RemoteObjectNode.h

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    ArmarXCore
 * @author     Raphael Grimm ( raphael dot grimm at kit dot edu )
 * @date       2015
 * @copyright  http://www.gnu.org/licenses/gpl.txt
 *             GNU General Public License
 */
#pragma once
 
#include <assert.h> // for assert
 
#include <atomic> // for atomic, atomic_bool
#include <cstddef> // for size_t
#include <limits> // for numeric_limits
#include <mutex> // for mutex
#include <string> // for string
#include <unordered_map> // for unordered_map
#include <vector> // for vector
 
#include <Ice/BuiltinSequences.h> // for StringSeq
#include <Ice/Config.h> // for Long
#include <Ice/Current.h> // for Current
#include <Ice/Handle.h> // for Handle
#include <Ice/Identity.h> // for Identity, IdentitySeq
#include <Ice/ObjectF.h> // for ObjectPtr, upCast
#include <Ice/PropertiesF.h> // for upCast
#include <Ice/ProxyF.h> // for ObjectPrx
 
#include "ArmarXCore/core/ManagedIceObject.h" // for ManagedIceObjectPtr
#include "ArmarXCore/core/application/properties/Property.h"
#include "ArmarXCore/core/application/properties/PropertyDefinition.hpp"
#include "ArmarXCore/core/application/properties/PropertyUser.h"
#include "ArmarXCore/interface/core/util/distributed/RemoteHandle/ClientSideRemoteHandleControlBlock.h"
#include <ArmarXCore/core/Component.h>
#include <ArmarXCore/core/util/distributed/RemoteHandle/RemoteHandle.h>
#include <ArmarXCore/core/util/distributed/RemoteHandle/RemoteHandleControlBlock.h>
#include <ArmarXCore/interface/core/RemoteObjectNode.h> // for upCast, etc
 
namespace armarx
{
    class RemoteObjectNode;
 
    /**
     * @brief An ice handle for a RemoteObjectNodeComponent
     */
    using RemoteObjectNodePtr = IceInternal::Handle<RemoteObjectNode>;
 
    /**
    * @brief Properties for a RemoteObjectNodeComponent
    */
    class RemoteObjectNodePropertyDefinitions : public armarx::ComponentPropertyDefinitions
    {
    public:
        /**
        * @brief ctor
        * @param prefix the used prefix for properties
        */
        RemoteObjectNodePropertyDefinitions(std::string prefix) :
            armarx::ComponentPropertyDefinitions(prefix)
        {
            defineOptionalProperty<int>(
                "CoreCount", 0, "The used count of cores (<=0 => autodetect)");
        }
    };
 
