Symphony Documentation: Installation, Setup, and
Execution
Installation
There are two parts to installing Symphony. The first is to get the Symphony
beans loaded into the BeanBox. The second is to install Symphony servers on any
machines that are to be accessed remotely during a particular meta-program's execution.
The Symphony Beans
- Install the Java Bean Development Kit (BDK) environment as specified by the
distribution's documentation. The BDK is available for download from Sun Microsystems
at http://java.sun.com.
- The preceding step will have created a
directory structure that contains a directory named "jars". This directory holds
any beans that are to be loaded automatically upon running the BeanBox. The file named
"symphony.jar" contains all of the additional beans that Symphony requires. Place this
file into the "jars" directory.
The Symphony Server
- On the remote machine, create a directory for the server. Place the file named
"symphony_server.jar" into the new directory.
- The Java Development Kit (JDK), after version 1.1.6, comes with a command named
"jar" that dearchives jar files. Give the following command:
jar xvf symphony_server.jar
This will install all of the files that the Symphony server requires into the proper
subdirectories.
Symphony Setup
Most of the following will have been done as a result of the initial JDK
installation. It is important enough to bear repeating. Make sure that this
configuration occurs on both the machine that is running the BeanBox, and the
machines that run the server.
The user must have properly set environment variables, specifically the "path"
and "CLASSPATH" variables must be set:
- To set the two variables above, changes must be made to the "rc" file
for the shell that the user is running under. The following example assumes that
the user runs the c-shell (csh). This implies that the user relies on a .cshrc
file to set environment variables.
- The path line likely exists already in the user's shell "rc" file. For
instance, if running the csh shell, the user will have a file named ".cshrc" in
their home directory. The path line will look something like "path = (. /usr/bin
/bin /usr/local/bin)" Add to this line (inside the parentheses) the path to the location of
the Java Runtime Environment (JRE) on the system.
- The most common JRE is the one that comes with the
JDK released by Sun. If version 1.1.6 of the JDK has been installed in the
/usr/local directory, then the string to append to the path is:
"/usr/local/jdk1.1.6/bin"
- In the same file add a new line to create a CLASSPATH variable. If version
1.1.6 of the JDK has been installed in the /usr/local directory, then the CLASSPATH
should read:
setenv CLASSPATH ".:..:/usr/local/jdk1.1.6/lib/classes.zip"
In this case the quotation marks should remain.
Execution
Once all of the above are
completed, running symphony is as simple as starting up the BeanBox.
The Symphony Beans in the BeanBox
- Change to the "beanbox" directory under the BDK installation. There will be a
script named "run.sh" in that directory.
- On the command line enter "run.sh &" to start the BeanBox.
- A small window will appear indicating that the BeanBox is loading the beans
contained in the "jars" directory. This step may take a few moments.
- Three windows will replace the first one: A ToolBox pallet, the BeanBox window,
and a Properties window. The BeanBox is now loaded with Symphony ready to be used.
The Symphony Server
- Under the directory where the Symphony server was installed, is a directory named
"codebase". Go to this directory.
- Give the following command:
run_server.sh
The server will indicate that it is starting up and, after a few moments, indicate that
it has bound itself in the registry and is ready to be used. There is no need to explicitly
run the server in the background as this is done automatically. Further, once the server
is running, it will remain so until the user explicitly kills the process. The server will
keep running even if the user logs out. Starting the server when another is already running
will cause two different servers to be running simultaneously.