Database and Repository Installation

Overview

Before proceeding with this installation, it is highly recommended to read through the Render Farm Considerations documentation.

The Database is the global database component of the Deadline Render Farm Management System. It stores the jobs, settings, and slave configurations. The Clients access the Database via a direct socket connection over the network. It only needs to be installed on one machine (preferably a server), and does not require a license. Deadline uses MongoDB for the Database.

The Repository is the global file system component of the Deadline Render Farm Management System. It stores the plugins, scripts, logs, and any auxiliary files (like scene files) that are submitted with the jobs. The Clients access the Repository via a shared network path. It only needs to be installed on one machine (preferably a server), and does not require a license.

The Database and Repository together act as a global system where all of Deadline’s data is stored. The Clients then connect to this system to submit, render, and monitor jobs. It is important to note that while the Database and Repository work together, they are still separate components, and therefore can be installed on separate machines if desired.

The Repository installer won’t install MongoDB database for you, so you’ll have to manually install MongoDB or connect to an existing MongoDB installation.

Manual Database Installation

This section will cover the basic steps required for you to manually download and install the MongoDB Database.

If you’re installing the MongoDB database on a machine running Linux or Mac OS X, you also have the option to download and install MongoDB through their associated package manager such as yum, apt, or homebrew. Just make sure the MongoDB version is 2.6.1 or later. For the purposes of this guide though, we will assume you’ve downloaded MongoDB manually.

Download and Install MongoDB

You can download the version of MongoDB that corresponds to your operating system from the MongoDB Downloads Page. Note that the MongoDB version must be 2.6.1 or later.

Once the download is finished, you’ll want to extract the compressed file (.tgz or .zip), rename the resulting folder to something readable (this guide will assume you chose application), and delete the compressed file. For example, mongodb-linux-x86_64-debian81.tgz decompresses to mongodb-linux-x86_64-debian81, and then can be renamed to application.

Next you’ll need to create a location to store the installation of the database. For the purpose of these instructions, we’re assuming these are the paths you’ll create:

  • Windows

    C:\DeadlineDatabase[VERSION]\mongo
    
  • Mac OS X

    /Applications/Thinkbox/DeadlineDatabase[VERSION]/mongo
    
  • Linux

    /opt/Thinkbox/DeadlineDatabase[VERSION]/mongo
    

Where [VERSION] is replaced with the major version of Deadline, such as 7. Follow this up by moving your application folder into this directory. Finally, create a data folder alongside the application folder.

Database Configuration

Before you run MongoDB, some configuration is required. First, a configuration file needs to be created, and then MongoDB should be configured to run as a service or daemon.

Configuration File (All Platforms)

A database configuration file has to be created in the data folder that you created above. For the purposes of this guide, this configuration file will be called config.conf. After creating the file, copy and paste the contents below into it. Before saving the file, be sure to make the following changes:

  • [PathToMongoDB] should be replaced with the path to the folder that contains the application and data folders you created earlier. If you’ve been following the instructions, that value will be C:\DeadlineDatabase[VERSION]\mongo, where [VERSION] is the major version of Deadline.
#MongoDB config file

#where to log
systemLog:
   destination: file
   path: [PathToMongoDB]/data/logs/log.txt
   quiet: true
   #verbosity: <integer>

#port for mongoDB to listen on
#uncomment below ipv6 and REST option to enable them.
net:
   port: 27070
   #ipv6: true
   #http:
         #RESTInterfaceEnabled: true

#where to store the data
storage:
 dbPath: [PathToMongoDB]/data

#enable sharding
#sharding:
   #clusterRole
   #configDB

#setup replica set with give replica set name
#replication:
   #replSetName

#enable authentication
#security:
   #authorization: enabled

These are the key settings defined in this file.

  • systemLog: path: This is where MongoDB will write its log to.
  • net: port: This is the port that MongoDB will listen on.
  • storage: dbPath: This is where MongoDB will save its data.

See the MongoDB Configuration File Options for more information on the available options. Note that if you change this file later, and MongoDB is already running, then you’ll need to restart the database service for the changes to go into effect.

