DOCSLIB.ORG

Gradle User Guide

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Gradle User Guide Gradle User Guide Version 2.2.1 Copyright © 2007-2012 Hans Dockter, Adam Murdoch Copies of this document may be made for your own use and for distribution to others, provided that you do not charge any fee for such copies and further provided that each copy contains this Copyright Notice, whether distributed in print or electronically. Table of Contents 1. Introduction 1.1. About this user guide 2. Overview 2.1. Features 2.2. Why Groovy? 3. Tutorials 3.1. Getting Started 4. Installing Gradle 4.1. Prerequisites 4.2. Download 4.3. Unpacking 4.4. Environment variables 4.5. Running and testing your installation 4.6. JVM options 5. Troubleshooting 5.1. Working through problems 5.2. Getting help 6. Build Script Basics 6.1. Projects and tasks 6.2. Hello world 6.3. A shortcut task definition 6.4. Build scripts are code 6.5. Task dependencies 6.6. Dynamic tasks 6.7. Manipulating existing tasks 6.8. Shortcut notations 6.9. Extra task properties 6.10. Using Ant Tasks 6.11. Using methods 6.12. Default tasks 6.13. Configure by DAG 6.14. Where to next? 7. Java Quickstart 7.1. The Java plugin 7.2. A basic Java project 7.3. Multi-project Java build 7.4. Where to next? 8. Dependency Management Basics 8.1. What is dependency management? 8.2. Declaring your dependencies 8.3. Dependency configurations 8.4. External dependencies 8.5. Repositories 8.6. Publishing artifacts 8.7. Where to next? 9. Groovy Quickstart 9.1. A basic Groovy project 9.2. Summary 10. Web Application Quickstart 10.1. Building a WAR file 10.2. Running your web application 10.3. Summary 11. Using the Gradle Command-Line 11.1. Executing multiple tasks 11.2. Excluding tasks 11.3. Continuing the build when a failure occurs 11.4. Task name abbreviation 11.5. Selecting which build to execute 11.6. Obtaining information about your build 11.7. Dry Run 11.8. Summary 12. Using the Gradle Graphical User Interface 12.1. Task Tree 12.2. Favorites 12.3. Command Line 12.4. Setup 13. Writing Build Scripts 13.1. The Gradle build language 13.2. The Project API 13.3. The Script API 13.4. Declaring variables 13.5. Some Groovy basics 14. Tutorial - 'This and That' 14.1. Directory creation 14.2. Gradle properties and system properties 14.3. Configuring the project using an external build script 14.4. Configuring arbitrary objects 14.5. Configuring arbitrary objects using an external script 14.6. Caching 15. More about Tasks 15.1. Defining tasks 15.2. Locating tasks 15.3. Configuring tasks 15.4. Adding dependencies to a task 15.5. Ordering tasks 15.6. Adding a description to a task 15.7. Replacing tasks 15.8. Skipping tasks 15.9. Skipping tasks that are up-to-date 15.10. Task rules 15.11. Finalizer tasks 15.12. Summary 16. Working With Files 16.1. Locating files 16.2. File collections 16.3. File trees 16.4. Using the contents of an archive as a file tree 16.5. Specifying a set of input files 16.6. Copying files 16.7. Using the Sync task 16.8. Creating archives 17. Using Ant from Gradle 17.1. Using Ant tasks and types in your build 17.2. Importing an Ant build 17.3. Ant properties and references 17.4. API 18. Logging 18.1. Choosing a log level 18.2. Writing your own log messages 18.3. Logging from external tools and libraries 18.4. Changing what Gradle logs 19. The Gradle Daemon 19.1. Enter the daemon 19.2. Reusing and expiration of daemons 19.3. Usage and troubleshooting 19.4. Configuring the daemon 20. The Build Environment 20.1. Configuring the build environment via gradle.properties 20.2. Accessing the web via a proxy 21. Gradle Plugins 21.1. Types of plugins 21.2. Applying plugins 21.3. Applying plugins with the plugins DSL 21.4. Finding community plugins 21.5. What plugins do 21.6. Conventions 21.7. More on plugins 22. Standard Gradle plugins 22.1. Language plugins 22.2. Incubating language plugins 22.3. Integration plugins 22.4. Incubating integration plugins 22.5. Software development plugins 22.6. Incubating software development plugins 22.7. Base plugins 22.8. Third party plugins 23. The Java Plugin 23.1. Usage 23.2. Source sets 23.3. Tasks 23.4. Project layout 23.5. Dependency management 23.6. Convention properties 23.7. Working with source sets 23.8. Javadoc 23.9. Clean 23.10. Resources 23.11. CompileJava 23.12. Incremental Java compilation 23.13. Test 23.14. Jar 23.15. Uploading 24. The Groovy Plugin 24.1. Usage 24.2. Tasks 24.3. Project layout 24.4. Dependency management 24.5. Automatic configuration of groovyClasspath 24.6. Convention properties 24.7. Source set properties 24.8. GroovyCompile 25. The Scala Plugin 25.1. Usage 25.2. Tasks 25.3. Project layout 25.4. Dependency management 25.5. Automatic configuration of scalaClasspath 25.6. Convention properties 25.7. Source set properties 25.8. Fast Scala Compiler 25.9. Compiling in external process 25.10. Incremental compilation 25.11. Eclipse Integration 25.12. IntelliJ IDEA Integration 26. The War Plugin 26.1. Usage 26.2. Tasks 26.3. Project layout 26.4. Dependency management 26.5. Convention properties 26.6. War 26.7. Customizing 27. The Ear Plugin 27.1. Usage 27.2. Tasks 27.3. Project layout 27.4. Dependency management 27.5. Convention properties 27.6. Ear 27.7. Customizing 27.8. Using custom descriptor file 28. The Jetty Plugin 28.1. Usage 28.2. Tasks 28.3. Project layout 28.4. Dependency management 28.5. Convention properties 29. The Checkstyle Plugin 29.1. Usage 29.2. Tasks 29.3. Project layout 29.4. Dependency management 29.5. Configuration 30. The CodeNarc Plugin 30.1. Usage 30.2. Tasks 30.3. Project layout 30.4. Dependency management 30.5. Configuration 31. The FindBugs Plugin 31.1. Usage 31.2. Tasks 31.3. Dependency management 31.4. Configuration 32. The JDepend Plugin 32.1. Usage 32.2. Tasks 32.3. Dependency management 32.4. Configuration 33. The PMD Plugin 33.1. Usage 33.2. Tasks 33.3. Dependency management 33.4. Configuration 34. The JaCoCo Plugin 34.1. Getting Started 34.2. Configuring the JaCoCo Plugin 34.3. JaCoCo Report configuration 34.4. JaCoCo specific task configuration 34.5. Tasks 34.6. Dependency management 35. The Sonar Plugin 35.1. Usage 35.2. Analyzing Multi-Project Builds 35.3. Analyzing Custom Source Sets 35.4. Analyzing languages other than Java 35.5. Setting Custom Sonar Properties 35.6. Configuring Sonar Settings from the Command Line 35.7. Tasks 36. The Sonar Runner Plugin 36.1. Sonar Runner version and compatibility 36.2. Getting started 36.3. Configuring the Sonar Runner 36.4. Specifying the Sonar Runner version 36.5. Analyzing Multi-Project Builds 36.6. Analyzing Custom Source Sets 36.7. Analyzing languages other than Java 36.8. More on configuring Sonar properties 36.9. Setting Sonar Properties from the Command Line 36.10. Controlling the Sonar Runner process 36.11. Tasks 37. The OSGi Plugin 37.1. Usage 37.2. Implicitly applied plugins 37.3. Tasks 37.4. Dependency management 37.5. Convention object 37.6. 38. The Eclipse Plugin 38.1. Usage 38.2. Tasks 38.3. Configuration 38.4. Customizing the generated files 39. The IDEA Plugin 39.1. Usage 39.2. Tasks 39.3. Configuration 39.4. Customizing the generated files 39.5. Further things to consider 40. The ANTLR Plugin 40.1. Usage 40.2. Tasks 40.3. Project layout 40.4. Dependency management 40.5. Convention properties 40.6. Source set properties 41. The Project Report Plugin 41.1. Usage 41.2. Tasks 41.3. Project layout 41.4. Dependency management 41.5. Convention properties 42. The Announce Plugin 42.1. Usage 42.2. Configuration 43. The Build Announcements Plugin 43.1. Usage 44. The Distribution Plugin 44.1. Usage 44.2. Tasks 44.3. Distribution contents 45. The Application Plugin 45.1. Usage 45.2. Tasks 45.3. Convention properties 45.4. Including other resources in the distribution 46. The Java Library Distribution Plugin 46.1. Usage 46.2. Tasks 46.3. Including other resources in the distribution 47. Build Init Plugin 47.1. Tasks 47.2. What to set up 47.3. Build init types 48. Wrapper Plugin 48.1. Usage 48.2. Tasks 49. The Build Dashboard Plugin 49.1. Usage 49.2. Tasks 49.3. Project layout 49.4. Dependency management 49.5. Configuration 50. The Java Gradle Plugin Development Plugin 50.1. Usage 51. Dependency Management 51.1. Introduction 51.2. Dependency Management Best Practices 51.3. Dependency configurations 51.4. How to declare your dependencies 51.5. Working with dependencies 51.6. Repositories 51.7. How dependency resolution works 51.8. Fine-tuning the dependency resolution process 51.9. The dependency cache 51.10. Strategies for transitive dependency management 52. Publishing artifacts 52.1. Introduction 52.2. Artifacts and configurations 52.3. Declaring artifacts 52.4. Publishing artifacts 52.5. More about project libraries 53. The Maven Plugin 53.1. Usage 53.2. Tasks 53.3. Dependency management 53.4. Convention properties 53.5. Convention methods 53.6. Interacting with Maven repositories 54. The Signing Plugin 54.1. Usage 54.2. Signatory credentials 54.3. Specifying what to sign 54.4. Publishing the signatures 54.5. Signing POM files 55. Building native binaries 55.1. Supported languages 55.2.
Load more

