core.py

Go to the documentation of this file.

# Software License Agreement (BSD License)
#
# Copyright (c) 2010, Willow Garage, Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions in binary form must reproduce the above
#    copyright notice, this list of conditions and the following
#    disclaimer in the documentation and/or other materials provided
#    with the distribution.
#  * Neither the name of Willow Garage, Inc. nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# Revision $Id: core.py 16578 2012-03-26 17:58:13Z kwc $

import os
import sys
import yaml

import rospkg
from rospkg.distro import DistroStack

def load_distro_index(filename):
    """
    Load the distro index file, which is necessary for stacks that are installed in
    binary form instead of with the extra rosinstall meta fields
    """
    with open(filename, 'r') as f:
        return yaml.load(f)
    
def repo_stacks(repo, checkout_dir):
    if repo.is_released_stack:
        # distro/debian install logic: repo is a released stack, no
        # need to crawl
        return [repo.name]
    else:
        # rosinstall logic
        repo_dir = os.path.join(checkout_dir, repo.local_path)
        if not os.path.exists(repo_dir):
            sys.stderr.write("checkout [%s] doesn't exist\n"%(repo_dir))
            return []
        
        stacks = rospkg.list_by_path('stack.xml', repo_dir, {})
        if repo.name == 'ros':
            stacks.append('ros')
        return stacks

def repo_packages(repo, checkout_dir):
    rosstack = rospkg.RosStack()
    if repo.is_released_stack:
        # distro/debian install logic: repo is a released stack, no
        # need to crawl
        try:
            packages = rosstack.packages_of(repo.name)
        except:
            packages = []
    else:
        # rosinstall logic
        repo_dir = os.path.join(checkout_dir, repo.local_path)
        packages = rospkg.list_by_path('manifest.xml', repo_dir, {})
    return packages

def load_repos_distro(distro_index_filename):
    """
    Load repository index for stacks that were installed via the
    distribution/debian.  We have to fake repository data for these as
    we are not actually retrieving from the repository itself.
    """
    repos = []

    # for released stacks, we use the metarepos logic to represent the
    # stack as its own repository as well as part of an aggregate
    # repository.
    distro_index = load_distro_index(distro_index_filename)
    distro_name = distro_index['distro_name']
    for stack_name in distro_index['stacks']:
        stack_data= distro_index['stacks'][stack_name]

        # should not be used (hopefully)
        if stack_name == 'ros':
            local_path = '/opt/ros/%s/ros'%(distro_name)
        else:
            local_path = '/opt/ros/%s/stacks/%s'%(distro_name, stack_name)            

        distro_stack = DistroStack(stack_name, stack_data['version'],
                                   distro_name, stack_data['rules'])
        
        # use the release branch as that is what we are documenting
        # TODO: broken for bzr
        rosinstalls = {}
        vcs_config = distro_stack.vcs_config
        for branch_name in ['release', 'devel', 'distro']:
            rosinstalls[branch_name] = vcs_config.to_rosinstall(stack_name, branch_name, anonymous=True)[0]
        rosinstall = rosinstalls['release'] # default rosinstall

        # for each debian-based stack, give it its own repo, plus an aggregate
        vcs_type = rosinstall.keys()[0]
        vcs_uri = rosinstall[vcs_type]['uri']

        print "loaded released stack repo: %s %s %s"%(stack_name, vcs_type, vcs_uri)
        print "released stack repo rosinstall: %s \n%s"%(stack_name, rosinstall)
        
        r = Repo(stack_name, vcs_type, vcs_uri, rosinstall, local_path)
        r.aggregate_name = stack_data['repo']
        r.is_released_stack = True
        r.rosinstalls = rosinstalls.copy()
        
        repos.append((stack_name, r))
    return repos
    
def load_repos(repos_filename, distro_index_filename):
    repos = load_repos_rosinstall(repos_filename)
    if distro_index_filename is not None:
        repos.extend(load_repos_distro(distro_index_filename))
    return repos

def load_repos_rosinstall(filename):
    """
    Load repository file, which is a rosinstall file with particular semantics
    
    @return: ordered list of repositories
    @rtype: [(str, Repo)]
    """
    with open(filename) as f:
        data = yaml.load(f.read())
    # rosinstall file is a list of dictionaries
    repos = []
    # have to reverse the repo order to match rosinstall precedence
    for d in reversed(data):
        type_ = d.keys()[0]
        if type_ == 'other':
            continue
        config = d[type_]
        # filter 'other' like elements that don't bear VCS info
        if not 'uri' in config:
            continue
        
        local_name = local_path = config['local-name']
        r = Repo(local_name, type_, config['uri'], d, local_path)
        if 'meta' in config and 'repo-name' in config['meta']:
            r.aggregate_name = config['meta']['repo-name']
        repos.append((local_name, r))
    return repos
    
class Repo(object):
    
    def __init__(self, name, type_, uri, rosinstall, local_path):
        """
        @param name: repository name
        @param type_: repository VCS type
        @param uri: repository VCS uri
        @param rosinstall: default rosinstall dictionary configuration data
        @param local_path: checkout-relative path for repository
        @param aggregate_name: (optional) aggregate name if we are
            grouping several repositories under a single name.
            Defaults to name.
        """
        self.name = name
        self.type = type_
        self.uri = uri
        # rosinstall data
        self.rosinstall = rosinstall
        self.local_path = local_path

        # aggregate is used to alias per-stack repositories to a
        # single name, e.g. ccny-ros-pkg
        self.aggregate_name = None
        self.is_released_stack = False
        
        # dictionary of different rosinstall configurations of repo,
        # uses same keys as VcsConfig.to_rosinstall,
        # e.g. {'devel': rosinstall_dict, 'release': rosinstall_dict}
        self.rosinstalls = None
        
_api_url = "http://ros.org/doc/api/"
def package_link(package):
    return _api_url + package + "/html/"
def stack_link(stack):
    return _api_url + stack + "/html/"

def safe_encode(d):
    d_copy = d.copy()
    for k, v in d_copy.iteritems():
        if isinstance(v, basestring):
            try:
                d[k] = v.encode("utf-8")
            except UnicodeDecodeError, e:
                print >> sys.stderr, "error: cannot encode value for key", k
                d[k] = ''
        elif type(v) == list:
            try:
                d[k] = [x.encode("utf-8") for x in v]
            except UnicodeDecodeError, e:
                print >> sys.stderr, "error: cannot encode value for key", k
                d[k] = []
    return d

---

rosdoc_rosorg
Author(s): Ken Conley
autogenerated on Fri Jan 11 09:12:19 2013