Showing posts with label Build Management. Show all posts

Thursday, July 5, 2012

Subversion configuration in windows

To create the repository, issue the following command:

svnadmin create c:/svnrepos

Create your SVN user: Now that your repository is successfully set up, you'll need to create an svn user. Simply open the file c:/svnrepos/conf/svnserve.conf of your choice and add the following:

anon-access = none
auth-access = write
password-db = passwd

Now you'll need to create a password file: Open passwd file which is located at

c:/svnrepos/conf/passwd

Add a line in that file for your user in the format =

Example_user_name = example_password

Run the svn service: open command prompt (run as administrator)

sc create svnserve binpath=
"\"C:\Program Files (x86)\Subversion\bin\svnserve.exe\" --service -r
C:\svnrepos" displayname= "Subversion" depend= Tcpip start= auto

sc - is command to create service in windows

svnserve- is service name

binpath : path to executiable file

--service - is to start service at startup

c:\svnrepos: folder which you created in C-drive well act as SVN Repository

displayname : service name in services console

Start = auto - automatic start at system boot

depend= Tcpip - works on ip Check out your repository onto your local machine: Back on your local machine, go to where you keep your nerd stuff. In my case it's in ~/workspace. Then use the svn co command to check out a copy of your project.

Test the repo-browser: (need to install TortoiseSVN)

right click on Desktop -> tortoiseSVN -> Repo-browser

svn://localhost -> test if it works internally

svn://192.168.20.204 -> (Example for external ip) test if it works remotely

Successfully Done..!

Suggestions are always welcome..! Without signing also you can send your comments.

Wednesday, June 22, 2011

Download and Install CollabNet Subversion in Solaris

CollabNet Subversion Download Link: http://www.collab.net/downloads/subversion/solaris.html

1. Platform and configuration

Product: CollabNet Subversion client

Platforms: Solaris 10 SPARC

Prerequisite: You must be a superuser (root) to install and uninstall

CollabNet Subversion.

2. Import/Update CollabNet certificate

CollabNet Subversion Solaris packages are signed. As a one-time task,

import the CollabNet certificate using the command:

sudo pkgadm addcert -ty certificate.pem

The CollabNet certificate is available for download at:

http://www.collab.net/nonav/downloads/subversion/certificate/certificate.pem

NOTE: the certificate has changed between 1.5.0 and 1.5.1 release. The

certificate used for 1.5.0 had a short expiration date so we have created

a new certificate. If you have previously installed the 1.5.0 certificate,

you must remove it before installing the new one:

sudo pkgadm removecert “Alexander Thomas(AT)”

Once it is removed you can install the new certificate.

3. First installation

The command to install the CollabNet Subversion client, if a previous version

has not already been installed, is:

sudo pkgadd -d /path/to/client-sparc-local

4. Updating an existing installation

The proper way to update a Solaris package is to remove the current version

and then install the new version. If you have the CollabNet Subversion server

installed, you will need to remove it first. Again, refer to the readme for

that package before proceeding.

sudo pkgrm CSVNclnt

sudo pkgadd -d /path/to/client-sparc-local

5. Post-installation instructions

A. CollabNet Subversion installs into /opt/CollabNet_Subversion, which is

probably not on the executable search path for your system. Add the directory

/opt/CollabNet_Subversion/bin to your $PATH environment variable. In order to

make this change affect all users of your system and persists across reboots,

add the following line to /etc/profile:

PATH=/opt/CollabNet_Subversion/bin:$PATH

B. CollabNet Subversion provides man pages and localizations for several

languages. To take advantage of these features, update your MANPATH and/or

LOCPATH environment variables to include the CollabNet Subversion directories.

For example:

export MANPATH=/opt/CollabNet_Subversion/share/man:$MANPATH

export LOCPATH=/opt/CollabNet_Subversion/share/locale:$LOCPATH

6. Support for CollabNet Subversion

Find out about CollabNet Technical Support at

http://www.collab.net/services/subversion/

Information about CollabNet Training, Consulting, and Migration

services is at http://www.collab.net/services/subversion/training.html

Join openCollabNet for community support: http://open.collab.net

7. About Subversion and CollabNet

CollabNet launched the Subversion project in 2000 in response to the demand

