Skip to content

Latest commit

 

History

History
376 lines (260 loc) · 11.8 KB

install-binary.rst

File metadata and controls

376 lines (260 loc) · 11.8 KB
Raw

Installation of Pre-Generated Packages

Debian Packages

Debian packages for several versions of |ubuntu| are available from the CoR-Lab `repository server`_.

  1. The following repository source line has to be added to :file:`/etc/apt/sources.list`

    deb http://packages.cor-lab.de/ubuntu/ :samp:`{RELEASENAME}` main testing

    where :samp:`{RELEASENAME}` is one of |debian_versions|.

    Note

    In case you add this line using a graphical package manager, some of these tools also propose to add a second line for source packages starting with deb-src. As we do not provide source packages, this line should not be added or needs to be removed manually.

    Note

    To prevent verification errors you also need to add our package server key to your system. Please follow the instructions available at http://packages.cor-lab.org.

  2. After that, packages can be installed via

    $ sudo apt-get install |debian_package_names|

    The above command installs the C++ and Common Lisp implementations of |project|. Of course, it also possible to only install a subset of the above packages.

    Note

    Support for the :term:`Spread` :term:`transport` is no longer automatically installed with |project|. Support for :term:`Spread` can be installed by executing

    $ sudo apt-get install |debian_package_names_spread|

Note

This installation method only works with |ubuntu|. More information can be found here.

Python PyPI Packages

For Python, platform-independent packages are pushed to the central repository server and can be installed with :program:`pip` or :program:`easy_install`.

Note

:program:`pip` is the recommended way of installing Python packages since some time and preferred over :program:`easy_install`. On |ubuntu| systems, :program:`pip` can be installed via the package python-pip.

Note

The Python implementation of |project| is currently only available for Python 2.X. If the default Python version on your system is Python 3, ensure that you call the respective :program:`easy_install` or :program:`pip` version. These usually contain the Python version as a suffix to the name, e.g.: easy_install-2.7.

  1. The installation of the Python implementation of |project| requires the `Google Protocol Buffers`_ compiler (:program:`protoc`) on your system. Before starting the installation, install :program:`protoc` and ensure that this binary can be found from the :envvar:`PATH` environment variable.

    To install :program:`protoc` we recommend to use Debian packages on |ubuntu| and `Homebrew`_ on MacOS. The respective installation commands are:

    $ sudo apt-get install protobuf-compiler
    $ brew install protobuf

  2. The installation of the Python implementation of |project| requires the `Google Protocol Buffers`_ module on your system. Depending on whether :program:`pip` or :program:`easy_install` is used, do one of the following:

    $ easy_install protobuf
    $ pip install protobuf

    Note

    These commands will install protobuf for the whole system and require root permissions. If you only want to install protobuf for your local user, add the --user option to the call of :program:`easy_install` or pip install. The same applies for the subsequently described installation of rsb-python itself.

  3. The rsb-python module can be installed by using one of the following functions:

    $ easy_install "rsb-python<=:samp:`{VERSION}`.99999"

    $ pip install "rsb-python<=:samp:`{VERSION}`.99999"

    where :samp:`{VERSION}` needs to be replaced with |version|.

    Note

    Development versions of |project| are not deployed on PyPI. These commands will revert to the latest stable version.

  4. If you plan to use the :term:`Spread` :term:`transport`, you need to additionally install the Python :term:`Spread` module which is available at: |spread_python_tarball|. The version of this module which is pushed to the PyPI is outdated and does not work with :term:`Spread` version 4. You need to compile this module on your own.

Mac Homebrew

|project| uses :term:`homebrew` for installation on MacOS. For further information on the ideas behind homebrew please check this blog post. To install |project| from source on MaxOS the following steps are required:

Note

As precondition XCode needs to installed. This can be easily achieved through the MacOS X App Store. A further requirement for installing Unixoid software components are the XCode Command Line Tools. They can be installed from within XCode (:menuselection:`XCode --> Preferences --> Downloads`) and install Command Line Tools.

  1. Bootstrapping :term:`homebrew` itself:

    Installing :term:`homebrew` on MacOS is simple as that:

    $ ruby -e "$(curl -fsSkL raw.github.com/mxcl/homebrew/go)"

    Note

    After the installation, you can run the following command to check if :term:`homebrew` was installed correctly:

    $ brew doctor

  2. Install the C++ implementation of |project| (core library and tools) with :term:`homebrew`:

    $ brew tap corlab/homebrew-formulas
