<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<link rel="stylesheet" type="text/css" href="../../help.css">
<title>Installing the server on Linux/Unix</title>
</head>

<body>

<h1>RDT Server Installation on Unix, Linux and MacOS X</h1>

<p>
The following documentation explains how to install the Linux or UNIX server code, 
start the server daemon, and make a connection to a remote Linux or UNIX server. 
<a href="server_installation_windows.html">Look here</a> for setting up a server on Windows.
</p>

<p><span class="bold">Prerequisites</span></p>

<p>
To use the Remote System Explorer communications server daemon you need to 
install Perl. Using the daemon helps eliminate some of the manual 
steps when you connect to the server.
</p>

<!-- TODO Link to where a RDT server can be downloaded -->
<p><span class="bold">Installing the server code</span></p>

<p>
<ol>
<li>Find the package that contains the server.</li> 
<li>Ensure that Perl is installed.</li>
<li>Ensure that a Java Runtime Environment (JRE) version 1.5 or higher is installed.
An IBM, Sun or equivalent JRE is required; The gcj-based jvm shipped with most Linux
distributions does not work. If in doubt, run the command <span class="typewriter">java -version</span>
 and check if there is a reference to gcj.</li>
<li>Choose a directory where you want to install the server code. These 
instructions will use the <span class="typewriter">/home/user/</span> directory as an example, 
but you are free to use any directory. When the server archive file is expanded
it will create a directory named <span class="typewriter">rdt-server</span> in the location where it
is expanded.
</li>
<li>Upload the server archive file to this directory.</li>
<li>Switch to the <span class="typewriter">/home/user/</span> directory.
</li>
<li>Run the following command in the <span class="typewriter">/home/user</span> directory to extract the
server code from the package appropriate to your operating system. For linux this command is:

<pre class="command">tar -xvf rdt-server-linux-[version].tar</pre>

</li>
<li>A directory named <span class="typewriter">/home/user/rdt-server</span> will be created that contains the server files.</li>
</ol>
</p>


<p><span class="bold">Starting the server</span></p>

<p>
You can start the RSE communications server with the server daemon, or manually. 
Before starting the server, make sure the Java command is in your path, 
you can do this by running the following command:
</p>

<pre class="command">java -version</pre>

<p>
You should see something similar to the following:
</p>

<pre class="command">
java version "1.4.1"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.1)
Classic VM (build 1.4.1, J2RE 1.4.1 IBM build cxppc321411-20040301 (JIT enabled: jitc))
</pre>

<p>
If you receive a "command not found" error, then try creating a symbolic link to 
the java command in /usr/bin by running the following command:
</p>

<pre class="command">
ln -s  /opt/IBMJava2-141/jre/bin/java /usr/bin/java
</pre>

<p><span class="bold">To start the server with the server daemon</span></p>

<p> 
Ensure that you are running using the root user ID. (If the daemon is not run under root, 
it will be unable to authenticate connecting users.) Run the following commands:
</p>

<pre class="command">
su -l root
cd /home/user/rdt-server
perl ./daemon.pl [daemonPort] [serverPortRange]
</pre>

<p>
Note that the server daemon runs on port 4075 by default. 
You can pass the optional daemonPort argument to force a different port if you want.
If your daemon runs behind a firewall, you may want to specify the optional 
serverPortRange argument to restrict selected server ports to the range given:
</p>

<pre class="command">
perl ./daemon.pl 4075 10000-10010
</pre>

<p><span class="bold">To start the server manually</span></p>

<p>
Note: In the following discussion we assume that the RSE server has been installed on Linux. 
If you are running on a UNIX system the script name is "server.sh" rather than "server.pl".
</p>
 
<p>
If you do not have root access on a remote machine, you can start the server manually 
for your particular user id only. Run the following commands:
</p> 

<pre class="command">
cd /home/user/rdt-server
perl ./server.pl [port]
</pre>

<p>
These commands run the server.pl script located in the /opt/rseserver 
directory. The port parameter to the server.pl script is optional. 
If you do not specify a port, then the server will pick the first 
one available and print the port number to standard out. 
By default, it is usually 4033. If you would like to use a different port, 
you will then have to enter this port number in port property for the 
Files subsystem for your connection in the Remote System Explorer 
(see Connecting to the Remote Server, below). Otherwise, you do 
not need to change this property.
<p>

<p>
Note: When you connect RSE to the server, the server will terminate as soon as you disconnect the client. 
The daemon, however, will not terminate. 
</p>



</body>
</html>
