 -----
 Archiva Community - Get Involved
 -----
 -----
 2012-01-19
 -----

~~ 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.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/guides/mini/guide-apt-format.html

Getting Involved in the Archiva Project

  Archiva is an open source project and relies heavily on an active community.
  If you need help, you should look to the community. Equally, please look
  for ways that you may contribute back.
  
  This page provides some pointers for receiving help and contributing to the
  Archiva community.


* Getting Help

  There are a number of ways to find help if you have an issue. 

  * <<Read the documentation>>\
  Read the {{{http://archiva.apache.org/docs/${archivaCurrentDevVersion}/userguide}user}} and {{{http://archiva.apache.org/docs/${archivaCurrentDevVersion}/adminguide}administration}}
  documentation. 

  * <<Search the Wiki>>\
  Search the
  {{{http://cwiki.apache.org/confluence/display/ARCHIVA}Archiva Wiki}}.
  Lots of useful information has been contributed by users here.

  * <<Submit an issue>>\
  Search the {{{./issue-tracking.html}Jira}} issue tracking system. The problem
  you are experiencing may be a known issue and others may have suggested
  work-arounds.  If the issue is new, you should consider submitting a report.
  
  * <<Search the mailing lists>>\
  Search the mailing lists. Look {{{./mailing-lists.html}here}} for a list of
  Archiva mailing lists.  If you cannot find everything you need, ask a
  question on the appropriate list.

** More Information

  If you are new to Archiva (or Maven), there are a number of helpful resources
  on the Maven website which provide step-by-step guides to getting help,
  useful information regarding etiquette, and lots of other resources.

  Check out:

  * {{{http://maven.apache.org/community.html}The Maven Community}}

  * {{{http://maven.apache.org/users/getting-help.html}Getting Help with Maven}}


* How to Contribute

  As with any open source project, there are several ways you can help:

  * <<Join a mailing list>>\
    Join a {{{./mailing-lists.html}mailing list}} and answer other user's questions.
    You can also meet up with developers and users on <<<#archiva>>> on <<<irc.freenode.net>>>

  * <<Fix bugs>>\
    Report bugs, feature requests and other issues in the
    {{{./issue-tracking.html}Jira}} issue tracking system. Also, read up on 
    {{{./developers/how-we-do-things.html}how we do things}} in Archiva.

  * <<Build it>>\
	 Check out the {{{./source-repository.html}source code}} and {{{./developers/building.html}build Archiva}} for yourself.
	 Fix bugs and submit patches for reported issues (both those you find, or that others have filed).

  * <<Write documentation>>\
    Help with the documentation by pointing out areas that are lacking or
	 unclear, and if you are so inclined, submitting patches to correct it.  You
	 can quickly contribute rough thoughts to the
	 {{{http://cwiki.apache.org/confluence/display/ARCHIVA} wiki}}, or you can
	 volunteer to help collate and organise information that is already there.

  * <<Contribute Patches>>
     You can attache source patches to our JIRA. Or contribute using github pull requests our github source mirror is
     available here {{{https://github.com/apache/archiva}https://github.com/apache/archiva}}


  []

  Your participation in the community is much appreciated!

** More Information

  If you are new to Archiva (or Maven), there are a number of helpful resources
  on the Maven website regarding contribution back to the community.

  Check out:

  * {{{http://maven.apache.org/community.html}The Maven Community}} 

  * {{{http://maven.apache.org/guides/development/guide-helping.html}Guide to helping with Maven}}