Recommended publications
  • Maksym Govorischev
    Maksym Govorischev E-mail : [email protected] Skills & Tools Programming and Scripting Languages: Java, Groovy, Scala Programming metodologies: OOP, Functional Programming, Design Patterns, REST Technologies and Frameworks: - Application development: Java SE 8 Spring Framework(Core, MVC, Security, Integration) Java EE 6 JPA/Hibernate - Database development: SQL NoSQL solutions - MongoDB, OrientDB, Cassandra - Frontent development: HTML, CSS (basic) Javascript Frameworks: JQuery, Knockout - Build tools: Gradle Maven Ant - Version Control Systems: Git SVN Project Experience Project: JUL, 2016 - OCT, 2016 Project Role: Senior Developer Description: Project's aim was essentially to create a microservices architecture blueprint, incorporating business agnostic integrations with various third-party Ecommerce, Social, IoT and Machine Learning solutions, orchestrating them into single coherent system and allowing a particular business to quickly build rich online experience with discussions, IoT support and Maksym Govorischev 1 recommendations engine, by just adding business specific services layer on top of accelerator. Participation: Played a Key developer role to implement integration with IoT platform (AWS IoT) and recommendation engine (Prediction IO), by building corresponding integration microservices. Tools: Maven, GitLab, SonarQube, Jenkins, Docker, PostgreSQL, Cassandra, Prediction IO Technologies: Java 8, Scala, Spring Boot, REST, Netflix Zuul, Netflix Eureka, Hystrix Project: Office Space Management Portal DEC, 2015 - FEB, 2016
    [Show full text]
  • Android Programming Cookbook I
    Android Programming Cookbook i Android Programming Cookbook Android Programming Cookbook ii Contents 1 Android Tutorial For Beginners 1 1.1 What is Android?...................................................1 1.2 Installing Android Studio...............................................1 1.3 Android versions and Android SDK Manager....................................7 1.4 Supporting different screen sizes...........................................7 1.5 Android Project Structure...............................................8 1.6 Create "Hello Android World" application......................................9 1.6.1 Create a New Android Studio Project....................................9 1.6.2 Create the source code of a simple FirstAndroidApplication Activity.................... 13 1.6.3 Create the layout of the project........................................ 14 1.6.4 Android Manifest............................................... 14 1.6.5 Edit the FirstAndroidApplication dimensions................................ 15 1.6.6 Edit the FirstAndroidApplication strings................................... 15 1.6.7 Add the drawable for every screen density.................................. 15 1.6.8 Build, compile and run............................................ 16 1.7 Download the Android Studio Project........................................ 18 1.8 How to continue?................................................... 18 2 Android Project migration from Eclipse to Android Studio 19 2.1 Why to use Android Studio over Eclipse ADT?..................................
    [Show full text]
  • Modern Web Development with Kotlin a Concise and Practical Step-By-Step Guide
    Modern Web Development with Kotlin A concise and practical step-by-step guide Denis Kalinin This book is for sale at http://leanpub.com/modern-web-development-with-kotlin This version was published on 2019-06-04 This is a Leanpub book. Leanpub empowers authors and publishers with the Lean Publishing process. Lean Publishing is the act of publishing an in-progress ebook using lightweight tools and many iterations to get reader feedback, pivot until you have the right book and build traction once you do. © 2016 - 2019 Denis Kalinin Contents Preface ...................................................... 1 Build tools ................................................... 4 Command line .............................................. 4 Gradle ................................................... 5 Editing source files .............................................. 9 Using Atom ................................................ 9 Using IntelliJ IDEA ............................................ 11 Language fundamentals ........................................... 13 Using the REPL .............................................. 13 Defining values .............................................. 13 Lambdas .................................................. 15 Type hierarchy .............................................. 16 Nullable types ............................................... 17 Collections ................................................. 18 Defining classes .............................................. 20 Defining objects ............................................
    [Show full text]
  • Code Smell Prediction Employing Machine Learning Meets Emerging Java Language Constructs"
    Appendix to the paper "Code smell prediction employing machine learning meets emerging Java language constructs" Hanna Grodzicka, Michał Kawa, Zofia Łakomiak, Arkadiusz Ziobrowski, Lech Madeyski (B) The Appendix includes two tables containing the dataset used in the paper "Code smell prediction employing machine learning meets emerging Java lan- guage constructs". The first table contains information about 792 projects selected for R package reproducer [Madeyski and Kitchenham(2019)]. Projects were the base dataset for cre- ating the dataset used in the study (Table I). The second table contains information about 281 projects filtered by Java version from build tool Maven (Table II) which were directly used in the paper. TABLE I: Base projects used to create the new dataset # Orgasation Project name GitHub link Commit hash Build tool Java version 1 adobe aem-core-wcm- www.github.com/adobe/ 1d1f1d70844c9e07cd694f028e87f85d926aba94 other or lack of unknown components aem-core-wcm-components 2 adobe S3Mock www.github.com/adobe/ 5aa299c2b6d0f0fd00f8d03fda560502270afb82 MAVEN 8 S3Mock 3 alexa alexa-skills- www.github.com/alexa/ bf1e9ccc50d1f3f8408f887f70197ee288fd4bd9 MAVEN 8 kit-sdk-for- alexa-skills-kit-sdk- java for-java 4 alibaba ARouter www.github.com/alibaba/ 93b328569bbdbf75e4aa87f0ecf48c69600591b2 GRADLE unknown ARouter 5 alibaba atlas www.github.com/alibaba/ e8c7b3f1ff14b2a1df64321c6992b796cae7d732 GRADLE unknown atlas 6 alibaba canal www.github.com/alibaba/ 08167c95c767fd3c9879584c0230820a8476a7a7 MAVEN 7 canal 7 alibaba cobar www.github.com/alibaba/
    [Show full text]
  • Maven Vs Gradle
    Maven vs Gradle This is a working document on the topic of converting from gradle to maven. If you add items / questions / etc, please tag and maybe color it (e.g., <dl>...) to make it easier to track things. Open questions / issues are in red. At a high level the motivations are: improve consumability of Edgent by users add publishing of signed Edgent binary release artifacts (JAR, WAR) in maven repos ultimately cease creating signed binary release bundles (tgz) simplify the build tooling the gradle scripting has some non-standard / complicated processing either out of ignorance or to achieve certain things TODO add the "why the complications" note here. (manifest classpath, binary bundle tgz with transitive deps, ...) Suspect that to simplify maven based tooling we'd need to eliminate some of those things (which would also simplify gradle stuff) Chris Dutz created PR-309 for working on a maven based system. PR-309 now includes a maven wrapper (mvnw). Set JAVA_HOME and then use "mvnw" instead of "mvn" below and you don't have to manually install maven. Or, to manually install maven https://maven.apache.org/download.cgi https://maven.apache.org/install.html Maven concepts: lifecycles, phases, goals, plugins High level building and testing mvn clean install # builds and tests add -DskipTests to omit testing, --fail-at-end for "continue"-like mvn clean package # a bit fewer phases than install mvn clean compile # even fewer/faster mvn site:site site:staging # see target/stagingindex.html mvn dependency:copy-dependencies # copies all dep
    [Show full text]
  • Verifying Android Applications Using Java Pathfinder
    Verifying Android Applications Using Java PathFinder by Heila-Marié Botha Dissertation presented for the degree of Doctor of Philosophy in Computer Science in the Faculty of Science at Stellenbosch University Supervisors: Prof. W Visser and Prof. AB van der Merwe December 2017 Stellenbosch University https://scholar.sun.ac.za Declaration By submitting this dissertation electronically, I declare that the entirety of the work contained therein is my own, original work, that I am the sole author thereof (save to the extent explicitly otherwise stated), that reproduction and publication thereof by Stellenbosch University will not infringe any third party rights and that I have not previously in its entirety or in part submitted it for obtaining any qualification. December 2017 Date: . Copyright © 2017 Stellenbosch University All rights reserved. i Stellenbosch University https://scholar.sun.ac.za Abstract Verifying Android Applications Using Java PathFinder H. Botha Department of Computer Science University of Stellenbosch, Private Bag X1, Matieland 7602, South Africa. Dissertation: PhD (Computer Science) November 2017 Current dynamic analysis tools for Android applications do not achieve acceptable code coverage since they can only explore a subset of the behav- iors of the applications and do not have full control over the environment in which they execute. In this work model checking is used to systemati- cally and more effectively explore application execution paths using state matching and backtracking. In particular, we extend the Java PathFinder (JPF) model checking environment for Android. We describe the difficul- ties one needs to overcome as well as our current approaches to handling these issues. We obtain significantly higher coverage using shorter event sequences on a representative sample of Android apps, when compared to Dynodroid and Sapienz, the current state-of-the-art dynamic analysis tools for Android applications.
    [Show full text]
  • Gradle in Action by Benjamin Muschko
    S AMPLE CHAPTER IN ACTION Benjamin Muschko FOREWORD BY Hans Dockter MANNING Gradle in Action by Benjamin Muschko Chapter 2 Copyright 2014 Manning Publications brief contents PART 1INTRODUCING GRADLE .................................................1 1 ■ Introduction to project automation 3 2 ■ Next-generation builds with Gradle 22 3 ■ Building a Gradle project by example 48 PART 2MASTERING THE FUNDAMENTALS .................................73 4 ■ Build script essentials 75 5 ■ Dependency management 105 6 ■ Multiproject builds 133 7 ■ Testing with Gradle 157 8 ■ Extending Gradle 191 9 ■ Integration and migration 223 PART 3FROM BUILD TO DEPLOYMENT ...................................247 10 ■ IDE support and tooling 249 11 ■ Building polyglot projects 282 12 ■ Code quality management and monitoring 310 13 ■ Continuous integration 337 14 ■ Artifact assembly and publishing 359 15 ■ Infrastructure provisioning and deployment 395 iii Next-generation builds with Gradle This chapter covers ■ Understanding how Gradle compares to other build tools ■ Describing Gradle’s compelling feature set ■ Installing Gradle ■ Writing and executing a simple Gradle script ■ Running Gradle on the command line For years, builds had the simple requirements of compiling and packaging soft- ware. But the landscape of modern software development has changed, and so have the needs for build automation. Today, projects involve large and diverse software stacks, incorporate multiple programming languages, and apply a broad spectrum of testing strategies. With the rise of
    [Show full text]
  • Security and Privacy of Secure Messaging Services
    Security and Privacy of Secure Messaging Services A Case Study of Wire DIPLOMARBEIT zur Erlangung des akademischen Grades Diplom-Ingenieur im Rahmen des Studiums Software Engineering & Internet Computing eingereicht von Andreas Boll, BSc Matrikelnummer 0825205 an der Fakultät für Informatik der Technischen Universität Wien Betreuung: Privatdoz. Mag.rer.soc.oec. Dipl.-Ing. Dr.techn. Edgar Weippl Mitwirkung: Univ.Lektor Dipl.-Ing. Dr.techn. Georg Merzdovnik, BSc Die approbierte gedruckte Originalversion dieser Diplomarbeit ist an der TU Wien Bibliothek verfügbar. The approved original version of this thesis is available in print at TU Wien Bibliothek. Wien, 3. März 2020 Andreas Boll Edgar Weippl Technische Universität Wien A-1040 Wien Karlsplatz 13 Tel. +43-1-58801-0 www.tuwien.at Die approbierte gedruckte Originalversion dieser Diplomarbeit ist an der TU Wien Bibliothek verfügbar. The approved original version of this thesis is available in print at TU Wien Bibliothek. Security and Privacy of Secure Messaging Services A Case Study of Wire DIPLOMA THESIS submitted in partial fulfillment of the requirements for the degree of Diplom-Ingenieur in Software Engineering & Internet Computing by Andreas Boll, BSc Registration Number 0825205 to the Faculty of Informatics at the TU Wien Advisor: Privatdoz. Mag.rer.soc.oec. Dipl.-Ing. Dr.techn. Edgar Weippl Assistance: Univ.Lektor Dipl.-Ing. Dr.techn. Georg Merzdovnik, BSc Die approbierte gedruckte Originalversion dieser Diplomarbeit ist an der TU Wien Bibliothek verfügbar. The approved original version of this thesis is available in print at TU Wien Bibliothek. Vienna, 3rd March, 2020 Andreas Boll Edgar Weippl Technische Universität Wien A-1040 Wien Karlsplatz 13 Tel.
    [Show full text]
  • USING the GROOVY ECOSYSTEM for RAPID JVM DEVELOPMENT Schalk W
    USING THE GROOVY ECOSYSTEM FOR RAPID JVM DEVELOPMENT Schalk W. Cronjé #ACCU2016 ACCU Bristol 2016 ABOUT ME Email: [email protected] Twitter / Ello : @ysb33r 1 2 SDKMAN Manages parallel version of multiple SDKs Mostly for (but not limited to) JVM-related systems Windows users can use Posh-GVM (Powershell) Windows 10 Bash ?? curl -s http://get.sdkman.io | bash 3 . 1 SDKMAN DEMO 3 . 2 SdkMan: http://sdkman.io Posh-GVM: https://github.com/ofreud/posh-gvm @sdkmanager 3 . 3 APACHE GROOVY A dynamic & static typed language for the JVM with REPL capability. 3 . 4 GROOVY VS JAVA In Groovy: All class members are public by default No need to create getters/setters for public elds Both static & dynamic typing supported def means Object 4 . 1 CALLING METHODS class Foo { void bar( def a,def b ) {} } def foo = new Foo() foo.bar( '123',456 ) foo.bar '123', 456 foo.with { bar '123', 456 } 4 . 2 CALLING METHODS WITH CLOSURES class Foo { void bar( def a,Closure b ) {} } def foo = new Foo() foo.bar( '123',{ println it } ) foo.bar ('123') { println it } foo.bar '123', { println it } 4 . 3 MAPS IN GROOVY Hashmaps in Groovy are simple to use def myMap = [ plugin : 'java' ] Maps are easy to pass inline to functions project.apply( plugin : 'java' ) Which can also be written as project.with { apply plugin : 'java' } 4 . 4 LISTS IN GROOVY Lists in Groovy are simple too def myList = [ 'clone', 'http://github.com/ysb33r/GradleLectures' ] This makes it possible write a method call as args 'clone', 'http://github.com/ysb33r/GradleLectures' 4 .
    [Show full text]
  • Reproducible Builds Summit III Berlin, Germany
    Reproducible Builds Summit III Berlin, Germany. October 31 – November 2, 2017 Event Documentation Aspiration, 2973 16th Street, Suite 300, San Francisco, CA 94103 Phone: (415) 839-6456 • [email protected] • aspirationtech.org Table of Contents Agenda..........................................................................................................................................4 Session Notes.............................................................................................................................10 Day 1.......................................................................................................................................10 Agenda brainstorming........................................................................................................10 Working sessions I..............................................................................................................17 Reviewing existing reproducible builds tools.................................................................17 Discussing the current status of .buildinfo files..............................................................22 What is the ecosystem around rpm?..............................................................................23 End user tools: What does exist, what is still needed....................................................25 Working sessions II.............................................................................................................27 How to fix the current issues with BUILD_PATH_PREFIX_MAP?.................................27
    [Show full text]
  • Tools and Processes for Creating and Maintaining Own Linux Based Distributions in Corporate Environment
    Tools and processes for creating and maintaining own Linux based distributions in corporate environment Juhani Heliö Helsinki April 28, 2017 UNIVERSITY OF HELSINKI Department of Computer Science HELSINGIN YLIOPISTO — HELSINGFORS UNIVERSITET — UNIVERSITY OF HELSINKI Tiedekunta — Fakultet — Faculty Laitos — Institution — Department Faculty of Science Department of Computer Science Tekijä — Författare — Author Juhani Heliö Työn nimi — Arbetets titel — Title Tools and processes for creating and maintaining own Linux based distributions in corporate environment Oppiaine — Läroämne — Subject Computer Science Työn laji — Arbetets art — Level Aika — Datum — Month and year Sivumäärä — Sidoantal — Number of pages April 28, 2017 70 pages + 17 appendices Tiivistelmä — Referat — Abstract Nokia has been maintaining its own Linux distribution, dubbed Nokia Linux, for quite some time, and while the distribution has been successful, supporting it has become tedious at very least. The current version of Nokia Linuxes build system builds a monolithic distribution. This creates a multitude of problems ranging from having to rebuild all of the distribution’s software packages after patching a single package to not being able to efficiently customise images according to user needs. The current version also lacks any kind of stable release management causing every user to either maintain their own stable releases or having to constantly update from the official version. Apart from being too monolithic, the support of the software packages is insufficient. An efficient support team needs to be created to answer any internal support requests Nokia Linux users might have. In this thesis we first define our corporate environmental needs. We identify three needs: support, storage and security. We then define three methods for organising the support.
    [Show full text]
  • Gradle User Guide
    Gradle User Guide Version 2.14.1 Copyright © 2007-2015 Hans Dockter, Adam Murdoch Copies of this document may be made for your own use and for distribution to others, provided that you do not charge any fee for such copies and further provided that each copy contains this Copyright Notice, whether distributed in print or electronically. Table of Contents I. ABOUT GRADLE 1. Introduction 2. Overview II. WORKING WITH EXISTING BUILDS 3. Installing Gradle 4. Using the Gradle Command-Line 5. The Gradle Wrapper 6. The Gradle Daemon 7. Dependency Management Basics 8. Introduction to multi-project builds 9. Continuous build 10. Using the Gradle Graphical User Interface 11. The Build Environment 12. Troubleshooting 13. Embedding Gradle using the Tooling API III. WRITING GRADLE BUILD SCRIPTS 14. Build Script Basics 15. Build Init Plugin 16. Writing Build Scripts 17. More about Tasks 18. Working With Files 19. Using Ant from Gradle 20. The Build Lifecycle 21. Wrapper Plugin 22. Logging 23. Dependency Management 24. Multi-project Builds 25. Gradle Plugins 26. Standard Gradle plugins 27. The Project Report Plugin 28. The Build Dashboard Plugin 29. Comparing Builds 30. Publishing artifacts 31. The Maven Plugin 32. The Signing Plugin 33. Ivy Publishing (new) 34. Maven Publishing (new) 35. The Distribution Plugin 36. The Announce Plugin 37. The Build Announcements Plugin IV. EXTENDING THE BUILD 38. Writing Custom Task Classes 39. Writing Custom Plugins 40. The Java Gradle Plugin Development Plugin 41. Organizing Build Logic 42. Initialization Scripts 43. The Gradle TestKit V. BUILDING JVM PROJECTS 44. Java Quickstart 45. The Java Plugin 46.
    [Show full text]