[Documentation] [TitleIndex] [WordIndex] 

Installation Instructions for Groovy in Fedora

This page describes how to install Groovy in Fedora. Fedora is not officially supported by ROS and the installation might fail for several reasons. This page does not (yet) contain instructions for most higher level ROS packages, only for the base system. This includes the middleware and command line tools but not much more.

Contents

  1. Installation Instructions for Groovy in Fedora
    1. Prerequisites
    2. Installation
      1. Building the catkin Packages
      2. Build the rosbuild Packages
    3. Troubleshooting
      1. Wet Packages
      2. Dry Packages
  2. Installing on Fedora 16 and 17

The following installation instructions are targeted for Fedora 18 and are currently a work in progress. Workarounds and patches for issues that may arise during installation will be posted after the installation instructions until we're able to get these fixes merged into package releases. Finally, instructions for installing ROS on Fedora 16 or 17 can be found at the bottom of the page, but there are no guarantees for the outcome of the install.

Prerequisites

Before you proceed, enabling RPM Fusion on your system will be necessary in order to have access to all required packages that will be installed during the installation process.

To enable RPM Fusion on Fedora 18:

Now, if you installed Fedora with the default options, then you're probably missing a C++ compiler, patch, git, and pip. These can be installed with:

The Fedora package calls pip "python-pip", while rosdep only looks for "pip". We'll make a symlink to handle this:

Next, we need to install a few ROS python tools using pip:

In order to use rosdep, we need to initialize it:

Installation

Start by building the core ROS packages.

Building the catkin Packages

ROS is in the process of converting to a new build system, catkin, but not all of the packages have been converted and the two build systems cannot be used simultaneously. Therefore it is necessary to build the core ROS packages first (catkin packages) and then the rest.

Create a catkin Workspace

In order to build the core packages, you will need a catkin workspace. Create one now:

Next we will want to fetch the core packages so we can build them. We will use wstool for this. Select the wstool command for the particular variant you want to install:

Desktop-Full Install: ROS, rqt, rviz, robot-generic libraries, 2D/3D simulators, navigation and 2D/3D perception

Desktop Install (recommended): ROS, rqt, rviz, and robot-generic libraries

ROS-Comm: (Bare Bones) ROS package, build, and communication libraries. No GUI tools.

This will add all of the catkin or wet packages in the given variant and then fetch the sources into the ~/ros_catkin_ws/src directory. The command will take a few minutes to download all of the core ROS packages into the src folder. The -j8 option downloads 8 packages in parallel.

In addition to the 3 variants above, more are defined in REP 131 such as robot, perception, etc. Just change the package path to the one you want, e.g., for robot do: 

$ wstool init -j8 http://packages.ros.org/web/rosinstall/generate/dry/raw/groovy/robot

Resolving Dependencies

Before you can build your catkin workspace you need to make sure that you have all the required dependencies. We use the rosdep tool for this:

This will look at all of the packages in the src directory and find all of the dependencies they have. Then it will recursively install the dependencies.

The --from-paths option indicates we want to install the dependencies for an entire directory of packages, in this case src. The --ignore-src option indicates to rosdep that it shouldn't try to install any ROS packages in the src folder from the package manager, we don't need it to since we are building them ourselves. The --rosdistro option is required because we don't have a ROS environment setup yet, so we have to indicate to rosdep what version of ROS we are building for. Finally, the -y option indicates to rosdep that we don't want to be bothered by too many prompts from the package manager.

After a while (and maybe some prompts for your password) rosdep will finish installing system dependencies and you can continue.

Building the catkin Workspace

Once it has completed downloading the packages and resolving the dependencies you are ready to build the catkin packages. We will use the catkin_make_isolated command because there are both catkin and plain cmake packages in the base install, when developing on your catkin only workspaces you should use catkin/commands/catkin_make.

Invoke catkin_make_isolated:

Note: The default catkin installation location would be ~/ros_catkin_ws/install_isolated, if you would like to install some where else then you can do this by adding the --install-space /opt/ros/groovy argument to your catkin_make_isolated call.

For usage on a robot without Ubuntu, it is recommended to install compiled code into /opt/ros/groovy just as the Ubuntu packages would do. Don't do this in Ubuntu, as the packages would collide with apt-get packages. It is also possible to install elsewhere (e.g. /usr), but it is not recommended unless you really know what you are doing.