    /**
     * @defgroup Component-RemoteObjectNode RemoteObjectNode
     * @ingroup ArmarXCore-Components
     * @brief Implementation of the slice interface RemoteObjectNodeInterface.
     *
     */
    class RemoteObjectNode :
        virtual public RemoteObjectNodeInterface,
        virtual public armarx::Component
    {
    public:
        static unsigned getDefaultCoreCount();
 
        /**
        * @brief ctor
        */
        RemoteObjectNode() = default;
 
        /**
         * @brief dtor
         */
        ~RemoteObjectNode() override
        {
            assert(shuttingDown);
        }
 
        // inherited from Component
        /**
         * @brief Returns the object node's default name.
         * @return The object node's default name.
         */
        std::string
        getDefaultName() const override
        {
            return "RemoteObjectNode";
        }
 
        /**
         * @brief reads in properties
         */
        void
        onInitComponent() override
        {
            setCoreCount(getProperty<int>("CoreCount").getValue());
        }
 
        void
        onConnectComponent() override
        {
        }
 
        //virtual void onDisconnectComponent() override;
        /**
         * @brief Removes all remote objects
         */
        void onExitComponent() override;
 
        /**
         * @see PropertyUser::createPropertyDefinitions()
         */
        armarx::PropertyDefinitionsPtr
        createPropertyDefinitions() override
        {
            return new RemoteObjectNodePropertyDefinitions(getConfigIdentifier());
        }
 
        //from RemoteObjectNodeInterface
        Ice::ObjectPrx createPersistentComponent(const std::string& componentFactoryName,
                                                 const std::string& registrationName,
                                                 const ComponentParameter& params,
                                                 const Ice::Current& = Ice::emptyCurrent) override;
        ClientSideRemoteHandleControlBlockBasePtr
        createRemoteHandledComponent(const std::string& componentFactoryName,
                                     const std::string& registrationName,
                                     const ComponentParameter& params,
                                     const Ice::Current& = Ice::emptyCurrent) override;
 
        Ice::ObjectPrx
        registerPersistentObjectWithIdentity(const Ice::Identity& ident,
                                             const Ice::ObjectPtr& registree,
                                             const Ice::Current& = Ice::emptyCurrent) override;
        ClientSideRemoteHandleControlBlockBasePtr
        registerRemoteHandledObjectWithIdentity(const Ice::Identity& ident,
                                                const Ice::ObjectPtr& registree,
                                                const Ice::Current& = Ice::emptyCurrent) override;
 
        Ice::ObjectPrx registerPersistentObject(const std::string& registrationName,
                                                const Ice::ObjectPtr& registree,
                                                const Ice::Current& = Ice::emptyCurrent) override;
        ClientSideRemoteHandleControlBlockBasePtr
        registerRemoteHandledObject(const std::string& registrationName,
                                    const Ice::ObjectPtr& registree,
                                    const Ice::Current& = Ice::emptyCurrent) override;
 
        /**
         * @brief Returns the number of cores to use.
         * @return The number of cores to use.
         */
        Ice::Long
        getNumberOfCores(const Ice::Current& = Ice::emptyCurrent) const override
        {
            return coreCountUsed;
        }
 
        Ice::Long getNumberOfObjects(const Ice::Current& = Ice::emptyCurrent) const override;
        Ice::Long
        getNumberOfPersistentObjects(const Ice::Current& = Ice::emptyCurrent) const override;
        Ice::Long
        getNumberOfRemoteHandledObjects(const Ice::Current& = Ice::emptyCurrent) const override;
        Ice::StringSeq
        getKnownComponentFactories(const Ice::Current& = Ice::emptyCurrent) const override;
 
        virtual void setCoreCount(int newCount);
 
    protected:
        //setup the object to be available per proxy
        struct ManagedIceObjectPtrAndPrx
        {
            ManagedIceObjectPtr ptr;
            Ice::ObjectPrx prx;
        };
 
        ManagedIceObjectPtrAndPrx setupManagedIceObject(ManagedIceObjectPtr mioPtr,
                                                        std::string registrationName);
        ManagedIceObjectPtrAndPrx setupComponent(const std::string& componentFactoryName,
                                                 const std::string& registrationName,
                                                 const ComponentParameter& params);
 
        struct IceObjectIdentityAndPrx
        {
            Ice::Identity ident;
            Ice::ObjectPrx prx;
        };
 
        IceObjectIdentityAndPrx setupIceObject(const Ice::ObjectPtr& ptr, Ice::Identity ident);
 
        //helper add data to the RON
        ClientSideRemoteHandleControlBlockBasePtr
        doRegisterRemoteHandledManagedIceObjectAtRON(ManagedIceObjectPtrAndPrx mio);
        ClientSideRemoteHandleControlBlockBasePtr
        doRegisterRemoteHandledIceObjectAtRON(IceObjectIdentityAndPrx io);
        Ice::ObjectPrx doRegisterPersistentManagedIceObjectAtRON(ManagedIceObjectPtrAndPrx mio);
        Ice::ObjectPrx doRegisterPersistentIceObjectAtRON(IceObjectIdentityAndPrx io);
 
        //cleanup
        void removeRemoteHandledObject(Ice::Long id);
        void shutdownAndCleanup();
 
        //data
        std::atomic<Ice::Long> nextRemoteHandledObjectId{std::numeric_limits<Ice::Long>::min()};
        std::atomic_bool shuttingDown{false};
 
        /**
         * @brief the map of running objects
         */
        std::unordered_map<Ice::Long, RemoteHandleControlBlockPtr> remoteHandledObjects;
        /**
         * @brief The persistent managed ice objects
         */
        std::vector<ManagedIceObjectPtr> persistentManagedIceObjects;
        /**
         * @brief The identities of persistent ice objects
         */
        Ice::IdentitySeq persistentIceObjectIdentities;
 
        /**
         * @brief mutex to protect the map
         */
        mutable std::mutex dataMutex;
 
        /**
         * @brief The nuber of cores returned, when querried for it.
         */
        std::size_t coreCountUsed;
    };
} // namespace armarx