Installing RAMADDA

Previous: Installation and Site Administration

11.0 Installing RAMADDA

First you need to download RAMADDA. The RAMADDA downloads area can be accessed here:
http://www.unidata.ucar.edu/downloads/ramadda/index.jsp.
You will need to register at the Unidata site to access the downloads area.

RAMADDA can run under Tomcat or can run stand-alone with just Java. To run under Tomcat download the repository.war file. To run stand alone download the repository.zip file.

The major difference is that when running stand-alone RAMADDA does not support SSL access. To use SSL you should run under Tomcat (or some other Java servlet container) and configure that for SSL access. For more information see the SSL FAQ.

Running under Tomcat

To run under Tomcat just place the repository.war in the tomcat webapps directory. By default the repository is accessed at /repository on the web server.

You need to specify the ramadda home directory. This is where it looks for properties files and other resources, where the java derby database is stored and where any uploaded data files are stored.

By default ramadda will use:

   <tomcat home>/.unidata/repository

i.e., the home directory of the process that runs tomcat.

You can override this a number of ways. What ramadda does is look for the property: ramadda_home in a variety of places, in precedence:

In the web.xml
In the web.xml in the repository.war you can specify command line properties:
```
    <param-value>-Dramadda_home=/home/dir</param-value>
```
The problem with this is you have to unjar the war and change the web.xml. Then, when you install a new release you have to repeat the process.
As a Java environment variable
Wherever you define the arguments that are passed to java when starting Tomcat include:
```
-Dramadda_home=/home/dir
```
e.g.:
```
java -Xmx512m  -Dramadda_home=/home/dir
```
As a process environment variable.
Environment variables can be set for the tomcat process Just define:
```
ramadda_home=/home/dir
```

Running Standalone

You can run RAMADDA stand-alone. This is really useful for development and just requires Java 1.5 or greater. First, download and unzip the repository.zip file.

To run RAMADDA run the ramadda.sh in the release directory. This just does:

   java -Xmx512m -jar repository.jar

By default the server is on port 8080. To change the port do:

    java -Xmx512m -jar repository.jar -port <some port>

RAMADDA creates a local storage directory in:

<home dir>/.unidata/repository

To change this do:

    java -Xmx512m -jar repository.jar -Dramadda_home=/home/dir

Directory Structure

Under the home directory RAMADDA will create the following subdirectories:

htdocs
This is where RAMADDA will first look for any static web content that it is serving. If it cannot find the file here it looks in its internal system area. So, if you want to change the system style sheet, the logo.png file or any other web content just place it here.
Note: Files here are relative to the top-level repository path. For example, if you have a URL:
```
    http://yourserver.edu/repository/somefile.gif
```
Then RAMADDA will strip off the "repository" prefix and look for a file in the RAMADDA home dir:
```
    htdocs/somefile.gif
```
If you had a URL:
```
    http://yourserver.edu/repository/somedir/somefile.gif
```
Then RAMADDA looks in:
```
    htdocs/somedir/somefile.gif
```
logs
Holds the log files.
plugins
RAMADDA has a plugin mechanism and it looks in this directory for the plugins.
resources
This is where RAMADDA will first look for any internal resources (e.g., html template files, etc.)
storage
This is where the uploaded files are stored. The directory strucuture is:
```
y<the year>/m<the month>/d<the day>/the files
```
There is also an upload directory that holds any anonymously uploaded files.
entries
This is where any attachments or any other file associated with an entry (except for the actual entry file) is held.
tmp
A temporary file space. RAMADDA manages the scouring ,etc., of old files.
derby
If you are running with the Derby database this directory holds the database

Configuration

RAMADDA for the most part can be configured through the Admin pages. When you are logged in to RAMADDA as an administrator there should be a "Admin" on the left side of the page.

Common tasks include:

Change the repository title and logo in the Admin->Settings->Display
Setting up an email server so RAMADDA can send email to users (e.g., for password notification). This is done on the Admin->Settings->Site and Contact Information page.
Enabling SSL for secure login and admin access.
Adding new users.
Creating new groups and uploading files.
Defining where RAMADDA can serve files from.
Limiting access to certain parts of the repository.

Changing the Main Page

To change the presentation of the main entry page (the top-level RAMADDA page) you simply change the name and description for the Entry. You do this with the Edit->Edit Entry menu.

You can use the wiki text facility (see "Wiki Text in Other Entries") for the description to customize the look and feel. For example, on our main RAMADDA site we have changed the name of the top level Entry to "RAMADDA". We also have this for the description:


<wiki>
Welcome to Unidata's RAMADDA data repository. 
RAMADDA is a content management system with a focus on Earth Science data.

More information is available [http://www.unidata.ucar.edu/software/ramadda/index.html here].

===Links:===
{{children title="Links" showhide="false"}}

Other Configuration Options

For other configuration options RAMADDA looks in its home directory for a repository.properties To configure RAMADDA create a repository.properties file or copy this one. The properties defined in the local file override the ones defined in the system file.

In the source release the system properties file can be viewed:
/ucar/unidata/repository/resources/repository.properties

Configuring the Database

By default RAMADDA uses a built in Java Derby database. RAMADDA also runs using mysql and postgres (though the postgres hasn't been test in a while). Derby works pretty well though we have seen some performance issues with search. If you are planning on really using RAMADDA and foresee a large amount of content stored in the repository (by large we don't mean file size but rather we mean number of entries in the repository) then its probably a good idea to use mysql or postgres.

To define the database just uncomment the appropriate ramadda.db properties in repository.properties:

ramadda.db=derby
#ramadda.db=mysql
#ramadda.db=postgres

The mysql database and user/password is defined in the repository.properties file. To change the port or server the database is on and to change the user name/password just edit:

ramadda.db.mysql.url=jdbc:mysql://localhost:3306/repository?zeroDateTimeBehavior=convertToNull
ramadda.db.mysql.user=the database user
ramadda.db.mysql.password=the database password