Create Windows Service (Windows)

To have MongoDB run as a service on Windows, you’ll have to manually create the service. This can be done by launching a command prompt as an Administrator and running the following command. Before running the command, please make the following changes:

  • [VERSION] should be replaced with Deadline’s major version.
  • [PathToMongoInstall] should be replaced with the location of Deadline’s MongoDB folder. If you’ve been following the instructions, that value will be C:\DeadlineDatabase[VERSION]\mongo.
sc create Deadline[VERSION]DatabaseService binPath= "\"[PathToMongoInstall]\application\bin\mongod.exe\" --config \"[PathToMongoInstall]\data\config.conf\" --service" start= auto depend= TCPIP DisplayName= "Deadline [VERSION] Database Service"

Database Property List File (Mac OS X)

For Mac OS X, a plist file needs to be created to allow MongoDB to run as a daemon. For the purposes of this guide, this plist file will be called org.mongodb.mongod_Deadline[VERSION]DatabaseService.plist, where [VERSION] is the major version of Deadline. Create this file in a temporary location, and then copy and paste the contents below into it. Before saving the file, be sure to make the following changes:

  • [VERSION] should be replaced with Deadline’s major version.
  • [ReplaceWithServiceName] should be replaced with the name of the service. For example, Deadline[VERSION]DatabaseService.
  • [ReplaceWithMongoInstallPath] should be replaced with the path to Deadline’s MongoDB database. For example, /Applications/Thinkbox/DeadlineDatabase[VERSION].
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key>
  <string>org.mongodb.mongod_[ReplaceWithServiceName]</string>
  <key>ProgramArguments</key>
  <array>
        <string>[ReplaceWithMongoInstallPath]/mongo/application/bin/mongod</string>
        <string>run</string>
        <string>--config</string>
        <string>[ReplaceWithMongoInstallPath]/mongo/data/config.conf</string>
  </array>
  <key>RunAtLoad</key>
  <true/>
  <key>KeepAlive</key>
  <true/>
  <key>WorkingDirectory</key>
  <string>[ReplaceWithMongoInstallPath]/mongo/application/bin</string>
  <key>StandardErrorPath</key>
  <string>/var/log/mongo/output.txt</string>
  <key>StandardOutPath</key>
  <string>/var/log/mongo/output.txt</string>
  <key>HardResourceLimits</key>
  <dict>
        <key>NumberOfFiles</key>
        <integer>1024</integer>
  </dict>
  <key>SoftResourceLimits</key>
  <dict>
        <key>NumberOfFiles</key>
        <integer>1024</integer>
  </dict>
</dict>
</plist>

After saving the file, copy it to /Library/LaunchDaemons/.

Finally, the permissions will have to be set on the file to allow reading and writing, which can be done with the following command from a terminal. Before running the command, please make the following changes:

  • [VERSION] should be replaced with Deadline’s major version.
sudo chmod 644 /Library/LaunchDaemons/org.mongodb.mongod_Deadline[VERSION]DatabaseService.plist

Database Script File (Linux)

For Linux, an executable script file needs to be created to allow MongoDB to run as a service. For the purposes of this guide, this file will be called Deadline[VERSION]db, where [VERSION] is the major version of Deadline. Create this file in a temporary location, and then copy and paste the contents below into it. Before saving the file, be sure to make the following changes:

  • [VERSION] should be replaced with Deadline’s major version.
  • [PathToMongoDBBin] should be replaced with the path to MongoDB’s bin folder. Installer’s default path is /opt/Thinkbox/DeadlineDatabase[VERSION]/mongo/application/bin.
  • [PathToMongoDBData] should be replaced with the path to MongoDB’s data folder. Installer’s default path is /opt/Thinkbox/DeadlineDatabase[VERSION]/mongo/data.
#!/bin/bash
#
# mongodb Startup script for mongo DB
#
# chkconfig: - 20 80
# description: MongoDB (from "humongous") is a scalable, high-performance, open$

