IceManager.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::core
 * @author     Nils Adermann (naderman at naderman dot de)
 * @author     Jan Issac (jan dot issac at gmx dot de)
 * @date       2010
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#pragma once
 
#include <ArmarXCore/core/logging/Logging.h>          // for Logging
#include <ArmarXCore/core/system/ImportExport.h>      // for ARMARXCORE_IMPORT_EXPORT
#include <ArmarXCore/util/CPPUtility/GetTypeString.h>
 
#include <Ice/Object.h>                 // for ObjectPtr
#include <Ice/Proxy.h>                  // for ObjectPrx
 
#include <IceUtil/Handle.h>             // for Handle, HandleBase
#include <IceUtil/Shared.h>             // for Shared
 
#include <stdexcept>                    // for out_of_range
#include <string>                       // for string, allocator, etc
#include <typeinfo>                     // for type_info
#include <utility>                      // for pair
#include <vector>                       // for vector
 
namespace Ice
{
    class ConnectionRefusedException;
 
    class Communicator;
    typedef ::IceInternal::Handle< ::Ice::Communicator> CommunicatorPtr;
 
    class ObjectAdapter;
    typedef ::IceInternal::Handle< ::Ice::ObjectAdapter> ObjectAdapterPtr;
 
}
 
namespace IceProxy::IceGrid
{
    class Registry;
}
namespace IceProxy::IceStorm
{
    class TopicManager;
    class Topic;
}
 
namespace IceStorm
{
    using TopicManagerPrx = ::IceInternal::ProxyHandle< ::IceProxy::IceStorm::TopicManager>;
    using TopicPrx = ::IceInternal::ProxyHandle< ::IceProxy::IceStorm::Topic>;
}
 
namespace IceGrid
{
    using RegistryPrx = ::IceInternal::ProxyHandle< ::IceProxy::IceGrid::Registry>;
}
 
namespace armarx
{
    class IceGridAdmin;
    using IceGridAdminPtr = IceUtil::Handle<IceGridAdmin>;
 
    class IceManager;
 
    using IceManagerPtr = IceUtil::Handle<IceManager>;
 
