Continuous Integration Summary

2010-08-16  来源:本站原创  分类:Java  人气:416 

First, what is continuous integration (Continuous Integration)?

This term has been in the field of software development lasted N years, a relatively simple definition as follows:
Continuous Integration (CI) is a practice that allows teams to receive feedback on an ongoing basis and make improvements, do not wait until late in the development cycle to find and fix defects. Popular little that means for developers to submit each code are automatically in the Repository Check out all the code into an empty directory, and automatically run all of Test Case. If successful, the submission is accepted, otherwise, all told, this is a failure of Revision. More specific explanation can refer to Martin fowler of Continuous Integration.

Second, the value of continuous integration and cost

There is a stylish case, called "There shall be reasonable." Continuous integration has been in existence since a long time, and there is no sign of disappearing, it is valuable. Then its value? It was summarized as follows: (1) reduce the risk; (2) reduction of manual processes; (3) Construction of the results generated; (4) sense of security.
The cost of continuous integration is to integrate the code for continuing maintenance costs and integration time cost. Because with the projects, hardware and software environments will become increasingly complex and will continue to expand product code. At this point, the team needs to modify or increase the original test code to adapt to these changes, the same time, each has become a long integration time, which is sustained integration costs. Mentioned in a blog said: "This integration is so frequent, how many times have the code number of continuous integration Commit. Provided that the low cost of integration, or is completely automated."

Third, continuous integration what should be automated?

We should cost as little as possible to get as much value. This automation should consider what is necessary to your friends. Jez Humble said there are at least six to be automated, they are (1) to run automated tests; (2) automatically generate the deployment of the binary product; (3) automatically will automatically deploy to the approximate finished production; (4 ) CodeBase automatically marked with labels; (5) automate regression testing; (6) automatic generation of measurement reports.

Fourth, the choice of continuous integration server

Before carrying out continuous integration practice, should be the right choice and configure continuous integration server. Continuous integration server more mature, including: CruiseControl, Anthill, Bamboo, TeamCity, Continuum, etc.. CruiseControl as an open source product, with its variety of SCM and build tools for the broad support of the development team has been accepted by many. The development automation expert Duvall consistent assessment criteria and many illustrative examples, describes some of the open source CI servers, including Continuum, CruiseControl and Luntbuild. And pointed out that "according to their specific technical and policy requirements of the tools to analyze." With the following five indicators to assess the CI tools, they are: (1) properties; (2) reliability; (3) life; (4) the target environment; (5) ease of use. The results listed below:

Which is the only thing I really used CruiseControl continuous integration tool, it is now flexible and powerful features let me stare, and configuration and management much easier than two years ago, friends. Why is it stronger? Because you want as long as the problem, it will be considered. Friends of the Blog CruiseControl best practices on some proof that, as long as you are willing to practice.

5, only the continuous integration server is not enough

As Jez Humble said, CruiseControl and other CI tool is essentially just a timer, when the time comes, do you let it do. Therefore, government must integrate with other tools, Fang was the true nature of continuous integration. These tools then what is it? Want to test it, you have to use some testing tools such as JUnit, JWebUnit, Selenium, etc.; want to check the code standards, you should check with the checkstyle tool such as coding standards; want to understand test coverage, you may have to used JCoverage Rights. Of course, want a binary file, we must use Ant, Make tools like friends.

6, the most important thing: Practice and Reflection

Maybe we all know these things, and some people may have practiced Rights. No matter what the results of these practices, and must not forget the summary and reflection. If the practice is successful, do not attribute it to this tool, but to sum up why would succeed, if you wish, also can share with you. If the practice fails, do not take it due to the tool, but to reflect on whether the proper use of this tool, team members are all like this tool, and why?

CruiseControl CI server is the old man, the birth has been for many years, in many ways, CruiseControl continuous integration server that has become synonymous with the practice. Now, CruiseControl has developed into a family system, including,, CruiseControl.ruby adapt to different language environments such as the realization of its powerful ability to plug-ins and extensions are also a number of similar systems can not be more than you. In here, I introduced the family of capitalists, or CruiseControl. CruiseControl is a good continuous integration server, but the general response of the domestic community is: its configuration is too troublesome, no start. From the beginning of this article, I will gradually introduce the environment CruiseControl build and configuration, and ongoing integration of some of the practice. We will use the simplest way (stand-alone) start, so you can quickly begin your journey continued integration, without having to face the "strange" problems.
Good! Let us briefly set up a continuous integration server to say it

First, I use CruiseControl version

1. CruiseControl is a java open source project, I will be a branch of its most recent version to introduce its use. CruiseControl recently released version is V2.8.1. Version of this branch is based in V2.8.1.
2. This branch contains a version of Dashboard, you can easily see that the purpose of building the state.
3. The branch version of the course also supports multiple Build Loop, you can deploy on multiple machine independent Build Loop, to build your own Build Grid.

Second, get the branch version of CruiseControl

To get this branch version, you can use subversion without any code detected from the CruiseControl's Repository. Command as follows:
svn checkout https: / / / svnroot / cruisecontrol / branches / cce / cruisecontrol /

Third, build CruiseControl

0. You have to install machines at least JAVA 1.4, and set the environment variables have JAVA_HOME, and the java / bin to path in. CruiseControl comes with ANT, so we do not pre-installed.

1. CruiseControl build from source code

If you build from source in CruiseControl, make sure your machine can access the Internet. Because the build process to check the number of license. In addition, preferably SVN client software, as in building, it will be used javahl.
In just checkout out the CruiseControl directory, there is a batch file named release.bat. Run the batch file, you will find in the target directory, a compressed file, name it Unzip to a directory, unzip to C we have here under the root directory. Decompression, the directory structure is as follows:
Directory structure
2. Directly use the CruiseControl build completed
If you do not want to do this step can also be found in the binaryrelease directory after extracting the files, copy them to the appropriate directory also.

4, run CruiseControl

CruiseControl can run on multiple application servers, of course, it is itself an open source application server bundle that Jetty 6. In order to expedite the establishment of our environment, we are here for the time being to use its own bundled Jetty, rapid integration to begin our journey continued.
Direct run CruiseControl directory CruiseControl.bat, that it will start Jetty6, when seen from the Console after it starts, you can visit in your browser http://localhost:8080/dashboard, then you will see example of a project called connectFour Dashboard on the show.

Build Dashboard

(If you are fast enough, you will find a small box on the Dashboard is a change from gray to dark green. Why? Us later.)
"Green" building by the project, said. If we are to have multiple projects, it should see several small boxes.

Click the "Builds" Tab page, Builds on to the page. This page will list all the items displayed. At present only one project, so only a single line in the list, as shown below:
Builds Page
Click on an item on that page, it will open the Build Detail page shows the latest Build the project information. Page on the right is all the history of the project construction information. You will find, when connectFour project has two built version of history, a building just completed, another is building two years ago. This information is from the CruiseControl log file for the project. At this point, click on these two results in any one building, will open the second building of the Build Detail page shows information related to the construction of history. As shown below:
Build Detail