### BEGIN INIT INFO
# Provides: Deadline[VERSION]db
# Default-Start: 2 3 5
# Default-Stop:  0 1 4 6
# Required-Start: $network $local_fs $remote_fs
# Required-Stop: $network $local_fs $remote_fs
# Short-Description: Mongo DB NoSQL Database.
# Description: MongoDB (from "humongous") is a scalable, high-performance, open$
### END INIT INFO

# Source function library. (Supported only on Red Hat distributions.
( . /etc/rc.d/init.d/functions > /dev/null 2>&1 )

DEADLINEVERSION=[VERSION]
MONGODBBIN=[PathToMongoDBBin]
MONGODBDATA=[PathToMongoDBData]
MONGOSERVICEFILENAME="mongodb"
MONGOLOCK="/var/lock/subsys/deadline$DEADLINEVERSION$MONGOSERVICEFILENAME"
LOGFILE="/var/log/deadline$DEADLINEVERSION$MONGOSERVICEFILENAME.log"
PIDFILE="/var/run/deadline$DEADLINEVERSION$MONGOSERVICEFILENAME.pid"
RUNNING=0 # Is the process in our PID file running?
PID=-1    # What is the process ID?



check_running() {
        if [ -e "$PIDFILE" ]; then
                PID=`cat $PIDFILE`
                ps -p $PID &> /dev/null
                if [ $? -eq 0 ]; then
                        RUNNING=1
                else
                        RUNNING=0
                fi
        fi
}

start () {
        check_running
        if [ $RUNNING -eq 1 ]; then
                echo "MongoDB for Deadline $DEADLINEVERSION already running"
                echo
                exit 4
        else
                # Start mongod
                if [ -x "$MONGODBBIN/mongod" ]; then
                        ("$MONGODBBIN/mongod" --config "$MONGODBDATA/config.conf") &
                        echo $! > "$PIDFILE"
                        echo "MongoDB Started"
                        date "+%F %T: MongoDB Started" >> $LOGFILE
                        date "+%F %T: Full MongoDB log can be found in $MONGODBDATA/logs/log.txt" >> $LOGFILE

                        touch $MONGOLOCK 2> /dev/null

                        exit 0
                else
                        echo "Either mongod could not be found or could not be executed."
                        exit 1
                fi
        fi
}

stop () {
        check_running
        if [ $RUNNING -eq 1 ]; then
                echo "Shutting down MongoDB for Deadline $DEADLINEVERSION..."
                kill -QUIT $PID

                echo "MongoDB for Deadline $DEADLINEVERSION Stopped"
                date "+%F %T: MongoDB Stopped" >> $LOGFILE
                rm -rf "$PIDFILE"

                # Alright, it should actually be dead now, let init know.
                rm -f $MONGOLOCK

                exit 0
        else
                rm -rf "$PIDFILE"
                echo "MongoDB for Deadline $DEADLINEVERSION is not running"
                exit 7
        fi
}

restart() {
        check_running
        if [ $RUNNING -eq 1 ]; then
                echo "Shutting down MongoDB for Deadline $DEADLINEVERSION..."
                kill -QUIT $PID
                rm -rf "$PIDFILE"

                echo "MongoDB for Deadline $DEADLINEVERSION Stopped"
                date "+%F %T: MongoDB Stopped" >> $LOGFILE
        else
                rm -rf "$PIDFILE"
                echo "MongoDB for Deadline $DEADLINEVERSION is not running"
        fi

        start
}

reload() {
        restart
}

force_reload(){
        restart
}

rh_status(){
        check_running
        if [ $RUNNING -eq 1 ]; then
                echo "MongoDB for Deadline $DEADLINEVERSION is running as PID $PID."
                exit 0
        else
                echo "MongoDB for Deadline $DEADLINEVERSION is stopped."
                exit 3
        fi
}

rh_status_q(){
        rh_status > /dev/null 2>&1
}

# See how we were called.
case "$1" in
        start)
                $1
                ;;
        stop)
                $1
                ;;
        restart)
                $1
                ;;
        reload)
                rh_status_q || exit 7
                $1
                ;;
        force-reload)
                force_reload
                ;;
        status)
                rh_status
                ;;
        condrestart|try-restart)
                rh_status_q || exit 0
                restart
                ;;
        *)
                echo "Usage: $0 {start|stop|status|restart|condrestart|try-restart|reload|force-reload}"
                exit 3
