<?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>
<!-- /*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/ -->
<link rel="stylesheet" type="text/css" href="../../org.eclipse.wst.doc.user/common.css" />
<title>Resources used to test and publish on your server</title>
</head>
<body onresize="location.reload();" id="cwres_wst"><a name="cwres_wst"><!-- --></a>
<h1 class="topictitle1">Resources used to test and publish on your server</h1>
<div><div>To test and publish on your server, you need
to define one or more of the following resources:</div><a name="cwres_wst__cwres_ul"><!-- --></a><ul id="cwres_wst__cwres_ul"><li>A server</li>
<li>An installed server runtime environment</li>
</ul>
<p id="cwres_wst__cwres_p1"><a name="cwres_wst__cwres_p1"><!-- --></a>If a server has server configuration files, in most situations,
these server configuration files are created for you automatically and contained
in a server project.</p>
<div class="section" id="cwres_wst__cwres_server_project"><a name="cwres_wst__cwres_server_project"><!-- --></a><h4 class="sectiontitle">Server Project</h4><p>A <em>server
project</em> contains servers and server configuration files. When a server
project is created automatically by the workbench, the name given to the project
is <span class="uicontrol">Servers</span> and is available in the Project Explorer
view under the Other Projects folder.</p>
</div>
<div class="section" id="cwres_wst__cwres_servers"><a name="cwres_wst__cwres_servers"><!-- --></a><h4 class="sectiontitle">Servers</h4><p id="cwres_wst__cwres_servers_p1"><a name="cwres_wst__cwres_servers_p1"><!-- --></a>A <em>server</em> identifies where you want to test or
publish your application. A server points to a specific runtime environment
such as a local test environment, a full installation of a server, or a server
on another machine. A server contains the logic of how to publish to the server;
and what application projects and configurations to run.</p>
<p id="cwres_wst__cwres_servers_p2"><a name="cwres_wst__cwres_servers_p2"><!-- --></a>On
the workbench, when the metadata of the server is automatically created, it
is stored in a <em>serverName</em>.server file, where <em>serverName</em> is the
name assigned to the server. For details on the metadata of the server, refer
to the <em>Displaying or hiding the metadata of the server</em> link at the
bottom of this topic.</p>
</div>
<div class="section"><h4 class="sectiontitle">Server configurations</h4><p id="cwres_wst__cwres_serverconfig_p1"><a name="cwres_wst__cwres_serverconfig_p1"><!-- --></a><span>Server configurations are files that contains
information that is required to set up and publish to a server. For example,
these files may include information about what port to run the server, security
preferences and other vendor-specific server settings.</span></p>
<p id="cwres_wst__cwres_serverconfig_p2"><a name="cwres_wst__cwres_serverconfig_p2"><!-- --></a>On
the workbench, the metadata of the server configurations is automatically
created and stored in a <em>configuration data folder</em> under a server project.
The naming convention of the configuration data folder is dependant on the
vendor, typically it has the following convention: <em>serverName</em>@<em>hostname</em>-config,
where <em>serverName</em> is the name assigned to the server, and <em>hostname</em> is
the fully qualified DNS name or IP address of the host machine where the server
is running.</p>
</div>
<div class="section" id="cwres_wst__cwres_installed_runtime"><a name="cwres_wst__cwres_installed_runtime"><!-- --></a><h4 class="sectiontitle">Installed Server Runtime Environment</h4>You
need to define the runtime environment of an application server for compiling
your application. A server contains a reference to an installed server runtime
environment it is currently using. For details on how to define an installed
server runtime environment, refer to the <em>Defining the installed server
runtime environments</em> link at the bottom of this topic.</div>
<div class="section" id="cwres_wst__cwres_relationship"><a name="cwres_wst__cwres_relationship"><!-- --></a><h4 class="sectiontitle">Relationship between the resources</h4><p>For
each server, you can specify the server configuration and installed server
runtime environment that should be used for that server. A server can only
point to one or no server configuration. However, a server configuration can
be pointed to from one or more servers.</p>
<p>A relationship between a server
configuration and an application project, for example an EAR project, is created
when a project is added to the server configuration. A server can point to
one or more projects. A project can be pointed to from one or more server
configurations.</p>
</div>
</div>
<div><div class="reltasks"><strong>Related tasks</strong><br />
<div><a href="../topics/tmetasrv.html" title="On the workbench, you have the option to display or hide the metadata of the server.">Displaying or hiding the metadata of the server</a></div>
<div><a href="../topics/twinstprf.html" title="Using the Preferences page, you can direct the workbench to use a specific runtime environment of an application server for compiling your application. You can complete this by defining the installation directory of the server:">Defining the installed server runtime environments</a></div>
</div>
</div>
</body>
</html>