<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--
Copyright (c) 2009, 2010, 2011, Oracle and/or its affiliates. All rights reserved.
--> 
<html>
<head>
    <title>Working With a Team Server in NetBeans IDE</title>
   <!-- BEGIN METADATA -->
   <meta http-equiv="content-type" content="text/html; charset=UTF-8" >
   <meta name="description" content="An introduction to how to set up a Team Server with NetBeans IDE and the features available for hosted projects.">
   <meta name="KEYWORDS" content="NetBeans, Team Server, Kenai, share, import, create project, issue tracking, version control, subversion, java.net">
   <link rel="stylesheet" href="../../../netbeans.css" type="text/css">
   <!-- END METADATA -->
   
</head>
<body>
   
    <a name="top"></a>
    <h1>Working With a Team Server in NetBeans IDE</h1>

    <p>A Team Server provides various services that are designed to help increase the productivity of developers
    by providing an infrastructure for developers collaborating on a project.
    To work with a Team Server, install the Team Server plugin from the NetBeans Update Center.
    The plugin will automatically register an instance of the <a href="https://java.net" target="blank">java.net</a> team server.
    After you register a Team Server with the IDE, you can take advantage of the services offered by the Team Server
    for your hosted projects.</p>


    <h2>What is a Team Server?</h2>
    <img  src="../../../images_www/articles/73/netbeans-stamp-80-74-73.png" class="stamp" alt="Content on this page applies to NetBeans IDE 7.2, 7.3, 7.4 and 8.0" title="Content on this page applies to the NetBeans IDE 7.2, 7.3, 7.4 and 8.0" >
    <p>A Team Server can be any online site that uses the Kenai infrastructure to provide project hosting and collaborative
    tools and services.
    Each project hosted on a Team Server is represented by a project page that provides a description and details about the project.
    The project page also enables the project owner to enable and disable the services associated with the project.
    </p>

    <p>For projects hosted on a Team Server, the IDE provides integrated support for the following services.</p>
    

    <div class="indent">

        <h3>Version Control Systems</h3>
        <p>A source code management tool is invaluable when a group of developers are working on the same code base.
        The IDE provides integrated support for version control systems to help
        developers manage the revisions to the source code in the repository.
        The NetBeans IDE provides support for working with Mercurial and Subversion repositories hosted on a Team Server.
        The IDE can automatically create local repositories for hosted projects.</p>


        <h3>Issue Tracking</h3>
        <p>An issue tracking system enables developers and users to report and track issues associated with a
        project and provides a valuable feedback mechanism for people involved in the project.
        The integration of issue tracking systems in the IDE enables developers to find, view and
        resolve project issues from within the IDE.
        NetBeans IDE provides integrated support for the Bugzilla and JIRA issue trackers.</p>


        <h3>Instant Messaging and Notifications</h3>
        <p>If a project on a team server has a chat room enabled, 
        project members can participate in the project's chat room and have private chats with each other.
        Chat enables members to exchange messages and links from within the IDE.
        The IDE can receive and display messages, for example, that notify you when there are changes to the project 
        and when there are changes to the repository.</p>
        <p class="notes"><strong>Note.</strong> The XMPP services for instant messaging and notifications are not currently available for java.net.</p>

       
    </div>
    
    <h2>Why Use a Team Server?</h2>

    <p>Developers who are collaborating on a project require a set of tools
    and an infrastructure that can help them stay connected to each
    other and work together as a team.
    In addition to sharing sources, team members need to be able to share
    information and communicate with each other, and how they share information
    depends on the type of information they need to share.
    
    Not all team members will use the same tools, but communication between members
    can be simplified when the infrastructure and tools are integrated.
    Some members will be developers, but there might also be people responsible for designing the user interface,
    testing quality, writing documentation, managing the build cycle, etc.,
    each with different requirements and preferences.
    A Team Server provides a scalable, flexible platform for development that can grow as the project grows.</p>

    <p>How a project develops can change over time.
    In some cases, in particular when starting a project from scratch, you might want to set up the
    project infrastructure before any coding starts.
    In other cases, a project might already be started and some code written,
    but the project has grown in scope and additional people need to be brought in to work 
    on the project. As the size of the team changes, details about the project need to
    be captured and communicated.
    Tools such as issue trackers and wiki pages are useful for capturing this type of information.</p>

    
    
    <h2>Registering a Team Server</h2>
    <p>To take advantage of Team Server services in the IDE, you need to install the Team Server plugin and then
        register a Team Server with the IDE.
        By default, the java.net team server instance is registered when you install the Team Server plugin.
        To register a new instance of a team server, perform the following steps.</p>

    <ol>
        <li>Choose Window &gt; Plugins to open the Plugins manager.</li>
        <li>Select the Available Plugins tab in the Plugins manager and select the Team Server plugin.<br>
        <img  src="../../../images_www/articles/73/ide/teamserver/team-plugin.png" alt="screenshot of Plugins manager" title="Team Server plugin selected in Plugins manager" class="margin-around b-all">
        </li>
        <li>Click Install in the Plugins manager and step through the plugin installation process.
            <p>After the Team Server plugin is installed, you can add a new team server instance.
            The plugin also enabled the Team Dashboard which provides an overview of team projects that you create, open or join.</p>
            <p class="notes"><strong>Note.</strong> You might need to install additional plugins that are required by the Team Server plugin and restart the IDE.</p>
        </li>
        <li>Choose Team &gt; Team Server &gt; Add Team Server in the main menu to open the New Team Server dialog box.</li>
        <li>Type the Name and URL of the Team Server. Click Add.<br>
        <img  src="../../../images_www/articles/73/ide/teamserver/add-team-server.png" alt="Add Team Server dialog" title="Add Team Server dialog" class="margin-around b-all">
        <p class="notes"><strong>Note.</strong> The IDE will check to confirm that the team
            server that you are adding is a valid team server instance that is built on the Kenai infrastructure.</p>
        <p>In the Services window you can see the new team server is listed under the Team Servers node.
            The java.net team server is added by default when you install the plugin and is also listed under the Team Servers node.</p>
        <img  src="../../../images_www/articles/73/ide/teamserver/services-window.png" alt="screenshot of Services window" title="Team Servers node in Services window" class="margin-around b-all">
        </li>
    </ol>
        <p>You can log in to any registered team server instance by choose Team &gt; Team Server &gt; Login from the main menu.
        Alternatively, you can right-click the name of the server under the Team Servers node in the Services window and choose Login
        or click Login in the Team Dashboard.</p>
        <img  src="../../../images_www/articles/73/ide/teamserver/user-login.png" alt="Add Team Server dialog" title="Add Team Server dialog" class="margin-around b-all">


    <p>After you register the Team Server and log in, you can open the Team Dashboard for an overview of your projects and
        to search for other projects that are hosted on the Team Server.
        To create projects on a Team Server you must have an account with the Team Server.</p>

        <p class="notes"><strong>Notes.</strong></p>
        <ul>
            <li>Currently, the only Team Server that is publicly available
            is <strong>java.net</strong>. The java.net Team Server is registered by default
            when you install the Team Server plugin.
            Please see the <a href="http://java.net">java.net site</a> for details and
            plans for other Team Server options.</li>
            <li>You need an account at java.net to log in to the java.net team server.
            However, you can retrieve and open many of the projects that are hosted on java.net without logging in.</li>
        </ul>

    <h2>Retrieving Sources of a Team Server Project</h2>
    <p>
        For many projects that are hosted on the java.net team server you do not need to be a
        project member or logged in to open the project and retrieve the sources.</p>

    <ol>
        <li>Choose Team &gt; Team Server &gt; Get Sources from the main menu to open
        the Get Sources from Team Server wizard.

        <p>Alternatively, you can open a Team Server project in the Team Dashboard
        and then click <strong>get</strong> under the project's Sources node
        in the Team Dashboard.</p></li>
        <li>In the Get Sources from Team Server wizard, click Browse to specify the project repository.<br>
        <img  src="../../../images_www/articles/73/ide/teamserver/get-sources.png" alt="screenshot of Get Sources from Team Server dialog" title="Get Sources from Team Server dialog" class="margin-around b-all"></li>
        <li>In the Browse Team Projects dialog, type a search term and then click Search.<br>
            <img  src="../../../images_www/articles/73/ide/teamserver/browse-projects.png" alt="screenshot of Browse Team Projects dialog" title="Browse Team Projects dialog" class="margin-around b-all">
        <p>The IDE searches the Team Server instance for projects containing the search terms and displays
        the results in the dialog box.</p></li>

        <li>Select a project from the list. Click OK.</li>
        <li>To select a specific folder in the repository, click Browse next to the Folder to Get dropdown list
            and select a folder in the Browse Repository Folders dialog.<br>
            <img  src="../../../images_www/articles/73/ide/teamserver/folder-to-get.png" alt="screenshot of Browse Repository Folders dialog" title="Browse Repository Folders dialog" class="margin-around b-all"></li>
        <li>Specify a location on your local system for the local repository of the sources.
        Click Get From Team Server.
        </li>
    </ol>

    <p>When you click Get From Team Server, the IDE will create a local repository and retrieve the sources of the
        project.</p>
    <p>After checkout is complete, you will be prompted to open any NetBeans project that
        were checked out. You can click Open Project in the dialog to select the projects
        that you would like to open in the IDE.  Select Cancel if you do not want to open any
        of the checked out projects.</p>


 
    

<div class="feedback-box"><a href="/about/contact_form.html?to=3&amp;subject=Feedback:%20Working%20With%20a%20Team%20Server%20in%20NetBeans%20IDE">Send Feedback on This Tutorial</a></div>
<br style="clear:both;" >

<h2>See Also</h2>
<p>For additional information on using NetBeans IDE in a collaborative environment, see the following resources.</p>
    <ul>
        <li><a href="subversion.html">Guided Tour of Subversion</a></li>
        <li><a href="../../trails/tools.html">Integration with External Tools and Services Learning Trail</a></li>
        <li><a href="http://www.oracle.com/pls/topic/lookup?ctx=nb8000&amp;id=NBDAG348">Working in a Collaborative Environment</a> in <em>Developing Applications with NetBeans IDE</em></li>
    </ul>

   
</body>
</html>