esac

After saving the file, copy it to /etc/init.d/.

Finally, the permissions will have to be set on the file to allow reading, writing, and execution, which can be done with the following command from a terminal. Before running the command, please make the following changes:

  • [VERSION] should be replaced with Deadline’s major version.
sudo chmod 755 /etc/init.d/Deadline[VERSION]db

Start Database Service

Now that MongoDB is installed and configured, it’s time is to start your MongoDB service or daemon. This can be done by executing the following command from a command prompt or terminal. Just replace [Version] with Deadline’s major version:

  • Windows (as Administrator):

    sc start Deadline[VERSION]DatabaseService
    
  • Mac OS X:

    launchctl load /Library/LaunchDaemons/org.mongodb_Deadline[VERSION]DatabaseService.plist
    
  • Linux:

    sudo service Deadline[VERSION]DatabaseService start
    

Confirm that MongoDB is Running

For the final step, you’ll want to confirm that the MongoDB service or daemon is running. The command for each output can be found below, followed by an example of what the output looks like. Just replace [Version] with Deadline’s major version:

  • Windows:

    sc query Deadline[VERSION]DatabaseService
    
        SERVICE_NAME: Deadline7DatabaseService
        TYPE        : 10  WIN32_OWN_PROCESS
        STATE       : 4   RUNNING
        ...
    
  • Mac OS X:

    ps aux | grep mongo
    
        root ... /Applications/Thinkbox/DeadlineDatabase7/mongo/application/bin/mongod --config /Applications/Thinkbox/DeadlineDatabase7/mongo/data/config.conf
    
  • Linux:

    ps aux | grep mongo
    
        root ... /opt/Thinkbox/DeadlineDatabase7/mongo/application/bin/mongod --config /opt/Thinkbox/DeadlineDatabase7/mongo/data/config.conf
    

Additional Information

If you’re looking for more information, here are some helpful links for manually installing the MongoDB database:

MongoDB also has a management system called MMS. It’s a cloud service that makes it easy to provision, monitor, backup, and scale your MongoDB database. Here are some helpful links for setting up and using MMS:

The Automation Agent mentioned above makes it possible to setup your MongoDB database from a web interface, and easily configure which MongoDB servers are replica sets or shards. It also allows you to easily upgrade the version of your MongoDB database. Here are some additional links for how you can use the Automation Agent:

Mongo and MongoDB are registered trademarks of MongoDB, Inc.

Repository Installation

While the Repository can be installed on any operating system, the Repository installer is only available for Windows, Linux, and Mac OS X. However, the machine that you run the Repository installer on doesn’t have to be the same machine you’re installing the Repository to. For example, if you have an existing share on a FreeBSD server or a NAS system, you can run the Repository installer on Windows, Linux, or Mac OS X and choose that share as the install location.

To install the Repository, simply run the appropriate installer for your operating system and follow the steps. This procedure is identical for all operating systems. The Repository installer also supports silent installations.

setup directory

When choosing the Installation Directory, you can choose either a local path on the current machine, or the path to an existing network share. Note that if you choose a local path, you must ensure that path is shared on the network so that the Clients can access it. Do not install over an existing installation unless it’s the same major version, or there could be unexpected results.

If you’re installing over an existing Repository installation, all previous binaries, plug-ins, and scripts will be backed up prior to being overwritten. After the installation is complete, you can find these backed up files in the Backup folder in the Repository installation root. Note that installing over an existing repository is only supported for repairing a damaged repository, or for performing a minor upgrade. Major upgrades require a fresh repository installation. See the Upgrading or Downgrading Deadline Documentation for more information.

mongodb_setup

After choosing the installation directory, you will be asked to connect to an existing MongoDB Database.

mongodb_conn_settings