Please see REP 122: Filesystem Hierarchy Layout for more detailed documentation on how the installed files are placed.

Note: In the above command we are running the catkin_make_isolated command from the catkin source folder because it has not been installed yet, once installed it can be called directly.

Now the packages should have been installed to ~/ros_catkin_ws/install_isolated or to wherever you specified with the --install-space argument. If you look in that directory you will see that a setup.bash file have been generated. To utilize the things installed there simply source that file. Lets do that now before building the rest of ROS:

Build the rosbuild Packages

Now that you have the catkin ROS packages built and sourced, you can build any of the packages and stacks using the rosbuild build system.

Create a rosbuild workspace

Note: You do not need to do this part of the installation for the ROS-Comm: (Bare Bones) variant as it does not contain any rosbuild packages in it.

Like with building catkin packages, it is convenient to build rosbuild packages in a workspace. Lets create a ROS workspace using rosws:

Note that we are pointing the ROS workspace to the catkin install location that we built in the previous step. This allows the ROS workspace to always source the catkin install location environment before you use the ROS workspace.

Download ROS Stacks

Now we need to get the dry (rosbuild) components of the variant you chose before. Use the corresponding command for your variant to do this:

Desktop-Full Install: 2d/3d simulators, navigation, robot models and several tutorial stacks

Desktop Install (recommended): ROS, rqt, rviz, and robot-generic libraries

Now this just sets up your rosbuild workspace, you need to tell rosws to fetch the packages still:

The rosbuild workspace is now ready for dependency resolution and compiling, so source the setup.bash to make the stacks visible to your ROS environment:

Resolving ROS Stack Dependencies

Like the catkin packages, rosbuild packages may have system package dependencies. Again we use wstool to download and install these dependencies:

Build the ROS Stacks

The final step in the process is to compile the ROS stacks. Optionally, you may specify the -i flag, which will cause rosmake to place a ROS_NOBUILD file in the stack/package folders, causing it to not attempt to recompile the stack/package during future rosmake calls.

Troubleshooting

This section will grow and shrink as new issues arise and fixes are pushed into packages.

Wet Packages

warehouse_ros fails to download

When running the 'wstool init' command to fetch the core packages, you may get an error similar to the following. (Note: the '...' is not part of error. There will most likely be other output from wstool instead of the '...'.) 

ERROR [vcstools] Tarball download unpack failed: u"warehouse_ros-release-release-warehouse_ros-0.7.12 is not a subdirectory with contents in members [u'warehouse-release-release-warehouse_ros-0.7.12']"[/vcstools]

...

Exception caught during install: Error processing 'warehouse_ros' : [warehouse_ros] Checkout of https://github.com/ros-gbp/warehouse-release/archive/release/warehouse_ros/0.7.12.tar.gz version warehouse_ros-release-release-warehouse_ros-0.7.12 into /home/user/ros_catkin_ws/src/warehouse_ros failed.

ERROR in config: Error processing 'warehouse_ros' : [warehouse_ros] Checkout of https://github.com/ros-gbp/warehouse-release/archive/release/warehouse_ros/0.7.12.tar.gz version warehouse_ros-release-release-warehouse_ros-0.7.12 into /home/user/ros_catkin_ws/src/warehouse_ros failed.

The source of this error is currently unkown, but there is known a workaround. Somehow, the .rosinstall file generated contains the wrong version name of warehouse_ros. First cd into the your src directory. 

cd src

Next, with your favorite editor, open the .rosinstall file and find the following line: 

- tar: {local-name: warehouse_ros, uri: 'https://github.com/ros-gbp/warehouse-release/archive/release/warehouse_ros/X.X.X.tar.gz',
    version: warehouse_ros-release-release-warehouse_ros-X.X.X}

The X.X.X is the version number and may not be the same for each user. Now, replace that line with: 

- tar: {local-name: warehouse_ros, uri: 'https://github.com/ros-gbp/warehouse-release/archive/release/warehouse_ros/X.X.X.tar.gz',
    version: warehouse-release-release-warehouse_ros-X.X.X}

Make sure the version number (the X.X.X) remains the same as before. Finally, run the following commands. This command must be run in your src directory. 