$ brew install rsb-tools-cpp

    Note

    After the installation, you can run the following command to check if |project| was installed correctly:

    $ rsb_version

Note

If the formula conflicts with one from mxcl/master or another tap, you can :samp:`brew install corlab/homebrew-formulas/{FORMULA}`.

You can also install via URL:

$ brew install https://raw.github.com/corlab/homebrew-formulas/master/rsb.rb

Note

For MacOS X 10.8 users: on mountain lion, X11 is not provided anymore. For the core library of |project|, X11 is not needed, but many downstream projects require it. So, if you need to install XQuartz you can get it from http://xquartz.macosforge.org/landing/. This is recommended (but not necessary) also on earlier MacOS versions as XQuartz is more robust and up-to-date than the system-provided X11.

Java

Pre-compiled JAR Download

Archives containing pre-built JAR-files of the Java implementation and required dependencies can be downloaded from the continuous integration server.

After downloading the archive, several JAR-files can be extracted from it. These files have to be placed on the Java classpath. Afterwards, the Java implementation of |project| should be usable in any Java program.

Maven Artifacts from the CITEC Repository

|project| java is also deployed to the CITEC `Maven`_ repository at https://mvn.cit-ec.de/. In order to use the version deployed there, include the following fragments in the :file:`pom.xml` of your project.

  1. In the dependencies section:

    <dependencies>
    <dependency>
        <groupId>rsb</groupId>
        <artifactId>rsb</artifactId>
        <version>0.19-SNAPSHOT</version>
    </dependency>
</dependencies>

  2. In the repositories section:

    <repositories>
    <repository>
        <id>citec-releases</id>
        <name>CITEC Maven Repository Server</name>
        <url>https://mvn.cit-ec.de/nexus/content/repositories/releases/</url>
        <layout>default</layout>
        <releases>
            <enabled>true</enabled>
        </releases>
    </repository>
    <repository>
        <id>citec-snapshots</id>
        <name>CITEC Maven Repository Server</name>
        <url>https://mvn.cit-ec.de/nexus/content/repositories/snapshots/</url>
        <layout>default</layout>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>

Binary Downloads of Tools

  1. Download the |main_binary| binary from the appropriate location:

  2. After the download, the |main_binary| file has to be made executable in most cases. This can be done for example by executing

    $ chmod +x rsb

    in the download directory.

Pre-Compiled Windows Archive

As compiling cross-platform C++ code on Windows can easily become a nightmare, we provide a ZIP archive with |project| for C++ as well as all other RSX-related software pre-compiled for Windows in 32 bit mode using different Visual Studio versions.

  1. Download the artifact for your Visual Studio version

    In order to install the complete collection of RSX C++ software, you first need to know the numeric version of the Visual Studio version you want to work with. E.g. Visual Studio 2010 corresponds to version 100 and Visual Studio 2012 corresponds to numeric version 110. As soon as you know this you can select the appropriate configuration from this CI server job: https://ci.cor-lab.org/job/rsx-trunk-windows-package/ (by clicking on the appropriate version name). After selecting the configuration, download the latest successful artifact (a zip file).

  2. Extract the archive

    Extract the archive to your desired target destination on your hard drive.

You end up with a folder containing one subfolder for each RSX project and all dependencies like the boost libraries.

Executing Programs Against the Archive

In order to execute programs that use software provided in the archive you need to extend the Windows PATH environment variable to point to all folders in the archive structure that contain DLL files. Otherwise you will receiving missing DLL warnings when trying to execute programs.

Please ensure that you do not have other Boost version etc. in your PATH than the ones provided in the archive.

Compiling Against the Archive

Windows is very picky about mixing different runtime libraries. All software provided in the archive is compiled in multi-threaded debug mode. Your client software should be compiled with exactly these settings to prevent unpredictable errors.