Next, you need to specify the Database Settings so that the installer can set up the Database. These settings will also be used by the Clients to connect to the database. The following are required:

  • Database Server: The host name or the IP address of the machine that the MongoDB database is running on. If desired, you can specify multiple entries and separate them with semicolons. There are a couple reasons to specify multiple entries:

    • You have machines on different subnets that need to access the database differently (ie: machines in the cloud might use a different host name than machines on the local network).
    • Some machines need to resolve the database machine by its host name, and others need to use its IP address.
Note that if there are IP addresses listed that cannot be resolved, the Deadline Command application can run slower on Linux and Mac OS X Clients because it won’t exit until the connection attempt for those IP addresses time out.
  • Database Port: The port that the MongoDB database is listening on.
  • Database Name: The name of the Database. If you are setting up a new Database, you can leave this as the default. If you are connecting to an existing Database, make sure to enter the same name you used when you initially set up the Database. If you are intending to setup 2 or more repositories completely separate from each other, then ensure you enter a different/unique name for your new database.
  • Replica Set: If you set up your MongoDB database manually and it is part of a Replica Set, specify the Replica Set Name here. If you don’t have Replica Set, just leave this blank.

When you press Next, the installer will try to connect to the database using these settings to configure it. This can take a minute or two. If an error occurs, you will be prompted with the error message. If the setup succeeds, you can then proceed with the installation of the Repository.

Command Line or Silent Installation

The Repository installer can be run in command line mode or unattended mode on each operating system. Note though that on Mac OS X, you must run the installbuilder.sh script that can be found in the Contents/MacOS folder, which is inside the Mac Repository Installer package.

To run in silent mode, pass the “–mode unattended” command line option to the installer. For example, on Windows:

DeadlineRepository-X.X.X.X-windows-installer.exe --mode unattended

To run in command line mode, pass the “–mode text” command line option to the installer. For example, on Linux:

./DeadlineRepository-X.X.X.X-linux-x64-installer.run --mode text

To get a list of all available command line options, pass the “–help” command line option to the installer. For example, on Mac OS X:

/DeadlineRepository-X.X.X.X-osx-installer.app/Contents/MacOS/installbuilder.sh --help

Note that there are a few Repository installer options that are only available from the command line, which you can view when running the “–help” command. These options include:

  • --help: Display the list of valid options.
  • --version: Display product information.
  • --unattendedmodeui <unattendedmodeui>: Unattended Mode UI. Default: none. Allowed: none minimal minimalWithDialogs.
  • --optionfile <optionfile>: Installation option file. Default: "".
  • --debuglevel <debuglevel>: Debug information level of verbosity. Default: 2. Allowed: 0 1 2 3 4.
  • --mode <mode>: Installation mode. Default: osx. Allowed: osx text unattended.
  • --debugtrace <debugtrace>: Debug filename. Default: "".
  • --installer-language <installer-language>: Language selection. Default: en. Allowed: en.
  • --prefix <prefix>: The path to install the Repository to. Default: /Applications/Thinkbox/DeadlineRepository7 (Mac OS X), C:\Program Files\Thinkbox\DeadlineRepository7\ (Win) or /opt/Thinkbox/DeadlineRepository7\ (Linux).
  • --backuprepo <backuprepo>: If set to true, many folders in the Repository will be backed up before overwriting them. Default: true.
  • --dbListeningPort <dbListeningPort>: MongoDB Port. Default: 27070.
  • --dbhost <dbhost>: The host name or IP address of the machine that MongoDB is running on. Default: "".
  • --dbport <dbport>: The port that MongoDB is listening on. Default: 27070.
  • --dbname <dbname>: The name of the MongoDB database that the data is stored in. Default: deadline7db.
  • --dbreplicaset <dbreplicaset>: The name of the MongoDB database replica set, if you have one set up. Default: "".
  • --dbuser <dbuser>: The user name to connect to MongoDB with. Default: "".
  • --dbpassword <dbpassword>: The password to connect to MongoDB with. Default: "".
  • --dbauth <dbauth>: If enabled, Deadline will use this account to connect to MongoDB. Default: false.
  • --dbsplit <dbsplit>: If enabled, the database collections will be split into separate databases to improve performance. Default: true.

Note, where applicable (contains spaces), it is recommended to encapsulate options in quoatation marks, such as:

--prefix "C:\Program Files\Thinkbox\DeadlineRepository7\" --mongodir "C:\Program Files\Thinkbox\DeadlineDatabase7\"

Installation Logging

Our Repository installer creates an installation log in the system’s temporary directory. On Linux and Mac OS X, this typically means the /tmp directory. On Windows, the log will be created in the user’s local temp directory, usually C:\Documents and Settings\%username%\Local Settings\Temp. The default name of the generated log file is bitrock_installer.log, but if the file already exists from a previous installation, the installer will try to create an unique filename trying bitrock_installer_[pid].log and bitrock_installer_[pid]_[uid].log where [pid] is the PID of the process and [uid] is an unique identifier. On Linux, if the /tmp directory is not writable, it will attempt to use /var/tmp, /usr/tmp and ~/tmp instead.

Database Resource Limits

Linux and Mac OS X systems impose a limit on the number of resources a process can use, and these limits can affect the number of open connections to the database. It is important to be aware of these limits, and make sure they are set appropriately to avoid unexpected behaviour. Note that MongoDB will allocate 80% of the system limit for connections, so if the system limit is 1024, the maximum number of connections will be 819.

If you choose a Linux system to host the database, make sure the system limits are configured properly to avoid connection issues. See MongoDB’s Linux ulimit Settings documentation for more information, as well as the recommended system limits to use.

You can check your current Linux/Mac OS X ulimit settings in a terminal shell:

#overall ulimit settings on the machine
>>> ulimit -a
#number of open files allowed
>>> ulimit -n

MongoDB provides these Recommended ulimit Settings for optimal performance of your database. Note, you must restart the Deadline Database daemon after changing these ulimit settings.

If you choose a Mac OS X system to host the database the resource limits will be set to 1024. These limits can be adjusted later by manually editing the HardResourceLimits and SoftResourceLimits values in /Library/LaunchDaemons/org.mongodb.mongod.plist after the Repository installer has finished.

Open Firewall Ports

To ensure that the Deadline applications can communicate with MongoDB, you will need to update the firewall on the machine that MongoDB is running on. You can either disable the firewall completely (assuming it operates in an internal network), or you can open the port that you chose for the database to use during install. More information on opening ports can be found below.

Windows

Open Windows Firewall with Advanced Security. Click on Inbound Rules in the left panel to view all inbout rules, and then right-click on Inbound Rules and select New Rule to start the Inbound Rule Wizard. Select Port for the Rule Type, and then click Next.

new_rule rule_type

On the Protocol and Ports page, choose TCP, and then specify the port that you chose for the database during the install, and then press next. Then on the Action page, choose Allow The Connection and press Next.

rule_port rule_allow

On the Profile page, choose the networks that this rule applies to, and then press next. Then on the Name page, specify a name for the rule (for example, MongoDB Connection), and then press Finish.

rule_network rule_name

Linux

On RedHat and CentOS, the following commands should allow incoming connections to the Mongo database if iptables are being used. Just make sure to specify the port that you chose for the database during the install.

>>> sudo iptables -I INPUT 1 -p tcp --dport 27070 -j ACCEPT
>>> sudo ip6tables -I INPUT 1 -p tcp --dport 27070 -j ACCEPT

Ubuntu has no firewall installed by default, and we have not yet tested Fedora Core’s FirewallD.

Mac OS X

Mac OS X has its firewall disabled by default, but if enabled, it is possible to open ports for specific applications. Open up System Preferences,, choose the Security & Privacy option, and click on the Firewall tab.

../_images/mac_firewall.png

Press the Firewall Options button to open the firewall options. Press the [+] button and choose the path to the mongod application, which can be found in the database installation folder in mongo/application/bin (for example, /Applications/Thinkbox/DeadlineDatabase7/mongo/application/bin/mongod). Then click OK to save your settings.

../_images/mac_firewall_options.png

Sharing The Repository Folder

In general, the Repository must have open read and write permissions for Deadline to operate properly. This section explains how to share your Repository folder and configure its permissions to ensure the Clients have full access. Without full read/write access, the Client applications will not be able to function properly.

