Hi, 

I came across Gradle a couple of days ago while searching for the next build 
tool for our company. Reasons being build performance and better continuous 
integration. I must say I am mighty impressed with gradle and want to move our 
build system based on Make + ant combination. We use make for all core tasks 
and use ant to build java code, javadoc, junit and jar artifacts. 

I need some help in understanding how a migration to gradle can be achieved 
with minimum downtime and disruption to our source control. 

We have notion of projects which contain modules. Modules have acyclic 
dependencies and can depend on modules in other projects.  The make script has 
targets to resolve conflicts, to untar the dependencies and create a local 
binary repository by downloading dependecy artifacts from the SVN repository. 


Our svn organization is as follows 


rep 
 \___ project1 
  |      \ 
  |        module1 
  |         \____ trunk 
  |          |       \____   src 
  |          |        |                \____com 
  |          |        |                        \___ java packages 
  |          |        | 
  |          |        \____ 1.0 
  |          |                \____   src 
  |          |                        \____com 
  |          |                                \___ java packages 
  |          module2 
  |          \____ trunk 
  |                 \____   src 
  |                  |                \____com 
  |                  |                        \___ java packages 
  |                  | 
  |                  \____ 1.0 
  |                          \____   src 
  |                                  \____com 
  |                                          \___ java packages 
  | 
  \____ project2 
  |      \ 
  |        module1 
  |         \____ trunk 
  |          |       \____   src 
  |          |        |                \____com 
  |          |        |                        \___ java packages 
  |          |        | 
  |          |        \____ 1.0 
  |          |                \____   src 
  |          |                        \____com 
  |          |                                \___ java packages 
  |          module2 
  |          \____ trunk 
  |                 \____   src 
  |                  |                \____com 
  |                  |                        \___ java packages 
  |                  | 
  |                  \____ 1.0 
  |                          \____   src 
  |                                  \____com 
  |                                          \___ java packages 
  | 
  \____ binaries 
          \______ project1.1.0.tgz 
          \______ project2.2.0.tgz 


After going over gradle documentation I could compile one of the modules by 
consulting our local dependencies  as  file dependencies in about 5 lines of 
script, which convinced that gradle is the way to go. 

Specifically the issues I could not get my head around are 

1. Is our project/module/version organization consistent with gradle? Will we 
be able to use gradle effectively by sticking to this organization. Could not 
find useful documentation on how to organize projects / modules. 
2. Is it possible to have a custom implementation for the repository? Can we  
use tgz files from SVN as repository artifacts? 
3. How do we manage dependencies given our code organization ? 
4. Is hudson gradle plugin capable of reliable handling dependencies and 
automatically firing builds for dependent modules? 

Any help in this regard would be greatly appreciated. 

Thank and regards, 
 - Ashish 

PS: The original message  failed , but a reply went through. Reposting.
      Sorry for the inconvenience.

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email


Reply via email to