PortConfiguration.cpp

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of CCA project
 *
 * Copyright (C) 2011 by Arne Nordmann <anordman at cor-lab dot uni-bielefeld dot de>
 *
 * This file may be licensed under the terms of the
 * GNU Lesser General Public License Version 3 (the ``LGPL''),
 * or (at your option) any later version.
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the LGPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the LGPL along with this
 * program. If not, go to http://www.gnu.org/licenses/lgpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The development of this software was supported by:
 *   CoR-Lab, Research Institute for Cognition and Robotics
 *     Bielefeld University
 *
 * ============================================================ */

#include "PortConfiguration.h"

#include <string>
#include <sstream>
#include <iostream>

#include <boost/shared_ptr.hpp>

#include <rsc/config/Configuration.h>
#include <rsc/config/OptionHandler.h>
#include <rsc/logging/OptionBasedConfigurator.h>

#include <rsb/Factory.h>
#include <rsb/Informer.h>
#include <rsb/Listener.h>
#include <rsb/transport/transports.h>

namespace cca {

using namespace std;
using namespace rsb;
using namespace rsb::transport;
using namespace boost;
using namespace rsc;
using namespace rsc::config;

PortConfigurationPtr PortConfiguration::DEFAULT(const std::string &scope,
        unsigned int qsize, bool keepl) {
    return PortConfigurationPtr(new PortConfiguration(scope, qsize, keepl));
}

PortConfigurationPtr PortConfiguration::LOCAL(const std::string &scope,
        unsigned int qsize, bool keepl) {
    return PortConfigurationPtr(
            new PortConfiguration(scope, true, false, qsize, keepl));
}

PortConfigurationPtr PortConfiguration::REMOTE(const std::string &scope,
        unsigned int qsize, bool keepl) {
    return PortConfigurationPtr(
            new PortConfiguration(scope, false, true, qsize, keepl));
}

PortConfigurationPtr PortConfiguration::LOCALREMOTE(const std::string &scope,
        unsigned int qsize, bool keepl) {
    return PortConfigurationPtr(
            new PortConfiguration(scope, true, true, qsize, keepl));
}

PortConfigurationPtr PortConfiguration::PROFILE(const std::string &p,
        const std::string &scope, unsigned int qsize, bool keepl) {
    PortConfigurationPtr cfg(
            new PortConfiguration(scope, false, false, qsize, keepl));

    // TODO: Remove RSB lock-in
    std::string config_file = p + ".conf";
    rsc::config::configure((cfg->rsbConfigMutable()), config_file, "RSB_");

    return cfg;
}

PortConfigurationPtr PortConfiguration::create(Transport tr,
        const std::string &scope, unsigned int qsize, bool keepl) {
    switch (tr) {
    case PortConfiguration::CCALocal:
        return PortConfiguration::LOCAL(scope, qsize, keepl);
        break;
    case PortConfiguration::CCARemote:
        return PortConfiguration::REMOTE(scope, qsize, keepl);
        break;
    case PortConfiguration::CCALocalRemote:
    default:
        return PortConfiguration::LOCALREMOTE(scope, qsize, keepl);
    }
}

PortConfigurationPtr PortConfiguration::create(const std::string &profile,
        const std::string &scope, unsigned int qsize, bool keepl) {
    return PortConfiguration::PROFILE(profile, scope, qsize, keepl);
}

rsb::ScopePtr PortConfiguration::getScopePtr() const {
    return this->scope;
}

void PortConfiguration::setQueueSize(unsigned int qsize) {
    this->queuesize = qsize;
}

unsigned int PortConfiguration::getQueueSize() const {
    return this->queuesize;
}

void PortConfiguration::setKeepLatest(bool keepl) {
    this->keeplatest = keepl;
}

bool PortConfiguration::keepLatest() {
    return this->keeplatest;
}

rsb::ParticipantConfig PortConfiguration::rsbConfig() const {
    return this->rsbconfig;
}

rsb::ParticipantConfig& PortConfiguration::rsbConfigMutable() {
    return this->rsbconfig;
}

bool PortConfiguration::isLocalPort() const {
    return this->local;
}

bool PortConfiguration::isRemotePort() const {
    return this->remote;
}

PortConfiguration::PortConfiguration(const std::string &scp, unsigned int qsize,
        bool keepl) :
        local(false), remote(false), keeplatest(keepl), scope(new Scope(scp)),
                queuesize(qsize) {

    // Participant configuration
    // TODO: Remove RSB lock-in
    this->rsbconfig = rsb::getFactory().getDefaultParticipantConfig();

    set<ParticipantConfig::Transport> transports =
            this->rsbconfig.getTransports(true);

    for (set<ParticipantConfig::Transport>::const_iterator it =
            transports.begin(); it != transports.end(); ++it) {
        ParticipantConfig::Transport transport = *it;

        if (    // transport ist available
        rsb::transport::isAvailable(transport.getName(),
                DIRECTION_IN_PUSH | DIRECTION_OUT) &&
        // transport is remote
                rsb::transport::isRemote(transport.getName())) {
            this->remote = true;
        } else {
            this->local = true;
        }
    }
}

PortConfiguration::PortConfiguration(const std::string &scp, bool loc, bool rem,
        unsigned int qsize, bool keepl) :
        local(loc), remote(rem), keeplatest(keepl), scope(new Scope(scp)),
                queuesize(qsize) {

    // Participant configuration
    // TODO: Remove RSB lock-in
    this->rsbconfig = rsb::getFactory().getDefaultParticipantConfig();

    set<ParticipantConfig::Transport> transports =
            this->rsbconfig.getTransports(true);

    // Transport Configuration
    bool localSatisfied = true; // maybe later !this->local;
    bool remoteSatisfied = !this->remote;
    for (set<ParticipantConfig::Transport>::const_iterator it =
            transports.begin(); it != transports.end(); ++it) {
        ParticipantConfig::Transport transport = *it;

        // Only consider available transports
        if (rsb::transport::isAvailable(transport.getName(),
                DIRECTION_IN_PUSH | DIRECTION_OUT)) {

            // Configure local transport
            if (!rsb::transport::isRemote(transport.getName())) {
                transport.setEnabled(this->local);
            }

            // Configure remote transport
            // If the transport is enabled and we want remote transports,
            // just leave it enabled. Otherwise, disable the transport. If
            // we want remote transports, make sure, we found at least one
            // enabled remote transport.
            else {
                if (transport.isEnabled()) {
                    if (this->remote) {
                        remoteSatisfied = true;
                    } else {
                        transport.setEnabled(false);
                    }
                }
            }

            this->rsbconfig.addTransport(transport);

        }
    }
    if (!localSatisfied) {
        throw std::runtime_error("Local transport requested, but middleware "
                "doesn't provide this in its current configuration.");
    }
    if (!remoteSatisfied) {
        throw std::runtime_error("Remote transport requested, but middleware"
                " doesn't provide this in its current configuration.");
    }
}

PortConfiguration::~PortConfiguration() {
}

string PortConfiguration::print() const {
    ostringstream outstream(ostringstream::out);
    outstream.precision(3); // Precision when printing double values
    outstream << "<cfg:";

    set<rsb::ParticipantConfig::Transport> ts = this->rsbconfig.getTransports();
    for (set<rsb::ParticipantConfig::Transport>::const_iterator tsit =
            ts.begin(); tsit != ts.end(); ++tsit) {
        outstream << tsit->getName() << ",";
    }

    outstream << ">";
    return outstream.str();
}

bool operator==(PortConfigurationPtr const a, PortConfigurationPtr const b) {
    return ((a->getScopePtr() == b->getScopePtr())
            && (a->isLocalPort() == b->isLocalPort())
            && (a->isRemotePort() == b->isRemotePort()));
}

}