Note that this guide is for applying full read/write permissions to the entire Repository folder structure. For the more advanced user, it is possible to enforce tighter restrictions on the Repository folders. Just make sure the Clients have full read/write access to the following folders in the Repository. The rest must have at least read access.

  • jobs: This is where job auxiliary files are copied to during submission.
  • jobsArchived: This is where archived jobs are exported to.
  • reports: This is where the physical log files for job and slave reports are saved to.

Windows

First, you need to configure the Repository folder permissions. Note that the images shown here are from Windows XP, but the procedure is basically the same for any version of Windows.

  • On the machine where the Repository is installed, navigate to the folder where it is installed using Windows Explorer.
  • Right-click on the Repository folder and select Properties from the menu.
  • Select the Security tab.
../_images/windows_initial_security_screen.png
  • If there is already an Everyone item under Group or user names, you can skip the next two steps.
  • Click on the Add button.
  • In the resulting dialog, type Everyone and click OK.
../_images/select_users_or_groups.png
  • Select Everyone under Group or user names.
  • Ensure that Modify, Read & Execute, List Folder Contents, Read, and Write are all checked under the Allow column.
  • Click on the OK button to save the settings.
../_images/finish_security_screen.png

Second, you need to share the Repository folder. Note that the images shown here are from Windows XP, but the procedure is basically the same for any version of Windows.

  • On the machine where the Repository is installed, navigate to the folder where it is installed using Windows Explorer.
  • Right-click on the Repository folder and select Properties from the menu. If you’re unable to see the Sharing tab, you may need to disable Simple File Sharing in the Explorer Folder Options.
../_images/folder_options.png
  • Select the Sharing tab.
../_images/windows_repo_props.png
  • Select the option to Share This Folder, then specify the share name.
  • Click the Permissions button.
  • Give Full Control to the Everyone user.
  • Press OK on the Permissions dialog and then the Properties dialog.
../_images/windows_permission.png

Linux

Since the Clients expects full read and write access to the repository, it’s recommended to use a single user account to mount shares across all machines. It is possible to add particular users to a ‘deadline’ group, but you will need to experiment with that on your own.

So for both of the sharing mechanisms we explain below, you’ll need to create a user and a group named ‘deadline’. They don’t need a login or credentials, we just need to be able to set files to be owned by them and for their account to show up in /etc/passwd. So, to do this use the useradd command.

>>> sudo useradd -d /dev/null -c "Deadline Repositry User" -M deadline

This should create a user named “deadline” with no home folder, and a fancy comment. The account login should also be disabled, meaning your standard users can’t ssh or ftp into your file server using this account. Set a password using sudo passwd deadline if you need your users to login as deadline using ftp or ssh.

Now add a group using

>>> sudo groupadd deadline

And finally, have the Repository owned by this new user and group

>>> sudo chown -R deadline:deadline /path/to/repository
>>> sudo chmod -R 777 /path/to/repository

Now you’re ready to set up your network sharing protocol. There are a many ways this can be done, and this just covers a few of them.

Samba Share

This is an example entry in the /etc/samba/smb.conf file:

[DeadlineRepository]
path = /path/to/repository
writeable = Yes
guest ok = Yes
create mask = 0777
force create mode = 0777
force directory mode = 0777
unix extensions = No

NFS Share

The simplest thing that could possibly work. Note that this is not the most secure thing that could possibly work:

If you do not have a /etc/exports file, you may need to install an NFS server. To do so, open a terminal or your favourite package manager to install one. For Ubuntu Server, type the following:

>>> sudo apt-get install nfs-kernel-server

For Linux and BSD, open up /etc/exports as an administrator, and make one new export:

/path/to/repository                  192.168.2.0/24(rw,all_squash,insecure)

