Distribuzione multi-progetto gradle

Question

Sto provando a creare una dist di una build a più progetti. Il progetto di root ha un aspetto simile al seguente:

apply plugin: 'distribution' 
version 1.0 
distributions { 
    main { 
     baseName = 'someName' 
     contents { 
      from 'nodes' 
     into 'nodes' 
     } 
    } 
} 

Copia semplicemente una cartella con alcuni file sul dist.

Ora desidero che ciascun sottoprogetto immetta le sue informazioni nel dist. Voglio aggiungere ogni jar dei sottoprogetti, eventuali dipendenze e possibilmente qualche altro file, ecc ...

Non ho idea di come iniettare dal sottoprogetto alla radice. Dovrei fare anche qualcosa del genere? Quello che voglio dire è qualcosa del genere:

subprojects { 
    apply java... 
    ... 

    // pseudocode 
    jack into the root project dist plugin 
    put my produced jars and dependencies in a folder with my name 
    ... 
} 

Qualcuno ha qualche esempio o semplicemente mi indica la giusta direzione?

grazie!

Answer 1

Stavo cercando la stessa cosa. Con un po 'sbirciare la documentazione API e propri file di generazione Gradle', sono venuto a quanto segue:

apply plugin: 'distribution' 

distributions { 
    main { 
     contents { 
      into('bin') { 
       from { project(':subproject1').startScripts.outputs.files } 
       from { project(':subproject2').startScripts.outputs.files } 
       fileMode = 0755 
      } 
      into('lib') { 
       def libs = [] 
       libs << project(':subproject1').configurations.runtime - project(':runner').configurations.runtime 
       libs << project(':subproject2').configurations.runtime 
       from libs 
       from project(':subproject1').jar 
       from project(':subproject2').jar 
      } 
     } 
    } 
} 

La chiusura contents {} è un CopySpec, sapendo che rende l'uso del plug-in di distribuzione modo più semplice :)

Controllare fuori il proprio sottoprogetto/distribuzioni/distributions.gradle file di Gradle per alcuni grandi esempi di utilizzo di CopySpec.

Questo funziona.

• La sottostruttura è di rimuovere i vasi duplicati.
• Le righe ".jar" devono aggiungere il jar di quel progetto poiché configurations.runtime sembra contenere solo la dependence.

Purtroppo, al momento non ho idea di come ridimensionarlo a più di due progetti in modo pulito. Almest siamo un passo avanti :)

Answer 2

Ho trovato una soluzione che ha funzionato bene per me. La chiave è che si aggiungere un sottoprogetto separato per creare il dist. Questo sottoprogetto è sibling per gli altri sottoprogetti. Cioè, non provare a codificare la distribuzione nel tuo file di livello superiore build.gradle.

Chiamiamo il nuovo sottoprogetto dist. La prima cosa da fare è quello di aggiungere al vostro livello superiore settings.gradle file nella root multi-progetto:

include "subproject1", "subproject2", "subproject3", ....... , "dist" 

Il progetto dist deve come minimo comprendere:

• build.gradle - per essere illustrati qui di seguito
• src/main/dist/at_least_one_dummy_file.txt - il plug-in di distribuzione richiede sempre una directory src/main/$distribution.name. Avere uno non vuoto con un distribution.name di main fa in modo che il plugin segua tutte le dipendenze transitive di tutti i sorgenti di main di tutti i progetti di pari livello.

Avanti, il file build.gradle per il progetto dist:

/* Hook in all sibling project jars and their transitive dependencies */ 
apply plugin: 'java' 
dependencies { 
    compile project(':subproject1') 
    compile project(':subproject2') 
    compile project(':subproject3') 
    . . . 
} 

/* Distribution */ 
apply plugin: 'java-library-distribution' 
distributions { 
    main { 
     baseName = "your-top-level-project-name" 
     contents { 
      exclude "dist-${version}.jar" 
      . . . 
     } 
    } 
} 

Quindi eseguire gradle distZip. Il file ZIP in dist/build/distributions avrà una sottodirectory lib con ogni singolo JAR desiderato: il progetto di pari livello JAR s e le loro dipendenze transitive.

A causa dell'astuzia che abbiamo utilizzato, il plug-in di distribuzione renderà uno JAR vuoto chiamato dist-${version}.jar. Per ragioni estetiche, lo rimuovo con la chiamata exclude qui sopra, ma è innocua. È anche possibile utilizzare una seconda chiamata exclude per rimuovere at_least_one_dummy_file.txt se non ci sono realmente contenuti in src/main/dist che si desidera includere. Se non vuoi aggiungere alcun artefatto e/o rimuovere quelli menzionati qui, non hai nemmeno bisogno di una sezione contents.

Ho anche trovato modi per includere selettivamente diversi artefatti in base al fatto che si tratti di una distribuzione "dev" o "prod", un profilo di La Maven. Se vuoi che lo aggiunga, per favore pubblica commenti e lo farò.

Answer 3

Realmente ho funzionato combinando gli approcci di entrambi, pvdissel e sparc_spread.

Nel mio progetto radice ho creato una directory src/main/dist dove ho inserito esattamente un file chiamato .gitkeep.

Il build.gradle del file del mio progetto principale si presenta come segue:

apply plugin: 'java-library-distribution' 

allprojects { 
    .... 
} 

dependencies { 
    // let root project depend on all subprojects that have the 
    // application plugin enabled 
    project.subprojects.each { p -> 
     p.plugins.withType(ApplicationPlugin) { 
      compile p 
     } 
    } 
} 

distributions { 
    main { 
     contents { 
      // exclude unnecessary files from archive 
      exclude ".gitkeep" 
      exclude "cs3d-toolbox-${version}.jar" 

      // add start scripts of all plugins that have the 
      // application plugin enabled to the archive 
      project.subprojects.each { p -> 
       p.plugins.withType(ApplicationPlugin) { 
        into('bin') { 
         from { p.startScripts.outputs.files } 
         fileMode = 0755 
        } 
       } 
      } 
     } 
    } 
} 

funziona abbastanza bene per me. Testato con Gradle 2.0.

Answer 4

Questa è la configurazione che sto utilizzando in un progetto con più librerie per creare un "rilascio" archivio:

apply plugin: 'distribution' 

distributions { 
    main { 
    baseName = libVersion 
    contents { 
     project.subprojects.each { sub -> 
     into('lib') { 
      from sub.jar 
     } 
     into('src') { 
      from sub.sourcesJar 
     } 
     into('doc') { 
      from sub.javadocJar 
     } 
     } 
    } 
    } 
} 

Utilizzando distZip compito crea un archivio con tutte le librerie con i file separati in tre cartelle (lib contiene i barattoli effettivi, src contiene barattoli con le fonti e doc contiene - avete indovinato - barattoli Javadoc).