<?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, 2009 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" />
<meta name="DC.rights.owner" content="(C) Copyright 2000, 2009" />
<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="concept" name="DC.Type" />
<meta name="DC.Title" content="Resources used to test and publish on your server" />
<meta name="abstract" content="To test and publish on your server, you need to define one or more of the following resources:" />
<meta name="description" content="To test and publish on your server, you need to define one or more of the following resources:" />
<meta content="preferences, server runtime environments, resources, runtime environments, description, servers, testing applications" name="DC.subject" />
<meta content="preferences, server runtime environments, resources, runtime environments, description, servers, testing applications" name="keywords" />
<meta scheme="URI" name="DC.Relation" content="../topics/tmetasrv.html" />
<meta scheme="URI" name="DC.Relation" content="../topics/twinstprf.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="cwres_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>Resources used to test and publish on your server</title>
</head>
<body id="cwres_wst"><a name="cwres_wst"><!-- --></a>


<h1 class="topictitle1">Resources used to test and publish on your server</h1>



<div><p>To test and publish on your server, you need
to define one or more of the following resources:</p>

<a name="cwres_wst__cwres_ul"><!-- --></a><ul id="cwres_wst__cwres_ul">
<li>A server</li>

<li>A 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.</p>
</div>

<div class="section" id="cwres_wst__cwres_servers"><a name="cwres_wst__cwres_servers"><!-- --></a><h4 class="sectiontitle">Server</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 contain
information 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">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 a server runtime environment
it is currently using. For details on how to define a server runtime environment,
refer to the <em>Defining the server runtime environments preference</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 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 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 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, testing, or running your application.">Defining the server runtime environments preferences</a></div>
</div>
</div>

</body>
</html>