for an open standard for Web-based software configuration management that

could support distributed development. CollabNet continues to be strongly

involved with the Subversion project and offers CollabNet Subversion Support,

Training, and Consulting services.

CollabNet also provides the most widely used collaborative development

environment in the world. More than 1,400,000 developers and IT projects

managers collaborate online through CollabNet. The company is transforming

the way software is developed by enabling organizations to leverage global

development talents to deliver better products and innovate faster.

Visit CollabNet at http://www.collab.net for more information

Thanks to: http://www.scmgalaxy.com

Suggestions are always welcome..! Without signing also you can send your comments.

Building Web Application With Ant and Deploying on Jboss

Building Web Application With Ant and Deploying on Jboss 3.0

In this lesson I will show you how to build you web application and install on the Jboss 3.0 application server.

After the completion of the lesson you will be able to include jsp, html and servlets in the ear file and deploy on the Jboss 3.0 application server. This example will provide a strong foundation for the further development. Ant script developed in this lesson will be used in subsequent tutorial for the development and deployment of complex J2EE Applications with little or no more modification.

In this lesson we will write one Hello World Servlet and a JSP file file to call Hello World Servlet. In order to deploy components we have to build .ear file which is the standard format for the deployment of J2EE application.

First of all let's understand the structure of .ear and .war files.

Enterprise Archive Contents

Enterprise Archive (.ear) component follows the standard directory structure defined in the J2EE specification.

Directory Structure of .ear archive
/
.war and .jar files
Meta-inf
	application.xml

In the .ear file .war,.jar and application.xml file are packaged in the above format.

Enterprise Archive Contents

Web component follows the standard directory structure defined in the J2EE specification.

Directory Structure of Web Component
/
index.htm, JSP, Images etc..
Web-inf
	web.xml
	classes
	servlet classes
	lib
	jar files

Root directory of the web archive ('.war' file) contains all the html, jsp, images files and the additional directories containing these files. In the root directory there is a special directory 'Web-inf' which contains the web deployment descriptor (web.xml), classes and the lib directory.

Directory Structure of Example2 directory

After understanding the structure of .ear and .war file let's look at the directory structure of example2directory where we have work to develop the deployable .ear file.

Directory structure:

Description of Directory and its content:

Directory	Description
example2	Base directory which contains build.xml and the .ear file generated by Ant utility will be placed here.
build	Various files generated by Ant utility will be placed in different directories under this directory.
build/deploymentdesciptors	Web.xml and application.xml files are placed in this directory.
build/ear	Intermediate files for the assembling of example2.ear ear file are placed here.
build/jar	Any jar file if required will be placed in this directory.
build/war	Intermediate files for the assembling of example2.war ear file are placed here.
build/src	All the compiled .class files are placed in this directory.
src	All the java source files are placed here.
web	All the html,jsp, images etc. files are placed in this directory.

In this lesson we creating HelloWorld.java and index.jsp which is in the /src and /web directory respectively.

Source code of HelloWorld.java:

/** HelloWorld.java
*
*/
import java.io.*;
import java.text.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
/**
* The Hello World Servelet.
*
* @author Deepak Kumar
* http://www.roseindia.net
* deepak@roseindia.net
*/public class HelloWorld extends HttpServlet {

public void service(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException{
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<head>");
out.println("<title>Hello World Servlet!</title>");
out.println("</head>");
out.println("<body>");
out.println("Hello World!");
out.println("<a href=\"javascript:history.back()\">Go to Home</a>");
out.println("</body>");
out.println("</html>");
}
}

Here is the code of index.jsp file:

<%@page language="java" %>
<html>
<head>
<title>Welcome to Jboss 3.0 tutorial</title>
</head>

<body bgcolor="#FFFFCC">

Welcome to 
Jboss 3.0 Tutorial
Congralutations you have successfully
installed lesson 2 tutorial
<a href="servlet/HelloWorld">Click here
to</a> execute Hello World Servlet.
 
For more tutorials and examples visit
 <a href="http://www.rosindia.net">http://www.rosindia.net</a>
 
Copyright © 2001 roseindia.net. All
rights reserved.

</body>

</html>

You can download all the file of this tutorial from here.
Writing Application and Web deployment descriptor
Since in this lesson we are developing one servlet and one jsp files so our deployment descriptor is very simple.
web.xml file:

<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"
"http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">

<web-app>
<servlet>
<servlet-name>HelloWorld</servlet-name>
<servlet-class>HelloWorld</servlet-class>
</servlet>

<servlet-mapping>
<url-pattern>/servlet/HelloWorld</url-pattern>
<servlet-name>HelloWorld</servlet-name>
</servlet-mapping>

</web-app>

application.xml file:

<?xml version="1.0" encoding="ISO-8859-1"?>

<application>
<display-name>Example 2 </display-name>
<module>
<web>
<web-uri>example2.war</web-uri>
<context-root>/example2</context-root>
</web>
</module>
</application>

Above application.xml file describe the content of example2.ear. Tag <web-uri>example2.war</web-uri> describe the name of web module (i.e.. example2.war) packaged in the archive. The context root of this example2.ear is eample2.
Writing Ant build xml file
To build example2.ear file, I have written build.xml which compiles source code and builds deployable archive file.
build.xml file:

<?xml version="1.0"?>








<project name="Jboss 3.0 tutorial series" default="all" basedir=".">

<target name="init">
<property name="dirs.base" value="${basedir}"/>
<property name="classdir" value="${dirs.base}/build/src"/>
<property name="src" value="${dirs.base}/src"/>
<property name="web" value="${dirs.base}/web"/>
<property name="deploymentdescription" value="${dirs.base}/build/deploymentdescriptors"/>

<property name="warFile" value="example2.war"/>
<property name="earFile" value="example2.ear"/>

<property name="earDir" value="${dirs.base}/build/ear"/>
<property name="warDir" value="${dirs.base}/build/war"/>


<mkdir dir="${warDir}/WEB-INF"/>
<mkdir dir="${warDir}/WEB-INF/classes"/>


<mkdir dir="${earDir}/META-INF"/>

</target>


<target name="all" depends="init,build,buildWar,buildEar"/>


<target name="build" >
<javac srcdir="${src}" destdir="${classdir}" debug="true" includes="**/*.java" />
</target>


<target name="buildWar" depends="init">
<copy todir="${warDir}/WEB-INF/classes">
<fileset dir="${classdir}" includes="**/*.class" />
</copy>

<copy todir="${warDir}/WEB-INF">
<fileset dir="${deploymentdescription}" includes="web.xml" />
</copy>

<copy todir="${warDir}">
<fileset dir="${web}" includes="**/*.*" />
</copy>


<jar jarfile="${earDir}/${warFile}" basedir="${warDir}" />

</target>


<target name="buildEar" depends="init">
<copy todir="${earDir}/META-INF">
<fileset dir="${deploymentdescription}" includes="application.xml" />
</copy>


<jar jarfile="${dirs.base}/${earFile}" basedir="${earDir}" />
</target>

</project>

Above build.xml file is design to create example2.ear for us in the base directory.
Running Ant utility to build example2.ear
Now it's time to build example2.ear and deploy on the Jboss 3.0 application server.
To execute Ant utility go to c:\anttest\example2 directory and issue ant command.
Out put of ant command:

C:\anttest\example2>ant
Buildfile: build.xml

init:
[mkdir] Created dir: C:\anttest\example2\build\war\WEB-INF
[mkdir] Created dir: C:\anttest\example2\build\war\WEB-INF\classes
[mkdir] Created dir: C:\anttest\example2\build\ear\META-INF

build:
[javac] Compiling 1 source file to C:\anttest\example2\build\src

buildWar:
[copy] Copying 1 file to C:\anttest\example2\build\war\WEB-INF\classes
[copy] Copying 1 file to C:\anttest\example2\build\war\WEB-INF
[copy] Copying 1 file to C:\anttest\example2\build\war
[jar] Building jar: C:\anttest\example2\build\ear\example2.war

buildEar:
[copy] Copying 1 file to C:\anttest\example2\build\ear\META-INF
[jar] Building jar: C:\anttest\example2\example2.ear

all:

BUILD SUCCESSFUL

Total time: 8 seconds
C:\anttest\example2>|

The above process will create example2.ear in c:\anttest\example2 directory.
Deploying and testing J2EE application
Statrt Jboss 3.0 and copy example2.ear file into the JBOSS_HOME/server/default/deploy directory. Jboss application server automatically deploys the application. Open web browse and type http://localhost:8080/example2 in the web browser. Browse should show the screen something like this:

Also try to execute Hello World Servlet by clicking "Click Here to" link on the index.jsp in the browser.

Thanks to: Rose India Technologies.

Suggestions are always welcome...! Without signing also you can send your comments.

Tuesday, June 21, 2011

Download and Install Hudson as a Windows service

Download Hudson :

http://hudson-ci.org/downloads/war/latest/hudson.war

Install Hudson as a Windows service

First, you need to start Hudson before installing it. This can be done from JNLP, or by running java -jar hudson.war".
Now connect to hudson by going to the following URL http://<hostname>:8080/

Once Hudson is started this way, look for the "Install as Windows Service" link in the "Manage Hudson" page (requires .net framework version >= 2.0):

Clicking this link shows you the installation screen:

Choose the directory where Hudson shall be installed (directory must already exist. If not create it before hand). This will become HUDSON_HOME and used to store data files and programs alike.
Upon successful completion of the installation, you should see a page asking you to restart Hudson.

This is to re-launch Hudson as a newly installed Windows service. When you click yes, you'll be asked to wait until the restart completes:

If a restart fails for some reason, check the output from Hudson, which is stored in the installation directory that you specified.

At this point you can use the service manager to confirm that Hudson is running as a service.

Install Slave as a Windows service (require .Net 2 framework)

Hudson also allows you to install a slave agent as a Windows service. (See Distributed builds for more about how to do distribute builds in general.)

First, you configure your slave to run as a JNLP slave agent. This should create a JNLP launch icon in the corresponding page, as shown below:

From the slave machine, launch a slave agent. You should see a window like this:

Choose "File" > "Install as Windows Service" from the menu:

Confirm your intention to install as a service. The installation will place the program files to the directory designated as the slave root directory (from the "configure executors" screen.)

Once the installation succeeds, you'll be asked if you'd like to stop the current slave agent and immediately start a slave agent.

When you click "OK", the slave agent window will terminate. The new slave agent runs as a service without showing a window, so head over to the service manager from the control panel and confirm that the slave agent is indeed running as a service:

Changing the configuration of services

The JVM launch parameters of these Windows services are controlled by an XML file hudson.xml and hudson-slave.xml respectively. These files can be found in$HUDSON_HOME and in the slave root directory respectively, after you've install them as Windows services.

The file format should be self-explanatory. Tweak the arguments for example to give JVM a bigger memory.

Stdout and stderr from the service processes go to log files in the same directory.

Uninstallation

To uninstall the service, run hudson-slave.exe uninstall from the command line.

Thanks to : http://wiki.hudson-ci.org/display/HUDSON/Installing+Hudson+as+a+Windows+service

Suggestions are always welcome...! Without signing also you can send your comments.

Friday, May 27, 2011

CollabNet Subversion - svn

Subversion

CollabNet Subversion is an enterprise-ready distribution of Subversion that includes certified binaries and platform-specific installers.
CollabNet Subversion downloads are available for:

These binaries are certified by CollabNet.
Other Subversion downloads are also available for:

These downloads are hosted by CollabNet, but not certified by CollabNet. They are created and maintained by the openCollabNet community.

Thanks to : http://www.open.collab.net/downloads/subversion.html

Suggestions are always welcome...! Without signing also you can send your comments.

Open Source Build System/Management tools in Java

Open Source Build System/Management tools in Java

Ant

Ant is a software tool for automating software build processes. It uses XML to describe the build process and its dependencies.

Go To Ant

Ivy

Ivy is a free java based dependency manager, with powerful features such as transitive dependencies, ant integration, maven repository compatibility, continuous integration, html reports and many more.

Go To Ivy

Hudson

Hudson monitors executions of repeated jobs, such as building a software project or jobs run by cron. Among those things, current Hudson focuses on the following two jobs: 1. Building/testing software projects continuously, just like CruiseControl or DamageControl. In a nutshell, Hudson provides an easy-to-use so-called continuous integration system, making it easier for developers to integrate changes to the project, and making it easier for users to obtain a fresh build. The automated, continoues build increases the productivity. 2. Monitoring executions of externally-run jobs, such as cron jobs and procmail jobs, even those that are run on a remote machine. For example, with cron, all you receive is regular e-mails that capture the output, and it is up to you to look at them diligently and notice when it broke. Hudson keeps those outputs and makes it easy for you to notice when something is wrong.

Go To Hudson

Rant

Rant stands for Remote Ant. It is a distributed build system that allows an Ant build file to launch builds on other systems and receive exceptions should they occur.

Go To Rant

JAM

JAM consists of a collection of Ant scripts designed to perform common Java/J2EE build tasks such as compilation, packaging, testing, deployment and J2EE application server control. JAM combines Maven’s high-level project description and repository features (via a Maven-to-Ant bridge) with the low-level capabilities of Ant. By assembling JAM modules, one is able to quickly create sophisticated IDE-independent build scripts. JAM supports various J2EE application servers, XDoclet invocation, JUnit unit testing, Apache Cactus integration testing, UML-based code generation and other technologies.

Go To JAM

Ant Hill

Ant Hill is an Ant library meant to perform remote invocation of build targets via XMPP (Jabber) protocol. To be more specific Ant Hill provides a mechanism to implement Remote Target Invocation. The client / server approach allows to work on clusters and coordinate a large number of machines. Ant Hill has been written to be extensible, it is possible to define quickly new Remote Commands. Ant Hill provides error reporting through Remote Exception Propagation and several debugging features.

Go To Ant Hill

JMK

This application is based on the make utility which is part of most Unix systems, but is designed to support the task of writing platform independe

Go To JMK

Schmant

Schmant is a build tool for building software artifacts. It uses the scripting support in Java 6 for running build scripts, so build scripts can be written in any supported script language. Schmant provides a set of tasks for common build script tasks, such as compiling Java code, building JAR files, exporting code from Subversion repositories and performing text substitution in files. Schmant aims to be feature-compatible with and much easier to use than Apache Ant.

Go To Schmant

Savant

Savant is an extension to the popular ant build system from the Apache group.

Go To Savant

APB

APB is a simple, yet powerfull, project build system that inherits some ideas from Ant and Maven while trying to avoid the use of complex XML files to define the metadata of the project. Project Definition is done in Java so you have the full power of Java plus the benefit of using your favorite IDE to edit the configuration files. Here are some of the features APB provides out-of-the-box:

* Simple project definition based on default layouts, but with flexibility to accomodate your preferred one.
* Model based builds: APB is able to build projects based on metadata about the project.
* Full extensibility using Java
* Dependency management
* Full project lifecycle, including compilation, packaging and testing.
* Coverage support during testing
* Documentation generation
* Generation of project files for common IDEs (Currently Intellij Idea)
* Ant tasks to integrate APB projects into foreign contexts.
* Command line invocation including shell-completion

Go To APB

Maven

Maven is a Java project management and project comprehension tool. Maven is based on the concept of a project object model (POM) in that all the artifacts produced by Maven are a result of consulting a well defined model for your project. Builds, documentation, source metrics, and source cross-references are all controlled by your POM. Look here to see the full list of Maven's features.

Go To Maven

Invicta

Invicta is an open-source build management tool. Using simple project definition files, it generates powerful build scripts (Apache ANT's), while hiding their complexity.

Go To Invicta

Cruise Control

CruiseControl is a framework for a continuous build process. It includes, but is not limited to, plugins for email notification, Ant, and various source control tools. A web interface is provided to view the details of the current and previous builds.

Go To Cruise Control

Bee

Bee is a Java-based build tool. Bee inherited some principles of Make. Bee provides more procedure languages constructions, so generally can be used for script programming. It's highly extendable and base DTD can be easily changed, so it allows to create own dialects of Bee.

Go To Bee

LuntBuild

LuntBuild is a powerful build automation and management tool. Continuous integration or daily build can be easily setup through a clean web interface. Generated builds are well managed through functions such as search, categorization, promotion, patching, deletion, etc. It also acts as a central build artifacts download area for your whole team.

Go To LuntBuild

CPMake

CPMake is a build tool similar to GNU make where as it lets file dependencies determine what tasks to perform. The build files can be written in either BeanShell or Jython script. CPMake has a built in dependency parser for both Java and C/C++ files.

Go To CPMake

GenJar

GenJar is a specialized Ant task that builds jar files based on class dependencies rather than simply the contents of a directory.

Go To GenJar

Antmod

Antmod is a build management, release management, and repository management tool. Its implementation is an Ant-based extensible engine for retrieving, versioning, building, and deploying code to and from Subversion or CVS. It standardizes build files for Java projects and provides build plugins for various tasks. It also standardizes tagging and branching for both CVS and Subversion, and its module and repository management can also be used for non-Java projects. It greatly speeds up Java software development, promotes reuse of Java software, and standardizes the build-test- release cycle.

Go To Antmod

Continuum

Continuum is an easy-to-use, Continous Integration server for building Java-based projects, with built-in support for Maven 2, Maven 1, Ant and Shell Scripts.

Go To Continuum

Autojar

Autojar helps creating jar files of minimal size from different inputs like own classes, external archives etc. It starts from one or more given classes (e.g., an applet), recursively searches the bytecode for references to other classes, extracts these classes from the input archives, and copies them to the output. The resulting archive will only contain the classes that are really needed. Thus one can keep size and loading time of applets low or make applications independent of installed libraries. In a similar way, autojar can search directories and archives for other resources (like image files), extract them and copy them to the output. Although autojar can't know exactly which classes get loaded dynamically, it can search the bytecode for invocations of Class.forName() and warn about it. In some cases (constant class name), it can even find out which classes are to be loaded, and add them automatically to the output.

Go To Autojar

Proximity

Proximity (px-core) is a generic fetch-and-cache engine with various extra capabilities like indexing. The Px-Core module is driven by Maven bindings (px-core-maven) to implement a Maven Proxy application behaviour. Proximity is in function somewhere between http-proxy and proactive-mirror. Proximity is not HTTP Proxy. One of it's primary use is as Java web application to serve as maven proxy on our company's intranet. As for reducing outgoing traffic (caching central and other maven repos), aggregating more repositories (reducing project config) with acting as one logical repository and for publishing in-house and other external maven artifacts which are not uploadable to ibiblio (like commercial projects, J2EE Jars, etc...).

Go To Proximity

Jar Jar Links

Jar Jar Links is a utility that makes it easy to repackage Java libraries and embed them into your own distribution. This is useful for two reasons:

* You can easily ship a single jar file with no external dependencies.
* You can avoid problems where your library depends on a specific version of a library, which may conflict with the dependencies of another library.

Go To Jar Jar Links

Anthill OS

Anthill OS is a Build Management Server. Anthill allows multiple users to work together and consistently access only the latest build, complete with changes from all programmers working on a project. Anthill performs a checkout from the source repository of the latest version of a project before every build and tags the repository with a unique build number. Anthill then updates a project intranet site with artifacts from the latest build.

Go To Anthill OS

Jenkins CI

Jenkins CI, formerly known as "Hudson Labs". Jenkins monitors executions of repeated jobs, such as building a software project or jobs run by cron. Among those things, current Jenkins focuses on the following two jobs: Building/testing software projects continuously, just like CruiseControl or DamageControl. In a nutshell, Jenkins provides an easy-to-use so-called continuous integration system, making it easier for developers to integrate changes to the project, and making it easier for users to obtain a fresh build. The automated, continuous build increases the productivity. Monitoring executions of externally-run jobs, such as cron jobs and procmail jobs, even those that are run on a remote machine. For example, with cron, all you receive is regular e-mails that capture the output, and it is up to you to look at them diligently and notice when it broke. Jenkins keeps those outputs and makes it easy for you to notice when something is wrong.

Go To Jenkins CI

Suggestions are always welcome...! Without signing also you can send your comments.

Pages

Thursday, July 5, 2012

Subversion configuration in windows

Wednesday, June 22, 2011

Building Web Application With Ant and Deploying on Jboss 3.0

Tuesday, June 21, 2011

Download Hudson :

Install Slave as a Windows service (require .Net 2 framework)

Uninstallation

Friday, May 27, 2011

Subversion