<!--
  ~ Licensed to the Apache Software Foundation (ASF) under one
  ~ or more contributor license agreements. See the NOTICE file
  ~ distributed with this work for additional information
  ~ regarding copyright ownership. The ASF licenses this file
  ~ to you under the Apache License, Version 2.0 (the
  ~ "License"); you may not use this file except in compliance
  ~ with the License. You may obtain a copy of the License at
  ~
  ~ http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing,
  ~ software distributed under the License is distributed on an
  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  ~ KIND, either express or implied. See the License for the
  ~ specific language governing permissions and limitations
  ~ under the License.
  -->

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 14 June 2007), see www.w3.org" />
<meta http-equiv="content-type" content="" />
<title>Developing Apache Axis2</title>
<link href="css/axis-docs.css" rel="stylesheet" type="text/css"
media="all" />
</head>
<body lang="en" xml:lang="en">
<h1>Developing Apache Axis2</h1>
<p>This document provides information on how to use SVN to get an
SVN checkout/update, make commits to the repository, etc., in the
process of contributing to Apache projects (specifically Axis2).
Instructions on configuring IDEs for development and using Maven to
build the project is also included here.</p>
<h2>Content</h2>
<ul>
<li><a href="#svn">Working with Subversion (SVN)</a></li>
<li><a href="#checkout">Checkout Axis2 from Subversion</a></li>
<li><a href="#maven">Installing Maven 2</a></li>
<li><a href="#ide">Configuring your IDE</a></li>
</ul>
<a name="svn" id="svn"></a>
<h2>Working with Subversion (SVN)</h2>
<p>The Axis2 development team uses Subversion (SVN) for source
control. Subversion is a compelling replacement for CVS, developed
under the auspices of the Tigris community and licensed under an
Apache compatible license. To learn more about Subversion or to
download the latest distribution, visit the <a href=
"http:///subversion.tigris.org" target="_blank">Subversion project
site</a>. If you are looking for guidance on setting up and
installing Subversion, please read the ASF <a href=
"http://www.apache.org/dev/version-control.html" target=
"_blank">Source Code Repositories page</a>.</p>
<a name="checkout" id="checkout"></a>
<h2>Checkout Axis2 from Subversion</h2>
<p>To check out the latest version of Axis2 from the Foundation's
Subversion repository, you must use one of the following URLs
depending on your level of access to the Axis2 source code:</p>
<ul>
<li><b>If you are not a committer:</b> <a href=
"http://svn.apache.org/repos/asf/webservices/axis2/trunk/java"
target=
"_blank">http://svn.apache.org/repos/asf/webservices/axis2/trunk/java</a></li>
<li><b>If you are a committer:</b> <a href=
"https://svn.apache.org/repos/asf/webservices/axis2/trunk/java"
target=
"_blank">https://svn.apache.org/repos/asf/webservices/axis2/trunk/java</a></li>
</ul>
If you are a committer, make sure that you have selected an
svnpasswd. To do this, you must log into svn.apache.org. For more
information, please read the ASF <a href=
"http://www.apache.org/dev/version-control.html" target=
"_blank">Source Code Repositories page</a>.
<p>Once you have successfully installed Subversion, you can check
out Axis2 trunk by following these steps:</p>
<ol type="1">
<li>Run <strong>svn co &lt;repository URL&gt; axis2</strong> where
the repository URL is one of the URLs from the previous list.</li>
<li>This step will check out the latest version of the Axis2 Java
codebase to a directory named "axis2". The second parameter to the
<strong>svn co</strong> selects a directory to create on your local
machine. If you want to checkout Axis2 to a different directory,
feel free to change axis2 to any other directory name.</li>
<li>To update your working copy to the latest version from the
repository, execute the <strong>svn update</strong> command.</li>
<li>If you would like to submit a patch, you can execute
<strong>svn diff</strong> to create a unified diff for submission
to the Axis2 JIRA issue tracker.</li>
</ol>
<a name="maven" id="maven"></a>
<h2>Installing Maven 2</h2>
<p>Axis2's build is based on Maven 2. Maven is a build system that
allows for the reuse of common build projects across multiple
projects. For information about obtaining, installing, and
configuring Maven 2, please see the <a href=
"http://maven.apache.org" target="_blank">Maven project page</a>.
To use Maven to build the Axis2 project, Please install <a href="http://maven.apache.org/download.html" target=
"_blank">Maven2</a> and follow instructions here -  <a href="maven-help.html">Quick Guide to Maven for Axis 2.0</a></p>.
<a name="ide" id="ide"></a>
<h2>Configuring your IDE</h2>
<p>The Axis2 development team uses a variety of development tools
from vi to emacs to eclipse to Intellij/IDEA. The following section
is not an endorsement of a specific set of tools, it is simply
meant as a pointer to ease the process of getting started with
Axis2 development.</p>
<ul>
<li><strong>Intellij IDEA</strong> - type <strong>mvn
idea:idea</strong>. Generates the necessary IDEA .ipr, .iml
and .iws project files</li>
<li><strong>Eclipse</strong>- type <strong>mvn eclipse:eclipse</strong>. Then in Eclipse, setup a Classpath Variable
for MAVEN_REPO, and select File &gt; Import &gt; Existing Projects
into Workspace &gt; Select root directory. Selecting the root of
the Axis source discovers all the modules and allows them to be
imported as individual projects at once.</li>
</ul>
</body>
</html>