We will brief the next article CruiseControl configuration file, you add your own building project preparation.

Previous article, we have seen CruiseControl to work. Next we first understand one of its configuration file, and then join your project.
CruiseControl configuration file is indeed a complex, partly because: it is too flexible, too would like to complete any of you want to achieve the effects. On the other hand is: It is indeed behind the aspect of the document. You can only find the answers in the user group. (However, this is a way of learning. If you understand open source, you will be used to find an answer in the user group friends.)

Find out about the configuration file, let us first define what we might use the term.

1. The working directory (ie CruiseControl working directory): refers to the start CruiseControl script directory. In Stand-alone case, that is, the directory where the file cruisecontrol.bat. If you deploy it to the application server, it usually means the bin directory on a.

Log directory

: Construction of the project is the CruiseControl log information stored in all the directory, the default value of the work directory called logs directory.

Projects directory:

CruiseControl build projects that stores all the source code directory, the default value of working directory named projects directory.

1, the profile and the correct location

Configuration file includes two, one named

And the other named

. By default, these two documents and cruisecontrol.bat look at the same directory, that is the working directory


If the configuration file, without any path in front of "/", then it is relative to working directory


In addition, CruiseControl can change their position, but suggested that in the absence of in-depth understanding of CruiseControl, do not try to change them, because our goal is to make CruiseControl in the shortest possible time for you to create value.

Second, Config.xml file

<project name="connectfour"> - the name should be here in the projects directory to your project name exactly.

<listeners> - for monitoring project status changes (refer to building, passed, etc.)
<currentbuildstatuslistener file="logs/${}/status.txt"/> - here's $ (
</ Listeners> means "connectfour"

<bootstrappers> - for CruiseControl update code from the Repository
<svnbootstrapper localWorkingCopy="projects/${}" />
</ Bootstrappers>

<modificationset quietperiod="30"> - for monitoring the quietperiod seconds, Repository if changes
<svn localWorkingCopy="projects/${}"/>
</ Modificationset>

<schedule interval="300"> - for every interval seconds, CruiseControl and plan a building to check
<ant anthome="apache-ant-1.7.0" buildfile="projects/${}/build.xml"/>
</ Schedule>