wstool update
cd ..

You may now continue the installation.

depth_image_proc fails to build (1 of 2)

This issue could be a problem with PCL or Catkin or something else entirely. Fedora places the VTK libraries in a subdirectory of the system library directory, and this subdirectory is not searched by Catkin when other packages compile against PCL. The problem presents itself as follows: 

Project 'depth_image_proc' tried to find library 'vtkCommon'.  The library
  is neither a target nor built/installed properly.  Did you compile project
  'pcl_ros'? Did you find_package() it before the subdirectory containing its
  code is included?

The easiest way to work around this is to update the PCLConfig.cmake file to use absolute paths to the libraries, so there is no question as to their location and Catkin doesn't search for them. The file that generates PCLConfig.cmake is located at src/pcl/PCLConfig.cmake.in. Change this line: 

    set(VTK_LIBRARIES vtkCommon vtkRendering vtkHybrid)

to the following: 

    set(VTK_LIBRARIES ${VTK_LIBRARY_DIRS}/libvtkCommon.so ${VTK_LIBRARY_DIRS}/libvtkRendering.so ${VTK_LIBRARY_DIRS}/libvtkHybrid.so)

You will then need to re-compile pcl and pcl_ros. To force Catkin to do so, remove their build directories: 

$ rm build_isolated/pcl build_isolated/pcl_ros -rf

There is an issue open on GitHub for this problem: https://github.com/ros-gbp/pcl-release/issues/2

depth_image_proc fails to build (2 of 2)

Another long running issue is the result of a problem between PCL and Eigen3, which presents itself similar to the following: 

/usr/bin/ld: _ZZN5Eigen8internal20manage_caching_sizesENS_6ActionEPlS2_E13m_l1CacheSize: TLS definition in ros_catkin_ws/install_isolated/lib/libpcl_sample_consensus.so section .tbss mismatches non-TLS definition in ros_catkin_ws/install_isolated/lib/libopencv_contrib.so section .bss
install_isolated/lib/libpcl_sample_consensus.so: could not read symbols: Bad value

The only known workaround is to fall back to an earlier version of eigen3-devel and re-compile PCL. Perform these commands to downgrade eigen3-devel to a Fedora 17 version and force re-compilation of PCL: 

$ sudo yum remove eigen3-devel
$ sudo yum install http://dl.fedoraproject.org/pub/fedora/linux/releases/17/Everything/x86_64/os/Packages/e/eigen3-devel-3.0.4-2.fc17.noarch.rpm
$ rm build_isolated/pcl -rf

Dry Packages

stage fails to build

For whatever reason, FLTK is not included in stage's CMakeLists.txt and throws a linking error on Fedora: 

/usr/bin/ld: CMakeFiles/bin/stageros.dir/src/stageros.cpp.o: undefined reference to symbol '_ZN2Fl4waitEd'
/usr/bin/ld: note: '_ZN2Fl4waitEd' is defined in DSO /lib64/libfltk.so.1.3 so try adding it to the linker command line
/lib64/libfltk.so.1.3: could not read symbols: Invalid operation
collect2: error: ld returned 1 exit status
make[4]: *** [../bin/stageros] Error 1

To fix this issue, see the open ticket and apply the patch found there: https://code.ros.org/trac/ros-pkg/ticket/5507

gmapping fails to build

In RedHat distributions, patch will not apply a diff that contains ".." in a path, where Ubuntu seems to allow this. When compiling gmapping, this will cause an error like this: 

cd build/gmapping_export && patch -p0 < ../../gmapping-r39.patch && patch -p0 < ../../gmapping-r39-2.patch && ./configure
  patch: **** rejecting target file name with ".." component: ../../gmapping_export/build_tools/Makefile.generic-shared-object
  make[1]: *** [installed] Error 2

There is an issue open that contains a patch to fix this: https://code.ros.org/trac/ros-pkg/ticket/5602

Installing on Fedora 16 and 17

For users still running Fedora 16 or 17 it is highly recommended to upgrade to Fedora 18, as support for ROS in Fedora will be primarily focused towards Fedora 18. But, if you wish to continue the installation for Fedora 16 or 17, the following seems to have worked on at least one Fedora 16 and one Fedora 17 system:

2024-12-28 14:57