<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html lang="en-us" xml:lang="en-us">
<head>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<meta name="copyright" content="Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License 2.0 which accompanies this distribution, and is available at https://www.eclipse.org/legal/epl-2.0/. Contributors: IBM Corporation - initial API and implementation" />
<meta name="DC.rights.owner" content="(C) Copyright 2000, 2011" />
<meta content="public" name="security" />
<meta content="index,follow" name="Robots" />
<meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
<meta content="task" name="DC.Type" />
<meta name="DC.Title" content="Adding projects to a server" />
<meta name="abstract" content="Once you have created a server, you need to create a relationship between the projects that contain the files you want to test and your server." />
<meta name="description" content="Once you have created a server, you need to create a relationship between the projects that contain the files you want to test and your server." />
<meta content="servers, adding projects, projects, adding to a server" name="DC.subject" />
<meta content="servers, adding projects, projects, adding to a server" name="keywords" />
<meta scheme="URI" name="DC.Relation" content="../topics/twmanage.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="twaddprj_wst" name="DC.Identifier" />
<meta content="en-us" name="DC.Language" />
<link href="../../org.eclipse.wst.doc.user/common.css" type="text/css" rel="stylesheet" />
<title>Adding projects to a server</title>
</head>
<body id="twaddprj_wst"><a name="twaddprj_wst"><!-- --></a>


<h1 class="topictitle1">Adding projects to a server</h1>



<div><p>Once you have created a server, you need to create
a relationship between the projects that contain the files you want to test
and your server.</p>

<div class="section" id="twaddprj_wst__context"><a name="twaddprj_wst__context"><!-- --></a><p>This is done by adding your project to a server:</p>
</div>

<a name="twaddprj_wst__steps"><!-- --></a><ol id="twaddprj_wst__steps">
<li class="stepexpand"><span>In the Servers view, right-click on the server and select  <span class="uicontrol">Add
and Remove Projects</span>.</span></li>

<li class="stepexpand"><span>In the Available projects list, select the project that you want
to test and click  <span class="uicontrol">Add</span>.</span></li>

<li class="stepexpand"><span>The project appears in the Configured projects list.</span> If
a project name appears in italic font style, this means the project has not
yet been uploaded to the server. Click <span class="uicontrol">Finish</span>.
</li>

</ol>

<div class="section" id="twaddprj_wst__result"><a name="twaddprj_wst__result"><!-- --></a><div class="note"><span class="notetitle">Note:</span> When you select a project to add to the server,
only the projects that are applicable to the type of server will appear.</div>
</div>

</div>

<div>
<div class="familylinks">
<div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/twmanage.html" title="You can use the server tools views to manage servers. The following tasks may be included as part of the development path:">Managing servers</a></div>
</div>
</div>

</body>
</html>