Mailing-List: contact ivy-user-help@incubator.apache.org; run by ezmlm
Precedence: bulk
Reply-To: ivy-user@incubator.apache.org
Received-SPF: pass (herse.apache.org: domain of lists@nabble.com designates
 216.139.236.158 as permitted sender)
Message-ID: <11668083.post@talk.nabble.com>
Date: Wed, 18 Jul 2007 05:53:05 -0700 (PDT)
From: bhatia <Bhatia@OFAC.CH>
To: ivy-user@incubator.apache.org
Subject: software development process with Ivy
MIME-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit


Hello Xavier,

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.

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.