DeploymentComponent.hpp

Go to the documentation of this file.

/***************************************************************************
  tag: Peter Soetens  Thu Jul 3 15:34:31 CEST 2008  DeploymentComponent.hpp

                        DeploymentComponent.hpp -  description
                           -------------------
    begin                : Thu July 03 2008
    copyright            : (C) 2008 Peter Soetens
    email                : peter.soetens@fmtc.be

 ***************************************************************************
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/


#ifndef OCL_DEPLOYMENTCOMPONENT_HPP
#define OCL_DEPLOYMENTCOMPONENT_HPP

#include <rtt/RTT.hpp>
#include <rtt/TaskContext.hpp>
#include <rtt/extras/Properties.hpp>
#include <rtt/Attribute.hpp>
#include <rtt/InputPort.hpp>
#include <rtt/OutputPort.hpp>
#include <ocl/OCL.hpp>
#include <vector>
#include <map>
#include <rtt/marsh/PropertyDemarshaller.hpp>

// Suppress warnings in ocl/Component.hpp
#ifndef OCL_STATIC
#define OCL_STATIC
#include <ocl/Component.hpp>
#undef OCL_STATIC
#else
#include <ocl/Component.hpp>
#endif

namespace OCL
{

    class OCL_API DeploymentComponent
        : public RTT::TaskContext
    {
    protected:
        RTT::PropertyBag root;
        std::string compPath;
        int defaultWaitPeriodPolicy;
        RTT::Property<bool> autoUnload;
        RTT::Attribute<bool> validConfig;
        RTT::Constant<int> sched_RT;
        RTT::Constant<int> sched_OTHER;
        RTT::Constant<int> lowest_Priority;
        RTT::Constant<int> highest_Priority;
        RTT::Attribute<std::string> target;
        int nextGroup;

        struct ComponentData {
            ComponentData()
                : instance(0), act(0), loaded(false), loadedProperties(false),
                  autostart(false), autoconf(false),
                  autoconnect(false),  autosave(false),
                  proxy(false), server(false),
                  use_naming(true),
                  configfile(""),
                  group(0)
            {}
            RTT::TaskContext* instance;
            base::ActivityInterface* act;
            bool loaded;
            bool loadedProperties;
            bool autostart, autoconf, autoconnect, autosave;
            bool proxy, server, use_naming;
            std::string configfile;
            std::vector<std::string> plugins;
            int group;
        };

        struct ConnectionData {
            typedef std::vector<RTT::base::PortInterface*> Ports;
            typedef std::vector<RTT::TaskContext*>   Owners;
            Ports ports;
            Owners owners;
            RTT::ConnPolicy policy;
        };

        typedef std::map<std::string, ConnectionData> ConMap;
        ConMap conmap;

        typedef std::map<std::string, ComponentData> CompMap;
        typedef std::list<std::string> CompList;
        CompMap compmap;
        CompList comps;

        bool configureHook();

        bool unloadComponentImpl( CompMap::iterator cit );


        virtual bool componentLoaded(RTT::TaskContext* c);

        virtual void componentUnloaded(RTT::TaskContext* c);

        Service::shared_ptr stringToService(std::string const& names);
        ServiceRequester::shared_ptr stringToServiceRequester(std::string const& names);
        base::PortInterface* stringToPort(std::string const& names);

    public:
        DeploymentComponent(std::string name = "Deployer", std::string siteFile = "");

        ~DeploymentComponent();

        RTT::TaskContext* myGetPeer(std::string name) {return compmap[ name ].instance; }

        bool connectPeers(const std::string& one, const std::string& other);

        bool createConnectionMapFromPortsTag(RTT::Property<RTT::PropertyBag>& comp,
                                             RTT::TaskContext* c,
                                             const bool ignoreNonexistentPorts);

        bool createDataPortConnections(const bool skipUnconnected);

        using TaskContext::connectPorts;
        bool connectPorts(const std::string& one, const std::string& other);

        bool connectPorts(const std::string& one, const std::string& one_port,
                          const std::string& other, const std::string& other_port);

        bool connect(const std::string& one, const std::string& other, ConnPolicy policy);

        bool stream(const std::string& port, ConnPolicy policy);

        bool createStream(const std::string& component, const std::string& port, ConnPolicy policy);

        using TaskContext::connectServices;
        bool connectServices(const std::string& one, const std::string& other);

        bool connectOperations(const std::string& required, const std::string& provided);

        bool addPeer(const std::string& from, const std::string& target);

        bool aliasPeer(const std::string& from, const std::string& target, const std::string& alias);

        using RTT::TaskContext::addPeer;
        using RTT::TaskContext::connectPeers;

        bool import(const std::string& package);

        void path(const std::string& path);

        bool loadLibrary(const std::string& name);

        bool reloadLibrary(const std::string& filepath);

        bool loadComponent(const std::string& name, const std::string& type);

        bool loadService(const std::string& component, const std::string& service);

        bool unloadComponent(const std::string& name);

        void displayComponentTypes() const;

        std::vector<std::string> getComponentTypes() const;

        bool setPeriodicActivity(const std::string& comp_name,
                                 double period, int priority,
                                 int scheduler);

        bool setActivity(const std::string& comp_name,
                         double period, int priority,
                         int scheduler);

        bool setFileDescriptorActivity(const std::string& comp_name,
                         double timeout, int priority,
                         int scheduler);
                                                 
        bool setActivityOnCPU(const std::string& comp_name,
                         double period, int priority,
                              int scheduler, unsigned int cpu_nr);

        bool setSequentialActivity(const std::string& comp_name);

        bool setSlaveActivity(const std::string& comp_name,
                              double period);

        bool setMasterSlaveActivity(const std::string& comp_name,
                                    const std::string& master_name);

        bool setNamedActivity(const std::string& comp_name,
                         const std::string& act_type,
                         double period, int priority,
                         int scheduler, const std::string& master_name = "");

        bool setNamedActivity(const std::string& comp_name,
                         const std::string& act_type,
                         double period, int priority,
                         int scheduler, unsigned cpu_affinity,
                         const std::string& master_name = "");

        bool setWaitPeriodPolicy(const std::string& comp_name,
                         int policy);

        bool loadComponents(const std::string& config_file);
        bool loadComponentsInGroup(const std::string& config_file,
                                   const int group);

        bool configureComponents();

        bool configureComponentsGroup(const int group);

        bool startComponents();
        bool startComponentsGroup(const int group);

        void clearConfiguration();

        bool stopComponents();
        bool stopComponentsGroup(const int group);

        bool cleanupComponents();
        bool cleanupComponentsGroup(const int group);        

        bool unloadComponents();
        bool unloadComponentsGroup(const int group);

        bool kickStart(const std::string& file_name);

        bool kickStart2(const std::string& configurationfile,
                        const bool         doStart,
                        bool&              loadOk,
                        bool&              configureOk,
                        bool&              startOk);

        bool kickOutComponent(const std::string& comp_name);

        void kickOut(const std::string& config_file);

        bool kickOutAll();
        bool kickOutGroup(const int group);

        bool runScript(const std::string& file_name);

        using base::TaskCore::configure;

        bool configure(const std::string& name);

        bool configureFromFile(const std::string& name, const std::string& filename);

        bool loadConfiguration(const std::string& config_file);

        bool loadConfigurationString(const std::string& config_text);

        const RTT::FactoryMap& getFactories() const;

        bool configureComponent(RTT::TaskContext *instance);

        bool configureComponent(const std::string& comp_name)
        {
            return this->configureComponent(  this->getPeer(comp_name) );
        }

        bool startComponent(RTT::TaskContext *instance);

        bool startComponent(const std::string& comp_name)
        {
            return this->startComponent(  this->getPeer(comp_name) );
        }

        bool stopComponent(RTT::TaskContext *instance);

        bool stopComponent(const std::string& comp_name)
        {
            return this->stopComponent(  this->getPeer(comp_name) );
        }

        bool cleanupComponent(RTT::TaskContext *instance);

        bool cleanupComponent(const std::string& comp_name)
        {
            return this->cleanupComponent( this->getPeer(comp_name) );
        }

        void shutdownDeployment();

        bool waitForSignals(int *sigs, std::size_t sig_count);

        bool waitForSignal(int signumber);

        bool waitForInterrupt();

    };


}
#endif