On 7/18/07, bhatia <[EMAIL PROTECTED]> wrote:
Hello Xavier,
Please do not address your questions to me, this is a public mailing list, anybody can give opinion, and I'm not always able to answer (lacking time, no experience in the field, ...). I know for the moment I'm answering quite a lot of questions, but it's probably because some other people actively involved in the community do not have time for the moment. It may be my case later, please don't always expect an answer from me, or contact me directly for consulting services if that's really what you want. Answer below... I need your inputs on how to use Ivy in our current development process.
Current Scenario Part1: Our developers use Eclipse/RAD7 currently and they checkout all project deps from CVS to compile a project. This was known to be taking lot of time and since Ivy is here, we have launched the Ivy Initiative to be able to compile a war or jar project in Eclipse without having to checkout all deps from CVS. I am able to get this part working fine whereby a developer just needs to call Ivy ant targets which do all the big bang needed to compile a jar or a war project in the workspace. For this to work, a developer needs only to add a build.xml file to his project home in Eclipse, and use my target to make an ivy file. Both these files can be a requirement to be able to tag a particular project for a specific env so that when the nightly build runs, it can locate the ivy.xml for this particular project for a particular env (dev1, dev2, dev3, pprod, prod, test). Part2: We also have a system by which we track which CVS version of a project in currently deployed in our following environments (dev1, dev2, dev3, pprod, prod, test). Our nightly build process recovers all sources from CVS for each of the environments mentioned above (so build process basically peeks into a database to find which version to checkout for which env) compiles, builds and makes the artifacts needed. To find the deps of a project, the build system reads the .project or .webSettings files. So for ex. a developer can run the following command on any of the servers: build dev1 WAR sso - the build system will checkout the sources and dependencies found in the sso project's .webSettings/.project files, compile and make the artifact before being deployed. Cuurent Progress: Part1: I am able to publish my artifacts (jars and wars) for a particular version e.g. HEAD, prod, dev1, ... from Eclipse using my Ivy targets without any problem. Part2: I have modified the system build so I can populate the ivy repository on a daily basis from artifacts produced by the system build. This repository can then serve artifacts which developers will be retrieving with Ivy in their local Eclipse workspaces. It now produces artifacts with the same pattern as used by the "internal" resolver in the Eclipse env. This is to ensure consistency while producing artifacts from the sys build and while producing from the Eclipse workspace. The questions are as follows: 1) How should I view these 2 entities that is the system nightly build and the RAD7/Eclipse env wrt Ivy ? System build and Eclipse can both be producers of artifacts both publishing to the repository and both are also consumers of each other's generated artifacts ? Is that correct ? 2) If both are producers and consumers, how should I generate artifacts using Ivy in the system nightly build ? Should the nightly build retreive deps from the common repository or should it check-out dependant projects afresh from CVS and compile and make them first before making the project and publishing it to the rep ? I dont think that its a good idea to download artifacts from the repository to make a new artifact. Probably would be better to read each project's ivy file and checkout fresh sources for each dep to make the project's artifact and then publish it. Is my understanding correct on these 2 critical areas ? What would you recommend ? On one side, we have a continuous nightly build process which needs to be Ivy-enabled and on the other hand I have the Eclipse workspace and both are producers of artifacts. I need your ideas to draw the lines as to who consumes whom.
I would make the nightly build compile from dependencies pulled from the repository, if you can ensure that all modules which have changed since last build will be built in the correct order (using ivy:buildlist for isntance). But I know some prefer to have one build trigger the dependencies build, this is possible with Ivy, it's simply that I prefer to see things in the opposite point of view, to minimize number of modules to build. But it also depends on the tool you use for your nightly builds, a continuous integration server with module dependencies management can be a good candidate to make sure your module build order is respected. For the difference between your RAD builds and server builds, I'd try to keep them as similar as possible, it's the best way to help developers find and fix issues. Now for the repositories, it depends which kind of version developers publish, and how frequently. I would better separate builds by status (integration, milestone, ...) than by builder (server, developer, ...). HTH, Xavier Many thanks
Saurabh -- View this message in context: http://www.nabble.com/software-development-process-with-Ivy-tf4103063.html#a11668083 Sent from the ivy-user mailing list archive at Nabble.com.
-- Xavier Hanin - Independent Java Consultant http://xhab.blogspot.com/ http://incubator.apache.org/ivy/ http://www.xoocode.org/