<log> - used to be and save the log file. By default, will be on projects / $ ( directory
<merge dir="projects/${}/target/test-results"/> - used to generate the results of the merger Build
</ Log> to a log file

<publishers> - used to build the results (such as binary files) published to a specified location
<onsuccess> - decided to build a successful case, what release
<artifactspublisher dest="artifacts/${}" file="projects/${}/target/${}.jar"/>
</ Onsuccess>
</ Publishers>

</ Project>
</ Cruisecontrol>

Third, dashboard-config.xml

<? Xml version = "1.0" encoding = "UTF-8"?>
<! -
/************************************************* *******************************
Here some statements omitted
************************************************** ******************************/
logsdir = "" - logs directory specified here must be consistent with the config.xml file, otherwise you will have trouble.
If the empty string, the default working directory for the logs directory.
artifactsdir = "" /> - artifacts directory specified here must be consistent with the config.xml file
If the empty string, the default working directory for the artifacts directory.
<features allowforcebuild=""/> - whether built in the Dashboard on the force (force build)
<trackingtool projectname="" baseurl="" keywords=""/> - This is used for integration with Mingle
<subtabs> - Here, you can expand your own subtab own page, but first to achieve a number of interfaces.
<subtab />
</ Subtabs>
</ Dashboard>

4, the configuration file notes

1, if the logs, artifacts and projects directory does not exist, before you run CruiseControl to manually create them.

2, make sure that the configuration file logs / artifacts directory point to the same directory. Because CruiseControl core of which will write data to, and Dashboard will read data from.

V. Tips

In Config.xml file, there are several elements to clarify the concept of first (only for the current example, strictly defined, see CruiseControl documentation).

1. <listeners> Used to monitor state changes, such as waiting for build, queued, building. Generally do not change.
2. <bootstrappers> For the detection code, CruiseControl there are many bootstrapper, the sample using SVN. localWorkingCopy property refers to the code you install CruiseControl machine detection to which file directories.
3. <modificationset> Repository for monitoring changes in frequency, if there are changes CruiseControl find the code, but in no other users within seconds quietperiod check-code (the version used to guarantee the integrity of being built), CruiseControl code will be detected.
4. <schedule> CruiseControl to check the Repository for the specified time interval. And specify which build file. Example using ant script to build the project file is being detected in the root directory of the build.xml (that is, in Repository in).
5. <log> CruiseControl to log on to specify where the results of which build on the log. If you do not specify any attributes, the default for the logs directory $ ( directory.
6. <publishers> For the end of the building, which published news and documents. CruiseControl plug-ins can do many kinds of Publishing. For example, in building a successful, through the http call to the specified page, or you can mail to the designated person. In failure, play music, informed team.

Well, now we have to build their own machines, a continuous integration server, and a preliminary understanding of its configuration files. In this article, we should add them own projects. As a starter example, we need to state what assumptions to enable us to rapidly advance our deployment process.

First, preparatory work (please confirm)

1, your program code on Google Code above (Google Code using a SVN), the name of your project is yourprojectname, the project's source files are placed under the trunk directory. Then, the svn update the links as follows: CruiseControl will update the file, not modify the source code, so anonymous detected on it.

2, your project is a JAVA program to build with ANT build file named build.xml, on the project's root directory, the default ant task called all. Make sure the file in which all paths are relative to the project root directory, to Copy to any directory, ant all can run correctly. (Our main Mudi is to establish the environment, Shi Qi Zai Jin Hou's development can Fahuizuoyong, Er Bu Shi to find Women in Cuowu build script.)

3, your CruiseControl working directory is C: / CruiseControl, convenience, the following will be replaced with $ (CC_HOME).

4, your logs directory is $ (CC_HOME) / logs. If you do not own the words of configuration changes, its location on the mentioned above.

5, your projects directory is $ (CC_HOME) / projects. If you do not own the words of configuration changes, its location on the mentioned above.

6, your artifacts directory is $ (CC_HOME) / artifacts. If you do not own the words of configuration changes, its location on the mentioned above.

Second, to join the project

1, manual detection of file:

To ensure that your project code detection to the $ (CC_HOME) / projects / yourprojectname directory, that directory is in the root directory of your project, you can find the file named build.xml.

2, modify the configuration file (add to your project)

Add the following code to config.xml file, located in <CruiseControl> node.

<project name="yourprojectname"> - here must be with your projects directory under the project name the same

<currentbuildstatuslistener file="logs/${}/status.txt"/>
</ Listeners>

<svnbootstrapper localWorkingCopy="projects/${}" />
</ Bootstrappers>

<modificationset quietperiod="30">
<svn localWorkingCopy="projects/${}"/>
</ Modificationset>

<schedule interval="300"> <ant anthome="apache-ant-1.7.0" buildfile="projects/${}/build.xml"/>
</ Schedule>

<merge dir="projects/${}/target/test-results"/>
<! - In the above sentence, we must ensure that the building failed to find the dir, if not, delete this element OK ->
</ Log>

<artifactspublisher dest="artifacts/${}" file="projects/${}/target/${}.jar"/>
<! - In the above sentence, make sure you pack out the file name is yourprojectname.jar ->
</ Onsuccess>
</ Publishers>

</ Project>

The final document is as follows:

<project name="connectfour">

<currentbuildstatuslistener file="logs/${}/status.txt"/>
</ Listeners>

<svnbootstrapper localWorkingCopy="projects/${}" />
</ Bootstrappers>

<modificationset quietperiod="30">
<svn localWorkingCopy="projects/${}"/>
</ Modificationset>

<schedule interval="300">
<ant anthome="apache-ant-1.7.0" buildfile="projects/${}/build.xml"/>
</ Schedule>

<merge dir="projects/${}/target/test-results"/>
</ Log>

<artifactspublisher dest="artifacts/${}" file="projects/${}/target/${}.jar"/>
</ Onsuccess>
</ Publishers>

</ Project>

<project name="yourprojectname">

<currentbuildstatuslistener file="logs/${}/status.txt"/>
</ Listeners>

<svnbootstrapper localWorkingCopy="projects/${}" />
</ Bootstrappers>

<modificationset quietperiod="30">
<svn localWorkingCopy="projects/${}"/>
</ Modificationset>

<schedule interval="300">
<ant anthome="apache-ant-1.7.0" buildfile="projects/${}/build.xml"/>
</ Schedule>

<merge dir="projects/${}/target/test-results"/>
</ Log>

<artifactspublisher dest="artifacts/${}" file="projects/${}/target/${}.jar"/>
</ Onsuccess>
</ Publishers>

</ Project>

</ Cruisecontrol>

Third, look at the results

(1) CruiseControl will automatically update the configuration file, loading time is normally no need to check whether a project update.

(2) you will see this item on the Dashboard is the first gray box, because the project had never been built in the CruiseControl without any historical information, we call the project as "inactive".

(3) After a while, you will see a circular dynamic icon that it is built (the implementation of the build.xml script).

(4) When the circular dynamic icon disappears, you will see it turns red (if the build fails) or green (if the build is successful).

I added to the project name is vcdstore, now I have two items of the dashboard.


(1) of the CruiseControl auto-detection code is not supported for the first time, so you have to first detection of the project code by hand to the local.

(2) If your SVN to update the code to use https, you must be detected in the command line code, and choose to accept the certificate permanently.

(3) CruiseControl version of this branch does not support an increase in the UI on the project.

(4) If you are in your config.xml file deletion, do not delete its log, you can still be seen in the Dashboard on the project, then it is marked as "Discontinued", that you can see to its historical information, but CruiseControl will not build it.

Next we will talk about some of the interface information elements CruiseControl.

Now, we have established for their continuous integration server project. Let us look at CruiseControl is what you said.

First, the status of the project

First of all, the project is divided into three categories CruiseControl, Discontinued, Inactive, and Active.

If an item is Discontinued, that CruiseControl can find the log file of the project, but in the configuration file (Config.xml) and they have not the file. So do not go CruiseControl build it, but you can see this project built over the past historical information. If you want to remove this item from the CruiseControl, only to the project log directory to delete Caixing. If the project is named "vcdstore", catalog when that is $ (CruiseContor.Home) / logs / vcdstore.

If a project is Inactive, that CruiseControl in the configuration file (Config.xml) found the item, but did not find any history on this item of information, that CruiseControl log directory not the project's log file, or log file is artificially removed. CruiseControl configuration information based on examination of this project and to build the new version. When the first building is completed, CruiseControl will generate a log, the project will be converted to Active status was.

If a project is the Active, said that CruiseControl can find the log file of the project, but also in the configuration file (Config.xml) can find it. At this point, the project could be successfully constructed, it could be build failure, and may be constructed of.

Second, Dashboard

You can http://localhost:8080/dashboard access Dashboard.

There are four main Dashboard page, they are Dashboard, Builds, Build Details and Administatiorn.

(1) Dashboard

In the Dashboard you can see the status of all projects,
Red box

Construction of the project, said the latest failure.
Green box indicates that the project is successful the last build. Gray box indicates that the item may be Inactive, and it may be Discontinued.

When the mouse on the small box on, it will display the project's key messages. Click the small box, and will enter the Build Details page.

Dashboard page

(2) Builds

You can Builds page for a list of ways to see the status of all items, click on each list, can Build Details page.

If you ForceBuild configured for true, there is a button right in the list, you can force the project to build, without having to wait until its next inspection, do not have to wait until it has a version of the change.

(3) Build Details

This page lists the project details of a particular building, including what changes compared to the previous build, test, what, a detailed log output, if the build is successful, in the configuration file (config.xml) to configure The Artifacts will also be called Artifiacts the tab page to see.

List on the right of all the construction of the project list, click one of the building, you can get detailed information of the second building.

(4) Administration

About this page you can see and Configuration of two sub-labels.

In the About sub-tab, you can see the environment used by CruiseControl information, such as CruiseControl version number, operating system and JDK used versions.

In the Administration sub-tab, you can see the CruiseControl's Dashboard-config.xml file content. In this version does not support the amendment also removed the "Add Project" button.

3, CruiseControl Reporting

You can also link http://localhost:8080/ to access CruiseControl the Old Reporting.

Click the project name, you can see the details.

4, CruiseControl JMX console

You can also link http://localhost:8000/ to access the JMX console CruiseControl.

In the console click the project name (such as connectfour), can modify the project configuration, suspend / resume building and other projects.


(1) The above links are not modify the default configuration based on CruiseControl.

(2) behind the article, we will explain how to Build Grid to extend our CruiseControl build capacity.

If you have followed this Thread, so now you should have been able to use the CruiseControl continuous integration. If you have a lot of projects need continuous integration, it may have many projects at the same time build the phenomenon of waiting, so much so that the project team can not get timely feedback, this time on an integrated server, not enough. Here we have to expand our Build Grid bar.

First, the prerequisite conditions and assumptions

According to the preceding description, your first continuous integration server already running the. Here are the following assumptions to facilitate the subsequent description.

(1) the first continuous integration server platform IP address:, hostname is CI_One.

(2) in the first continuous integration server platform:

CruiseControl root directory is: C: / CruiseControl, the future use $ (CC.HOME) said.

CruiseControl the Projects directory is: C: / CruiseControl / Proects, in the future that use $ (CC.Projects).

CruiseControl's Logs directory is: C: / CruiseControl / Logs, the future use $ (CC.Logs) said.

CruiseControl's Artifacts directory is: C: / CruiseControl / Artifacts, in the future, said with the $ (CC.Artifacts).

(3) in the IP address you will:, hostname of the machine for the CI_Two deployment of a second continuous integration server.

(4) to make the machine named CI_One main server that is built on CI_Two log (Logs) and results (Artifacts) the Release to CI_One of $ (CC.Logs) and $ (CC.Artifacts) in.

(5) You will be built in CI_Two called CI_TWO_connectFour project, which also uses SVN as the project's SCM.

Second, preparations

(1) CI_One on $ (CC.Logs) and $ (CC.Artifacts) Make a shared directory, ensure CI_Two the two directory writable.

(2) can CI_Two on the CI_One of $ (CC.Logs) and $ (CC.Artifacts) two directories are mapped to two network drives, to name the other as the Z: /, and Y: /.

(3) CI_One on CruiseControl, the copy to CI_Two under the root directory on the C, that is for CI_Two, CruiseControl working directory is C: / CruiseControl. (Of course, you can also put a compiled CruiseControl generated copied.)

(4) CI_Two of $ (CC.Projects) directory, and set up a directory called CI_TWO_connectFour, the SVN checkout of the source code to this directory, and ensure that build.xml file in this directory.

3, second continuous integration server configuration

All in all the following work entitled CI_Two this machine.

(4) modify the configuration file config.xml, as follows:

<project name="CI_TWO_connectFour">

<currentbuildstatuslistener file="Z:/${}/status.txt"/>
<! - Please note that here the z: ->
</ Listeners>

<svnbootstrapper localWorkingCopy="projects/${}" />
</ Bootstrappers>

<modificationset quietperiod="30">
<svn localWorkingCopy="projects/${}"/>
</ Modificationset>

<schedule interval="300">
<ant anthome="apache-ant-1.7.0" buildfile="projects/${}/build.xml"/>
</ Schedule>

<log dir="Z:/">
<! - Please note that here the z: ->
<merge dir="projects/${}/target/test-results"/>
</ Log>

<artifactspublisher dest="Y:/${}" file="projects/${}/target/connectfour.jar"/>
<! - Please note where Y: ->
</ Onsuccess>
</ Publishers>

</ Project>
</ Cruisecontrol>

(5) modify the startup script

Open CruiseControl.bat file, locate the following line of code:

set EXEC =% JAVA_PATH%% = mx4j.server.MX4JMBeanServerBuilder-jar "% LAUNCHER%"% *-jmxport 8000-webport 8080-rmiport 1099

Add the following code:


To the above code, the final code is as follows:

set EXEC =% JAVA_PATH%% = mx4j.server.MX4JMBeanServerBuilder-jar "% LAUNCHER%"% *-jmxport 8000-webport 8080-rmiport 1099-dashboardrul : 8080/dashboard

Save the file.

4, run Build Grid

(1) run $ (CC.Home) in CruiseControl.bat, start CI_One the CruiseControl.

(2) run $ (CC.Home) in CruiseControl.bat, start CI_Two the CruiseControl.

5, access your Build Grid

(1) In any one machine can access CI_One, through a browser to access the following URL to see you build the project. Of course, you can use the hostname. CruiseControl built as a Jetty application server, version 6.1.

(2) You can also use http://CI_One:8080/ access CI_One the Old Reporting page, with http://CI_Two:8080/ visit CI_Two the Old Reporting. But you will find that you configure the project in CI_Two state of the Old Reporting page in CI_One are shown as ?????。 This is the Old Reporting limitations.


(1) To ensure that all projects (regardless of which machine in the building) the project name is different, otherwise, CruiseControl's DashBoard will select one of the project the same name, ignoring other items of the same name.

(2) CI_Two in the startup script, be sure to fill in the correct DashBoardURL parameters, to ensure that CI_One address and port.

(3) If the log file larger project, or build more use of memory in the startup script, you can increase the JAVA command line parameters, JVM memory expansion, so as to avoid OutOfMemory errors.

Stop here, CruiseControl entry papers over. Later, as CruiseControl advanced articles, I will also continue to introduce some details CruiseControl configuration.

CruiseControl inclined to automatically trigger a build of source changes, but still offers several ways to trigger the build time to meet the nightly building effect.

Before beginning configuration, first explain config.xml file, the relevant Project element attributes.

* Project element corresponds to a need to build your project. Of which:

o name for the specified name.

o buildafterfailed said the failure of this building, asking to continue to the next CruiseControl build.
+ When set to true, that if this build fails, even if no one is checking in code, one interval to, CruiseControl also build it.
+ When set to false, the table seeking if this build fails, if no one is checking in code, CruiseControl will not build it again.
o requireModification that need to change the source file to build it.
+ When set to true when, CruiseControl modificationset element according to the settings of the source file to be checked.
+ When set to false when, CruiseControl only settings under Schedule regular building elements.
+ The default value is ture.
o forceOnly that it can only be built by hand.
+ When set to true, the user can manually start the construction of the project.
+ When set to false, that the conditions that can automatically build, users can build by hand (provided in the dashboard-config.xml configuration must be true).
+ The default value is true.

In order to achieve the purpose of time building, first to document the project Project Config.xml element requireModification property is set to false.

1 hour trigger a

Schedule element of the interval set the property value 3600, means that plans to build one every hour, as requireModification has been set to false, so in any case, CruiseControl will build. For example:

<schedule interval="3600">
<ant anthome="apache-ant-1.7.0" buildfile="projects/${}/build.xml" />
</ Schedule>

Second, once a day to trigger

Schedule major elements using a variety of builder (such as ant, nant, rake, etc.) time properties. time property of the format hhmm, such as 2300 on that 23 o'clock.

<ant anthome="xxxxxx" buildfile="projects/${}/xxxxx.xml" time="2300"/>
</ Schedule>

Of course, you can also use the pause to specify the child element does not build in a certain period, such as during the day time is not built, other times every hour build time configuration can be expressed as follows:

<schedule interval="3600">
<ant anthome="apache-ant-1.7.0" buildfile="projects/${}/build.xml"/>
<pause starttime="0800" endtime="1800"/>
</ Schedule>

Third, once a week trigger

Schedule major elements using a variety of builder (such as ant, nant, rake, etc.) time and day attributes. day of the week in English and property value is not case sensitive, such as sunday.

<ant anthome="apache-ant-1.7.0" buildfile="projects/${}/build.xml" day="Sunday"/>
</ Schedule>

If you want to designate a specific time, you can also use the time attributes, such as Sunday's 23 o'clock can be expressed as follows:

<ant anthome="apache-ant-1.7.0" buildfile="projects/${}/build.xml" time="2300" day="Sunday"/>
</ Schedule>

Be noted that if construction of the project longer than the specified time interval, then the building would be less than the ideal number of times. For example, build a set hour, but the building takes time and a half hours.

In addition, day attributes do not support multiple days, that does not support the day = "Monday Wednesday Friday" this set up. If you want to build one, then every other day, can only use the Schedule of the interval property.

Personal recommendation, CruiseControl best to trigger the event was outside in a variety of Builder, but the current situation is: If the Builder does not support the time and day properties (eg exec), may not be as equipped as described above.

Continued integration of the seven best practices


Often submitted to the code
(Note: we should always be submitted, to submit a code, and has little impact on the system code to be submitted as soon as possible, so as to realize the benefits of CI, developers can make use of the latest changes to the code)

Do not submit the code can not be built
(Note: Do not build the code can not be submitted to the version control repository, in a repeatable way to compile and test code, version control repository to be submitted prior to the implementation of private building code)

Construction of an immediate repair can not be integrated
(Note: is not able to report a successful build. May compile error, test or examination failure, the database issue or deployment fails)

Developers write automated tests
(Note: In the CI system to run tests, all tests must be automated)

Must pass all the tests and review
(Note: The automated test and build just as important, not fully tested code that will lead to lower quality software)

Construction of the implementation of private
(Note: In order to prevent the integration build fails, developers should complete their unit testing, in their own local work in the simulation of an integrated IDE build)

Avoid building code can not be checked out
(Note: When integration build fails, do not remove from the version control repository in the new code. Otherwise, you must take the time to find some way to bypass the failure to build those errors, to compile and test code)

Building Automation
(Note: write automated build scripts, software projects to reduce manual, repetitive and error-prone process)

Construction of a single command execution
(Note: all need to build the code into the source code version control repository, so a single command can be constructed by the system)

Separation of the build script from the IDE
(Note: There are two reasons: 1. Each developer may use different IDE, and to identify each IDE (integrated development environment is divided into: eclipse (IBM), NetBean (SUN), IDEA, etc.) in the configuration the difference will be very difficult to document. 2.CI be no intervention in the case Xia perform automated construction, therefore, Kai Fa implementation of the automated build Jiaoben Ye should Nenggou You CI Executive)

Concentration place the software assets
(Note: Use the version control repository to store all the files, you can build a better realization of a single command. Moreover, the focus placed on software assets to prevent the "my machine is working," the situation, in this case, developers can not reproduce the defects occur in other environments)

Create a consistent directory structure
(Note: In order to be able to project development process removed from the version control repository of all the available portfolio)

Failed to build fast
(Note: the most vulnerable to possible errors or failures on the front, then, for processing)

Construction for all environmental
(Note: Improved Construction of configurability, the build script parameter, in all circumstances to create the software to work)

Construction of the use of specialized computer
(Note: You can greatly reduce the assumptions on the environment and configuration, when the developer was informed that the latest integration build fails, to prevent the library from the version control problem out of code)

CI server use
(Note: The IC server for continuous integration. Manual integration more complex)

Implementation of hand-built integration
(Note: only one person at a time can submit changes to the version control repository, effectively prevent the failure of the building, and is not suitable for large teams)

Implementation of the Rapid Construction
(Note: If the build takes a long time to complete, often the practice of CI will cast an unpleasant shadow.
Construction of the shorter integration time, the sooner you can receive the feedback information)

Construction phases
(Note: The first implementation of the initial integration "submit" or lightweight construction, set up to integrate the software and perform unit testing,
More comprehensive integration in the implementation of construction, including component testing, review and deployment)

Automated database integration
(Note: Ant provides a task, through the sql task to execute SQL scripts, in a serialized manner database integration)

Using the local database sandbox
(Note: Creating a database of local examples of his workstation in the database changes, testing changes will not affect others, modify, test and will be submitted by post to the version control repository)

Version control repository using a shared database of assets
(Note: all database assets are put version control repository, version control repository using a script from scratch to create the database, reducing the project to all developers have modified the database by the DBA to find the bottleneck caused by)

Allow developers to modify the database
(Note: for every developer can modify any part of the database script, not every developer will be to modify the database script, because each developer has its own database sandbox)

To be developed by a DBA
(Note: for DBA to become a member of the development community, so convenient for developers to modify the database)

Automated Unit Testing
(Note: to make unit testing (ie testing) automated)

Automated component test

(Note: verify that all parts of the system may need to install the entire system or some external dependencies, typical of the underlying database needs to support component testing, or even across the border architecture)

Automated System Test

(Note: the overall effect of the project to automate testing.)

Automated functional testing
(Note: to test the functions of the project, which is the perspective from the customer to test the application, the test will mimic the behavior of customers.)

Classification of the developer test

(Note: the content of the developer test to classify management.)

First test the implementation of the fastest

(Note: The first test implementation of the most easy way)

Written test for the defect

(Note: write test cases for the defect, the ongoing implementation and repair test, up until the test no longer fails)

To test reusable components

(Note: the database of the test. Will the information database inconvenience. So you have to simulate a test database for testing. Through the XML data that can be achieved in the insert, update, and delete files. Configuration specific to the database for our test)

Will be limited to an assertion test cases (a test in only one Assert ..)

(Note: Set the number of assertions, an assertion that any failure will not perform the following assertion. Limitations into a claim that, no interference)

Reduce the code complexity

(Note: The code is complex: if else such as logic and common code duplication code so complex circle degree usually associated with defects, code complexity is too high will increase the risk of procedure)

Ongoing design review

(Note: always look at the code of the coupling. Two metrics help determine the situation of over-coupling (coupling incoming and outgoing coupling) reflects the maintenance of a framework for the problem. By coupling measure which will have XML and HTML format format of the report. to correct the situation out of control before)

Through code reviews to maintain the standards organization

(Note: The continuous monitoring and review of the code, your team can maintain compliance with the structure and coding guidelines. The problem can be found early, often find that in order to avoid long-term maintenance issues)

Reduce duplication of code

(Note: Repeat the code to bring the issue: 1. Increased maintenance costs, as many times as necessary to detect, report, analyze and repair defects. 2. Not sure whether there are other defects. 3. For additional code written in increased cost of testing. use common, reusable, abstract behavior or good framework to solve the code duplication problem)

Determine code coverage

(Note: The test equipment typically used to execute code, and record the testing process, "contact" to the corresponding code data. To get code coverage. Code coverage the higher the note you write code more excellent)

Software release can work anywhere, anytime

(Note: at any time, any circumstances release the software to work)

Assets for the library to tag

(Note: to create a version control repository of tags help identify and track assets. To tag the version control repository, the equivalent of a snapshot, in the worst case, can be used as the basis for rollback. These labels makes version control library allows the existence of parallel branches, it also provides a processing capacity of a number of development line)

Get clean environment

(Note: the last test before the test that is left clear records or procedures that may affect the factors, to avoid affecting the normal operation of the current program)

Each tag the build version

(Note: The version for each building to create a unique identifier, that is, "build version tag", which is intended to function, defective products or demand associated with the binary up)

Perform all tests

(Note: the implementation of all automated testing, from unit testing to functional testing. Or to the person after the test)

Create build feedback reports

(Note: Automatic Construction of generating feedback to help us understand the release build version of the exact situation
Construction documents, including version which is different from what repair defects, which features implemented, etc.)

Roll back the process of capacity building
(Note: to "remove" the deployment of an effective development of an important part. If you need to replace the previous version of the new defective code, probably because the previous version work better. Can build and version control repository version tag labels to obtain the desired version on it)

Use continuous feedback mechanism
(Note: The use of continuous feedback mechanism, continuous feedback from the construction project information to us. So that we can make timely processing)

In any software development process are an important part: get a reliable software to create (build) version. Although aware of the importance of creation, but we will still always surprised because the creation failure. In this article, we will discuss Matt (MatthewFoemmel) projects in the ThoughtWorks is an important process in the implementation of this process in our company more and more attention. It emphasizes the fully automated, repeatable creation process, including automated test several times a day to run. It allows developers to integrate the system each day, thereby reducing integration problems.
ThoughtWorks has opened CruiseControl software source code, which is an automated continuous integration tool. In addition, we also provide CruiseControl, Ant, and continuous integration consultancy services. If you need more information, please JoshMackenzie ([email protected]) link.

This article has the following main elements:

* Continuous integration integrates the advantages of more frequent, the better to create a successful What?
* Create a single code source automated test script from the code to create the code to return the main conclusion in the field of software development, a wide variety of "best practice", they often talk about it, but it seems very few have truly achieved. The practice of the most basic, the most valuable is: has created a fully automated, the testing process, so that development teams can create their software many times a day. "Date created" is also often discussed in a point, McConnell in his "Fast Software Development"
Japan will create a best practice as recommended by Microsoft, while Japan is also very well known to create a development methodology. However, we also support the XP community perspective: Japan to create just the minimum requirement. A fully automated process allows you to create many times every day, this can be done, and it is completely worth it.
Here, we use a "continuous integration (Continuous Integration)" the term, the term comes from the XP (Extreme Programming) is a practice. But we think: This practice already exists, and many do not consider people who are using XP with it. But we have been using XP as the standard software development process, XP is also on our terms and practices have a profound impact. However, you can just use the continuous integration, without having to use XP any other part of the - - in fact, we believe that: for any practical software development activities, continuous integration are fundamental components. Created to automate day to do the following components:
* All the source code stored in a single location, so everyone from here to obtain the latest source code (and previous versions).
* To create a fully automated process, so that anyone can enter only one command to create a complete system.
* To test a fully automated, so anyone can enter only one command to run a complete system test.
• To ensure everyone can get the latest, the best executable file.
All systems must be guaranteed. We found a project to the introduction of these systems takes considerable effort. However, we also found that once the system was established, to maintain its normal operation does not take much effort on a.
Advantages of continuous integration

Description of continuous integration is most difficult: it fundamentally changed the development model. If you do not practice continuous integration environment, worked hard for you to understand its development model. In fact, when working alone, most people can feel such an atmosphere - because they only need to integrate with their in the system. For many people, "team development" is the word they think of software engineering, the total area of some of the problems. Continuous integration reduces the number of these problems and replace them with a certain system.
Continued integration of the most basic advantage is: it completely avoids the developers have a "debugging session" - - before the developers will often need to open this, because someone at work when someone else stepped into the area, affecting someone else's code, the affected people do not know what happened, so bug will appear. This bug is the most difficult to investigate because the problem was not in a person's field, but the top two people sharing. Over time, the problem will gradually worsen. Usually, there's bug in the integration phase as early as weeks or even months before they existed. A result, developers need to phase in the integration of time and energy consuming to find the root causes of these bug.
If you use continuous integration, this bug can be introduced into most of the same day was found. Moreover, since a change in some of the day is not much, so you can quickly find the error location. If you can not find where is bug, you can not put these nasty code into the products. Therefore, even in the worst case, cause you just do not add features just bug. (When
However, you may request the new features is better than the hatred of the bug, but at least you can be more than one option. )
Until now, continuous integration can not guarantee when you catch all the integration of the bug. Continued integration of debugging capabilities depending on testing technology, we all know, testing can not prove that all the errors have been found. The key is to: Continuous Integration can catch enough time bug, which it has been worth the cost of the.
Therefore, continuous integration can reduce the integration phase of "courting" time consuming, and ultimately improve productivity. Although not yet know whether this method was carried out scientific research, but as a practical way, it is clear that it is quite effective. Continuous integration can significantly reduce the cost of "integration hell" in time, in fact, it can become a piece of cake to hell.
Integrated more frequently, the better

There is a continuous integration runs counter to the basic elements of intuition: the integration of regular is better than the little integration. For those who continued the practice of integration, this is very natural; but never practiced for continued integration of people, this is in contradiction with the visual impression.

If you are not always carried out the integration (less than once a day), then integration is a painful thing, will cost you a lot of time and effort. We often hear people say: "In a large-scale projects, can not be applied on to create" In fact, this is a very stupid point of view.
However, there are still many projects to practice continuous integration. In a 50 person team, two hundred thousand lines of code in the project, we integrated 20 several times a day. Microsoft has tens of millions of lines of code in the project insist on creating.
Continuous Integration has been feasible because the workload is twice integrated integration interval of time proportional to the square. Although we have not measured the specific data, but can be roughly estimated by: a week of work required integration is definitely not an integrated 5 times a day, but about 25 times. So, if you feel pain integration, perhaps show that you should be more frequent integration. If the method is correct, more frequent integration should be able to reduce your pain and let you save a lot of time.
The key is automated continuous integration. Most of the integration can and should be done automatically. Read the source code, compile, link, test, which can be done automatically. Finally, you should get a simple message, to tell you the success of this creation: "yes" or "no". If successful, this integration will stop here; If it fails, you should be able to very simply undo the last modification, creation of a successful return to the former. Throughout the creation process, all without moving your head.
With such an automated process if you want more frequent random can be created. The only limitation is to create the process itself will consume some time. (Yi Zhu: But with more time to catch up worms, this time is negligible.)
Continuous Integration

Creating a successful What?

There is one important thing needs to determine: how to create a truly successful? Looks very simple, but sometimes such a simple thing becomes a mess, it is worth noting. On one occasion, Martin Fowler to check a project. He asked whether the implementation of the project on creation, has been answered in the affirmative. Thanks to Ron Jeffries was present, he raised a question: "How do you deal with to create the error?" The answer is: "We send a person to the relevant e-mail." In fact, this project has not been successful for several months created. This is not the day to create, this is Japan's attempt to create.
The following "successful created" standard, we still very confident:
• All the latest source code configuration management system certification are eligible to re-compile all the documents are received by the target file (in our Java-class file is here) through connection, get the system started to run the executable file for the system test suite (in our tests here are about 150 classes) began to run all the steps, if no errors, no human intervention, all tests have passed, we have successfully created a vast majority of people that the "compiler + Connection = create." At least we think: Creating start the application should also be included for the application to run a simple test (McConnell called the "smoke test": turn on the switch to the software running, to see if it will "smoke"). Run a more detailed test set can greatly enhance the value of continuous integration, so we will be more detailed test of choice.
Continuous Integration

A single code source

In order to achieve the daily integration needs of any developer can easily access all the latest source code. Previously, if done once integrated, we must run all over the development center, asked every programmer has no new code, and then copied the new code, and then find insert location ... ... no worse than this of the.
Is very simple. Anyone should be able to clean the machine with a round, even on the LAN, then use a command to get all the source files, the system immediately began to create.
The simplest solution is: Use a configuration management (source code control) system as the source of all code. Configuration management systems are often designed with network capabilities and allow developers with easy access to the source code of the tool. Moreover, they also provide version management tool, so you can easily find previous versions of files. Costs not be a problem even more, CVS is a great open source configuration management tools.
All the source files should be saved in the configuration management system. I said that "all" is often even more than people think, it also includes the creation of scripts, properties files, database scheduling DLL, install scripts, as well as a clean machine to start creating all other things necessary. Often able to see this situation: the code under control, but some other important documents have disappeared.
Try to ensure that everything is stored in configuration management system with a source code tree. Sometimes in order to get different components, it will use the configuration management system in different projects. This is the trouble is: People have to remember which version of which components to use the other components of what version. In some cases, you must separate the source code, but the chances of this happening is much smaller than you think. You can code from a source tree to create multiple components, above those problems can be resolved by creating a script, without having to change the storage structure.
Continuous Integration

Create automated scripts

If you write is a small program, only a dozen files, then the application may only be the creation of what the command line: javac *. java. Larger projects will need to create more work: you may put files in many directories, need to make sure of the target code is in place; addition to compile, possibly connected steps; you may also from other file generated code, compiled into required before President; tests also need to run automatically.
The creation of large-scale often take some time, only had a little change, if, of course, you do not want to re-do all of these steps. So good of creation tools will automatically need to change part of the common way is to check the source file and target file modification date, and only when the source file modification date later than the target file, only to re-compile. Thus, the dependence between the files need a little skill: if a target file has changed, then only those who depend on it will be re-compiled object file. Compiler may deal with such matters, it may not.
Depending on their needs, you can choose to create different types: you create the system Keyi have test code there will be no, even can choose a different test set; some components can be individually created. You can create a script that should allow to choose different depending on the goal to build.
You enter the single line of command, to help bear the burden often you stir up the script. You may be using shell scripts, it may be more complex scripting languages (such as Perl or Python). But soon you will find a specially designed to create the environment is useful, for example, under Unix make tool.
In our Java development, we soon found that it needs a more complex solution. Matt spent considerable time developing an enterprise-class Java development for the creation of tools, known as Jinx. However, recently we have switched to open-source creation tools Ant Ant is very similar to the design and Jinx, also supports the Java Jar files to compile and packaged. Meanwhile, the preparation of the expansion is also very easy to Ant, which we can create more tasks to complete the process.
Many people use the IDE, the vast majority of IDE are included to create management functions. However, these documents are dependent on a particular IDE, and often more vulnerable, but also in order to work in the IDE. IDE users can create their own project file, and in their own separate development to use them. But our Lord created with Ant build process, and a run on the server using Ant.
Continuous Integration

Self-test code

Only the program to compile or not enough. Despite the strongly typed language, the compiler can point out many problems, but even if successful compile, the program may still leave a lot of mistakes. To help track these errors, we are very emphasize automated testing - - This is another practice advocated by XP.
XP will test into two categories: unit testing and capacity testing (also called functional testing). Unit test is written by the developers themselves, usually to test a class or a group class. Capacity test is usually tested by the customer or group of external developers to help in the preparation of the entire system end to end testing. The two tests we will use, and maximize the automation testing.
As part of creation, we need to run a group called "BVT" (Build Verification Tests, create validation testing) testing. BVT in all the tests must be passed before we can announce the creation has been a success. All XP-style unit tests are BVT. As the article is about the creation process, so we call the "test" basically means the BVT. Remember, in addition to BVT, there exists a test line (Yi Zhu: refer to functional testing), so do not BVT and the overall test, QA and so confused. In fact, our QA group does not pass BVT will not see the code, because they only create a successful test.
There is a basic principle: the same time in writing code, developers should also write the corresponding test. Complete the task, they not only have to return (check in) product code, but also the return of the code test. This is with XP's "test first" programming style is very similar: in the preparation of the corresponding test completed, and before that test fails, you should not write any code. So, if you want to add new features to the system, you should first write a test. Only when the new features have been implemented after the adoption of this test is possible. Then, your job is to make this test pass through.
We use the Java development of these tests, and development using the same language, written test and writing code is not much difference. We use JUnit ( as organization, preparation of test framework. JUnit is a simple framework, so that we can quickly write tests, the test organization for the suite, and to interactive or batch mode to run the test suite. (JUnit is a Java version of the xUnit family - - xUnit, including almost all the languages of the testing framework.)
In the process of writing software, in each build, the developers often run part of the unit test. This actually improves developer productivity, because these unit tests can help you find the logic error in the code. Then, you will not need to debug troubleshooting, only to note the last modified code after running tests on the line. The scope of change should be minimal, so finding a bug also much easier.
Not all of them strictly follow the XP "test first" style, but write in the first test of the benefits are obvious. They not only make everyone's job more efficient, and BVT posed by these tests to the system to better capture the error. As BVT run several times a day, so check out BVT is easier to correct any problems, and the reason is simple: We only quite small changes, so we can find in this range bug. In the revised course, a small piece of code debugging troubleshooting than tracking the entire system to be effective more.
Of course, you can not expect the test to help you find all the questions. As is often said: The test can not prove that the system does not exist error. However, perfection is not our only requirement. Imperfect test as long as the regular run, than ever could not write to the "perfect test" to be much better.
Another related question is: developers write tests for their code. We often hear people say: developers should not test their code, because they are easy to overlook the errors in their work. While this is true, but since the testing process needs to quickly test into the code base. This rapid conversion value exceeds the value of independent testers. Therefore, we use the developers write their own tests to construct BVT, but still prepared to accommodate an independent test.
Since the test is another important part of it through the feedback - - XP is a core value - - to improve test quality. Here's feedback from the escape from the BVT's bug. Self-test rule is: unless you add in the corresponding BVT test, otherwise it can not correct any errors. Thus, whenever the time to rectify a wrong, you must add the appropriate tests to ensure error BVT will not longer let the past. Moreover, this test should lead you to think more testing, more testing to enhance the preparation of BVT.
Continuous Integration

Lord created

Create automated process makes sense for a single developer, but it really light, or in the system's main creation (master build) generation. We found that the primary creation process allows the entire team come together so that they integrate in the early detection of problems.
The first step is to select the machine running the Lord created. We chose one called "catapult" the computer (we used to play "Age of Empires" J), this is a server with four CPU is very suitable to create specifically designed to do. (The complete creation will take a long time, so that horsepower is required.)
Create a process to keep running in a Java class at any time carried out. If you do not create tasks, create a process cycle has been to wait a few minutes to check each code repository. If at the end no one to return after the creation of any code, the process will continue to wait. If the code repository with the new code, it started.
The first phase created is completely extracted warehouse code. Starteam has provided us with some very good Java API, it is also very easy to cut into the code repository. Daemon (daemon) will observe five minutes before the warehouse, watching the last five minutes as people returned to the code there. If so, the daemon will consider the five minutes to extract the code (to prevent the return of others in the process of extracting the code).
Daemon will extract all the code to a directory catapults. Extraction is complete, the daemon will be in this directory call Ant scripts. Then, Ant will take over the entire creation process, all the source code to do a complete creation. Ant script is responsible for the compilation process, and to get the class file into the six-jar package, posted to the EJB server.
When completed Ant to compile and publish the work, the creation daemon will start running in the EJB server, a new jar, while starting to run BVT test suite. If all the tests can be run by normal, we get a

  • Continuous Integration Summary 2010-08-16

    First, what is continuous integration (Continuous Integration)? This term has been in the field of software development lasted N years, a relatively simple definition as follows: Continuous Integration (CI) is a practice that allows teams to receive

  • Continuous Integration brief summary 2008-09-09

    A theoretical articles: Continuous integration period as short as possible to encourage the project team to submit the code, while ensuring that every check in will not damage our building through. It is built with daily difference is that the code s

  • CruiseControl + SVN + Maven + Tomcat6 continuous integration build summary 2011-08-03

    Recently manager asked me to research and to build a continuous integration environment, so that, after continuous integration development will be very easy to developers to submit code to the end SVN, CruiseControl SVN code will detect whether the t

  • Continuous integration (transfer) 2010-04-12

    Continuous Integration Martin Fowler & Matthew Foemmel the transparent translation Martin Fowler Chief Scientist, ThoughtWorks Language Translator: January 23, 2002, we are honored to organize the Internet in exchange UMLCHINA listened to Mr. Martin

  • Continuous Integration: What should be automated? 2010-12-09

    First, what is continuous integration (Continuous Integration)? This term has been in the software development lasted N years, a relatively simple definition as follows: Continuous Integration (CI) is a practice that allows teams to receive feedback

  • Using Hudson for continuous integration (IX) 2009-01-13

    Building the track Translated: Hudson build allows you to create multiple tracks; based on your software development process, you may want to create more than one software project bas

  • Continuous integration best practices Maven 2009-01-20

    Translated: Continuous Integration is that you in the development process are often used as a best practice, it is efficient software development life cycle (SLDC)

  • The choice of continuous integration tools 2009-10-07

    Continuous Integration (continuous integration) as a cornerstone of agile programming is now the development team has been most widely used. And continuous integration tools are now also vary, each has its advantages, this paper compares the Java are

  • Continuous Integration essence of the theory (reproduced Matt) 2010-04-07

    Continuous Integration essence of the theory (reproduced) is a continuous integration principle of program development, which requires each member of the development team integrate their work frequently results, this frequency is usually at least onc

  • Continuous Integration (rpm) 2010-04-12

    Continuous Integration Martin Fowler & Matthew Foemmel a transparent translation Martin Fowler Chief Scientist, ThoughtWorks Language Translator: January 23, 2002, we are proud of the organization's online communication UMLCHINA heard the teachings o

  • Software development management best practices - on build and continuous integration 2009-09-11

    XP approach to software development as on building a best practice management; agile software development is also to ensure continued integrated software as a matter of principle the success of the project. Coincidentally, 2003 China's software ( 600

  • Early detection of defects through continuous integration 2010-04-10

    Continuous Integration (Continuous Integration, CI) is a continuous build, test, inspection and the deployment of the source code process. In many continuous integration environment, this means that whenever the source code management repository chan

  • Open-source book Continuous Integration with Hudson 2010-03-22

    Based on the technical books on open source software open source seems to be becoming a trend, we are familiar with the Subversion version control with Maven The Definitive Guide, I have recently learned that a book about Hudson's book is being open-

  • Continuous Integration using Hudson 2010-04-02

    Continuous Integration has become in many software development teams in the entire software development life cycle focused on common practices to ensure code quality. In this series, Nicholas Whitehead to introduce you to Hudson, a now very popular o

  • Ant build continuous integration 2010-02-25

    <!--**************************************************************************** * CruiseControl, a Continuous Integration Toolkit * Copyright (c) 2005, ThoughtWorks, Inc. * 200 E. Randolph, 25th Floor * Chicago, IL 60601 USA * All rights reserved. *

  • (Forward) Continuous Integration with Hudson - Tutorial 2010-03-14

    Source: Continuous Integration with Hudson - Tutorial Lars Vogel Version 0.5 Copyright © 2008 -2009 Lars Vogel 02.02.2010 Hudson This article describes how to build a continuous integr

  • Getting Started with Continuous Integration hudson 2010-04-07

    Extreme Programming in Practice is the continuous integration of a proposal, continuous integration is that in the development stage of projects ongoing on automated build, test, to achieve the control code quality means. Continuous Integration provi

  • What is Continuous Integration? 2010-05-10

    Reprinted from the Chinese network Scrum Integrated software process is not new problems, if the relatively small scale of project development, for example, a person's project, if it has a small external

  • Continuous Integration - the cornerstone of the first part of agile development 2010-05-10

    Reprinted from the Chinese network Scrum In recent years, agile software engineering is gradually picking up, quick books, articles, community, and various General Assembly is also increasing. Continuous

  • Continuous Integration - a cornerstone of agile development Part II 2010-05-10

    Reprinted from the Chinese network Scrum In the continuous integration - the cornerstone of agile development we introduced the first part of the concept of continuous integration and value, we have to i