Breakdown of this command is as follows:

  • /path/to/repository: The Repository folder to share. Change the path as necessary.
  • 192.168.2.0/24: The IP range to allow. The zero is important for these ranges. You can also go by hostname if you have reverse DNS, or * to allow from anyone’s computer.
  • rw: Allow read/write for the repository, which is required for the Clients to operate properly.
  • all_squash: Make every single person who connects to the Repository share map to the nobody:nogroup user and group. This relieves a lot of permissions pain for new users at the cost of zero security. Files and folders within your repository will be fully readable and writeable by whomever is able to connect to your NFS server. The Clients require this, but it can also be achieved by creating a group and adding individual users into that group. Many studios will only need all_squash as Deadline will keep track of who submits what jobs.
  • insecure: Required for Mac OS X to mount nfs shares. It simply means that NFS doesn’t need to receive requests on a port in the secure port range (a port number less than 1024).

Then start up the server (for those living in an init.d world):

>>> sudo /etc/init.d/nfs-kernel-server start

Any time you change the exports file, you’ll need to issue the same command, but replace ‘start’ with ‘reload’.

There is an excellent tutorial here as well: https://help.ubuntu.com/community/SettingUpNFSHowTo

Mac OS X

First, you need to configure the Repository folder permissions. Note that the images shown here are from Leopard (10.5), but the procedure is basically the same for any version of Mac OS X.

  • On the machine where the Repository is installed, navigate to the folder where it is installed using Finder.
  • Right-click on the Repository folder and select Get Info from the menu.
  • Expand the Sharing & Permissions section, and unlock the settings if necessary.
  • Give everyone Read & Write privileges.
  • While probably not necessary, also give admin Read & Write privileges.
../_images/initial_security_screen_mac.png

If you prefer to set the permissions from the Terminal, run the following commands:

$ chown -R nobody:nogroup /path/to/repository
$ chmod -R 777 /path/to/repository

Now you can share the folder. There are a many ways this can be done, and this just covers a few of them.

Using System Preferences

Note that the images shown here are from Leopard (10.5), but the procedure is basically the same for any version of Mac OS X.

  • Open System Preferences, and select the Sharing option.
  • Make sure File Sharing is enabled, and then add the Repository folder to the list of shared folders.
  • Under Users, give everyone Read & Write privileges.
  • If sharing with Windows machines, press the Options button and make sure the “Share files and folders using SMB (Windows)” is enabled.
../_images/mac_sharing.png

Samba Share

Interestingly, Mac OS X uses samba as well. Apple just does a good job of hiding it. To create a samba share in Mac OS X, past this at the bottom of /etc/smb.conf:

[DeadlineRepository]
path = /path/to/repository
writeable = Yes
guest ok = Yes
create mask = 0777
force create mode = 0777
force directory mode = 0777
unix extensions = No

Uninstallation

The Repository installer creates an uninstaller in the folder that you installed the Repository to. To uninstall the Repository, simply run the uninstaller and confirm that you want to proceed with the uninstallation.

../_images/uninstall_repo.png

Note that the Database that you manually installed will be unaffected.

Command Line or Silent Uninstallation

The Repository uninstaller can be run in command line mode or unattended mode on each operating system.

To run in command line mode, pass the “–mode text” command line option to the installer. For example, on Linux:

./uninstall --mode text

To run in silent mode, pass the “–mode unattended” command line option to the installer. For example, on Windows:

uninstall.exe --mode unattended

To get a list of all available command line options as a pop-up dialog, pass the “–help” command line option to the installer. For example, on Windows:

uninstall.exe --help

To get a list of all available command line options in the terminal, pass the “–help” command line option to the installer and an additional option when on Mac OS X:

./uninstall osx-intel --help

Note that there are a few Repository uninstall options that are only available from the command line, which you can view when running the “–help” command. These options include:

  • --help: Display the list of valid options.
  • --version: Display product information.
  • --debuglevel <debuglevel>: Debug information level of verbosity. Default: 2. Allowed: 0 1 2 3 4.
  • --mode <mode>: Installation mode. Default: osx. Allowed: osx text unattended.
  • --debugtrace <debugtrace>: Debug filename. Default: "".
  • --installer-language <installer-language>: Language selection. Default: en. Allowed: en.

Uninstall Logging

Our Repository uninstall process creates an uninstall log in the system’s temporary directory with the same behaviour as the Repository Installation log.