    using ObjectHandles = std::pair<Ice::ObjectPrx, Ice::ObjectAdapterPtr>;
 
 
    class ARMARXCORE_IMPORT_EXPORT IceManager:
        public IceUtil::Shared,
        virtual public Logging
    {
        friend class Component;
 
    public:
        IceManager(const Ice::CommunicatorPtr& communicator,
                   std::string name = "", const std::string topicSuffix = "");
 
        ~IceManager() override;
 
        ObjectHandles registerObject(const Ice::ObjectPtr& object,
                                     const std::string& objectName, const Ice::ObjectAdapterPtr& adapterToAddTo = nullptr);
 
        void removeObject(const std::string& objectName);
 
        template <class ProxyType>
        ProxyType getProxy(const std::string& name,
                           const std::string& endpoints = std::string())
        {
            std::string proxyString = name;
 
            if (!endpoints.empty())
            {
                proxyString += std::string(":") + endpoints;
            }
 
            std::string proxyTypedId =
                proxyString
                + std::string(":")
                + std::string(typeid(ProxyType).name());
 
            try
            {
                return ProxyType::uncheckedCast(implGetCheckedProxy(proxyTypedId));
            }
            catch (std::out_of_range& uncheckedProxiesException)
            {
            }
 
            Ice::ObjectPrx base = communicator_stringToProxy(proxyString);
 
            ProxyType proxy;
 
            try
            {
                proxy = ProxyType::checkedCast(base);
                implSetCheckedProxy(proxyTypedId, proxy);
            }
            catch (const Ice::ConnectionRefusedException&)
            {
                std::stringstream exceptionText;
                exceptionText << "Connection refused for proxy of type '" << GetTypeString<ProxyType>()
                              << "': " << name << " ProxyString: " << proxyString << " Endpoints: " << endpoints << std::endl;
                throwUserException(exceptionText.str());
            }
 
            if (!proxy)
            {
                std::stringstream exceptionText;
                exceptionText << "Invalid Proxy. Searched for: " << name << " ProxyString: " << proxyString << " Endpoints: " << endpoints << std::endl;
                throwUserException(exceptionText.str());
            }
 
            return proxy;
        }
 
        void throwUserException(std::string const& message);
 
        template <class ProxyType>
        bool removeProxyFromCache(const std::string& name,
                                  const std::string& endpoints = std::string())
        {
            return removeProxyFromCache(name, typeid(ProxyType).name(), endpoints);
        }
 
        bool removeProxyFromCache(const std::string& name,
                                  const std::string& typeName,
                                  const std::string& endpoints = std::string());
 
        bool removeProxyFromCache(const Ice::ObjectPrx& proxy);
 
        IceStorm::TopicManagerPrx getTopicManager();
        static IceStorm::TopicManagerPrx GetTopicManager(Ice::CommunicatorPtr communicator);
 
        template <class TopicProxy>
        TopicProxy getTopic(const std::string& topicName, bool useUDP = false)
        {
            Ice::ObjectPrx pub = __getTopic(topicName, useUDP);
            TopicProxy castTopic = TopicProxy::uncheckedCast(pub);
 
            return castTopic;
        }
 
        void subscribeTopic(Ice::ObjectPrx subscriber,
                            const std::string& topicName, bool orderedPublishing = false);
        void registerAndSubscribeTopic(Ice::ObjectPtr subscriber,
                                       const std::string& topicName, bool orderedPublishing = false);
 
        void unsubscribeTopic(Ice::ObjectPrx subscriberProxy,
                              const std::string& topicName);
 
        void registerObjectDependency(
            const std::string& registrantName,
            const std::string& dependencyObjectName);
 
        void registerDelayedTopicSubscription(
            const std::string& registrantName,
            const std::string& topicName);
 
        void registerDelayedTopicRetrieval(
            const std::string& registrantName,
            const std::string& topicName);
 
        bool isObjectReachable(std::string objectName);
 
        template <typename ProxyType>
        bool isObjectReachable(std::string objectName);
 
        const Ice::CommunicatorPtr& getCommunicator();
 
        IceGrid::RegistryPrx getIceGridRegistry();
 
        const armarx::IceGridAdminPtr& getIceGridSession();
 
        void setName(std::string name);
 
        void shutdown();
 
        void waitForShutdown();
 
        bool isShutdown();
 
        void destroy();
 
        std::string getTopicSuffix() const;
 
    private:
 
        Ice::ObjectPrx communicator_stringToProxy(std::string const& proxyString);
 
        Ice::ObjectPrx __getTopic(const std::string& topicName, bool useUDP = false);
 
        struct ObjectEntry;
 
        struct DependencyObjectEntry: public IceUtil::Shared
        {
            DependencyObjectEntry(std::string name, Ice::ObjectPrx proxy) :
                name(name),
                proxy(proxy),
                resolved(false)
            {
 
            }
 
            std::string name;
            Ice::ObjectPrx proxy;
            bool resolved;
        };
 
        using ObjectEntryPtr = IceUtil::Handle<ObjectEntry>;
        using DependencyObjectEntryPtr = IceUtil::Handle<DependencyObjectEntry>;
 
        using TopicList = std::vector<std::string>;
        using DependencyList = std::vector<DependencyObjectEntryPtr>;
 
        void subscribeTopics(Ice::ObjectPrx subscriber,
                             const TopicList& topics, bool orderedPublishing = false);
 
        void retrieveTopics(const TopicList& topics);
 
        void resolveObjectDependencies();
 
        ObjectEntryPtr getOrCreateObjectEntry(const std::string& objectName);
 
        void cleanUp();
 
        IceStorm::TopicPrx retrieveTopic(const std::string& topicName);
 
        IceStorm::TopicPrx stormTopicRetrieve(const std::string& topicName);
 
        Ice::ObjectPrx  implGetCheckedProxy(std::string const& proxyTypedId);
        void implSetCheckedProxy(std::string const& proxyTypedId, Ice::ObjectPrx const& proxy);
 
 
        struct Impl;
        std::unique_ptr<Impl> impl;
    };
 
 
    template <typename ProxyType>
    bool IceManager::isObjectReachable(std::string objectName)
    {
        try
        {
            ProxyType prx = getProxy<ProxyType>(objectName);
            prx->ice_timeout(500)->ice_ping();
            // if ping'able, object is already registered
            return true;
        }
        catch (...)
        {
 
            return false;
        }
    }
 
}