RemoteObjectNode.cpp

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
 */
#include "ArmarXCore/interface/core/RemoteObjectNode.h"
 
#include <algorithm> // for move, max
#include <ostream> // for operator<<, etc
#include <thread> // for thread
#include <thread>
#include <utility> // for pair
 
#include <Ice/Object.h> // for Object
#include <Ice/ObjectAdapter.h> // for ObjectAdapter
#include <Ice/PropertiesAdmin.h> // for PropertyDict
#include <IceUtil/Handle.h> // for HandleBase, Handle
 
#include "ArmarXCore/core/Component.h" // for Component
#include "ArmarXCore/core/logging/LogSender.h" // for LogSender
#include "ArmarXCore/core/logging/Logging.h" // for ARMARX_DEBUG_S, etc
#include "ArmarXCore/core/util/distributed/RemoteHandle/RemoteHandleControlBlock.h"
#include "ArmarXCore/interface/core/UserException.h"
#include "ArmarXCore/interface/core/util/distributed/RemoteHandle/RemoteHandleControlBlock.h"
#include <ArmarXCore/core/ArmarXManager.h> // for ArmarXManager
#include <ArmarXCore/core/ComponentFactories.h> // for ComponentFactory
 
#include "RemoteObjectNode.h"
 
namespace armarx
{
    /**
     * @brief The processor thread count according to std. (in libstd shipped with gcc 4.6 this is 0)
     */
    static const unsigned CORE_COUNT_STD = std::thread::hardware_concurrency();
    /**
     * @brief The minimal used processor thread count. (in case both boost and std return 0)
     */
    static const unsigned CORE_COUNT_MIN = 1;
    /**
     * @brief Used core count. (in case both boost and std return 0 we will still use 1)
     */
    static const unsigned CORE_COUNT_DEFAULT = std::max(CORE_COUNT_STD, CORE_COUNT_MIN);
 
    unsigned
    RemoteObjectNode::getDefaultCoreCount()
    {
        return CORE_COUNT_DEFAULT;
    }
 
    void
    RemoteObjectNode::setCoreCount(int newCount)
    {
        coreCountUsed = newCount < 1 ? getDefaultCoreCount() : newCount;
        ARMARX_DEBUG_S << "processor core count according to (std/requested from user) : "
                       << CORE_COUNT_STD << "/" << newCount;
        ARMARX_VERBOSE_S << "processor core count used: " << coreCountUsed;
    }
 
    void
    RemoteObjectNode::onExitComponent()
    {
        assert(!shuttingDown);
        shutdownAndCleanup();
    }
 
    Ice::Long
    RemoteObjectNode::getNumberOfObjects(const Ice::Current&) const
    {
        std::lock_guard<std::mutex> lock{dataMutex};
        return persistentIceObjectIdentities.size() + persistentManagedIceObjects.size() +
               remoteHandledObjects.size();
    }
 
    Ice::Long
    RemoteObjectNode::getNumberOfPersistentObjects(const Ice::Current&) const
    {
        std::lock_guard<std::mutex> lock{dataMutex};
        return persistentIceObjectIdentities.size() + persistentManagedIceObjects.size();
    }
 
    Ice::Long
    RemoteObjectNode::getNumberOfRemoteHandledObjects(const Ice::Current&) const
    {
        std::lock_guard<std::mutex> lock{dataMutex};
        return remoteHandledObjects.size();
    }
 
    Ice::StringSeq
    RemoteObjectNode::getKnownComponentFactories(const Ice::Current&) const
    {
        return ComponentFactory::getKeys();
    }
 
    Ice::ObjectPrx
    RemoteObjectNode::createPersistentComponent(const std::string& componentFactoryName,
                                                const std::string& registrationName,
                                                const ComponentParameter& params,
                                                const Ice::Current&)
    {
        if (shuttingDown)
        {
            throw ServerShuttingDown{};
        }
        return doRegisterPersistentManagedIceObjectAtRON(
            setupComponent(componentFactoryName, registrationName, params));
    }
 
    ClientSideRemoteHandleControlBlockBasePtr
    RemoteObjectNode::createRemoteHandledComponent(const std::string& componentFactoryName,
                                                   const std::string& registrationName,
                                                   const ComponentParameter& params,
                                                   const Ice::Current&)
    {
        if (shuttingDown)
        {
            throw ServerShuttingDown{};
        }
        return doRegisterRemoteHandledManagedIceObjectAtRON(
            setupComponent(componentFactoryName, registrationName, params));
    }
 
    Ice::ObjectPrx
    RemoteObjectNode::registerPersistentObjectWithIdentity(const Ice::Identity& ident,
                                                           const Ice::ObjectPtr& registree,
                                                           const Ice::Current&)
    {
        if (shuttingDown)
        {
            throw ServerShuttingDown{};
        }
        auto mioPtr = ManagedIceObjectPtr::dynamicCast(registree);
 
        if (mioPtr)
        {
            return doRegisterPersistentManagedIceObjectAtRON(
                setupManagedIceObject(std::move(mioPtr), ident.category + ident.name));
        }
        return doRegisterPersistentIceObjectAtRON(setupIceObject(registree, ident));
    }
 
    ClientSideRemoteHandleControlBlockBasePtr
    RemoteObjectNode::registerRemoteHandledObjectWithIdentity(const Ice::Identity& ident,
                                                              const Ice::ObjectPtr& registree,
                                                              const Ice::Current&)
    {
        if (shuttingDown)
        {
            throw ServerShuttingDown{};
        }
        auto mioPtr = ManagedIceObjectPtr::dynamicCast(registree);
 
        if (mioPtr)
        {
            return doRegisterRemoteHandledManagedIceObjectAtRON(
                setupManagedIceObject(std::move(mioPtr), ident.category + ident.name));
        }
        return doRegisterRemoteHandledIceObjectAtRON(setupIceObject(registree, ident));
    }
 
    Ice::ObjectPrx
    RemoteObjectNode::registerPersistentObject(const std::string& registrationName,
                                               const Ice::ObjectPtr& registree,
                                               const Ice::Current&)
    {
        if (shuttingDown)
        {
            throw ServerShuttingDown{};
        }
        auto mioPtr = ManagedIceObjectPtr::dynamicCast(registree);
 
        if (mioPtr)
        {
            return doRegisterPersistentManagedIceObjectAtRON(
                setupManagedIceObject(std::move(mioPtr), registrationName));
        }
        Ice::Identity ident;
        ident.name = registrationName;
        return doRegisterPersistentIceObjectAtRON(setupIceObject(registree, std::move(ident)));
    }
 
    ClientSideRemoteHandleControlBlockBasePtr
    RemoteObjectNode::registerRemoteHandledObject(const std::string& registrationName,
                                                  const Ice::ObjectPtr& registree,
                                                  const Ice::Current&)
    {
        if (shuttingDown)
        {
            throw ServerShuttingDown{};
        }
        auto mioPtr = ManagedIceObjectPtr::dynamicCast(registree);
 
        if (mioPtr)
        {
            return doRegisterRemoteHandledManagedIceObjectAtRON(
                setupManagedIceObject(std::move(mioPtr), registrationName));
        }
        Ice::Identity ident;
        ident.name = registrationName;
        return doRegisterRemoteHandledIceObjectAtRON(setupIceObject(registree, std::move(ident)));
    }
 
    RemoteObjectNode::ManagedIceObjectPtrAndPrx
    RemoteObjectNode::setupManagedIceObject(ManagedIceObjectPtr mioPtr,
                                            std::string registrationName)
    {
        getArmarXManager()->addObject(mioPtr, true, registrationName);
        //the self proxy could still be null => wait for it
        auto mioPrx = mioPtr->getProxy(-1);
        return {std::move(mioPtr), std::move(mioPrx)};
    }
 
    RemoteObjectNode::ManagedIceObjectPtrAndPrx
    RemoteObjectNode::setupComponent(const std::string& componentFactoryName,
                                     const std::string& registrationName,
                                     const ComponentParameter& params)
    {
        if (!ComponentFactory::has(componentFactoryName))
        {
            throw NoSuchComponentFactory{"There is no component factory for the name " +
                                         componentFactoryName};
        }
        return setupManagedIceObject(ComponentFactory::get(componentFactoryName)(
                                         params.prop, params.configName, params.configDomain),
                                     registrationName);
    }
 
    RemoteObjectNode::IceObjectIdentityAndPrx
    RemoteObjectNode::setupIceObject(const Ice::ObjectPtr& ptr, Ice::Identity ident)
    {
        auto ioPrx = getArmarXManager()->getAdapter()->add(ptr, ident);
        return {std::move(ident), std::move(ioPrx)};
    }
 
    ClientSideRemoteHandleControlBlockBasePtr
    RemoteObjectNode::doRegisterRemoteHandledManagedIceObjectAtRON(
        RemoteObjectNode::ManagedIceObjectPtrAndPrx mio)
    {
        auto mioPtr = std::move(mio.ptr);
        auto axManager = getArmarXManager();
 
        auto id = nextRemoteHandledObjectId++;
        RemoteObjectNodePtr ron = this;
 
        auto mioRH =
            RemoteHandleControlBlock::create(axManager,
                                             std::move(mio.prx),
                                             [axManager, mioPtr, ron, id]
                                             {
                                                 axManager->removeObjectNonBlocking(mioPtr);
                                                 ron->removeRemoteHandledObject(id);
                                             });
        {
            std::lock_guard<std::mutex> lock(dataMutex);
            if (shuttingDown)
            {
                mioRH.directHandle->forceDeletion();
                throw ServerShuttingDown{};
            }
            remoteHandledObjects[id] = std::move(mioRH.directHandle);
        }
        return mioRH.clientSideRemoteHandleControlBlock;
    }
 
    ClientSideRemoteHandleControlBlockBasePtr
    RemoteObjectNode::doRegisterRemoteHandledIceObjectAtRON(
        RemoteObjectNode::IceObjectIdentityAndPrx io)
    {
        auto ioIdent = std::move(io.ident);
        auto objAdapter = getArmarXManager()->getAdapter();
 
        auto id = nextRemoteHandledObjectId++;
        RemoteObjectNodePtr ron = this;
 
        auto ioRH = RemoteHandleControlBlock::create(getArmarXManager(),
                                                     std::move(io.prx),
                                                     [objAdapter, ioIdent, ron, id]
                                                     {
                                                         objAdapter->remove(ioIdent);
                                                         ron->removeRemoteHandledObject(id);
                                                     });
        {
            std::lock_guard<std::mutex> lock(dataMutex);
            if (shuttingDown)
            {
                ioRH.directHandle->forceDeletion();
                throw ServerShuttingDown{};
            }
            remoteHandledObjects[id] = std::move(ioRH.directHandle);
        }
        return ioRH.clientSideRemoteHandleControlBlock;
    }
 
    Ice::ObjectPrx
    RemoteObjectNode::doRegisterPersistentManagedIceObjectAtRON(
        RemoteObjectNode::ManagedIceObjectPtrAndPrx mio)
    {
        {
            std::lock_guard<std::mutex> lock(dataMutex);
            if (shuttingDown)
            {
                getArmarXManager()->removeObjectBlocking(mio.ptr);
                throw ServerShuttingDown{};
            }
            persistentManagedIceObjects.emplace_back(std::move(mio.ptr));
        }
        return mio.prx;
    }
 
    Ice::ObjectPrx
    RemoteObjectNode::doRegisterPersistentIceObjectAtRON(
        RemoteObjectNode::IceObjectIdentityAndPrx io)
    {
        {
            std::lock_guard<std::mutex> lock(dataMutex);
            if (shuttingDown)
            {
                getArmarXManager()->getAdapter()->remove(io.ident);
                throw ServerShuttingDown{};
            }
            persistentIceObjectIdentities.emplace_back(std::move(io.ident));
        }
        return io.prx;
    }
 
    void
    RemoteObjectNode::removeRemoteHandledObject(Ice::Long id)
    {
        std::lock_guard<std::mutex> lock(dataMutex);
        auto it = remoteHandledObjects.find(id);
        if (it == remoteHandledObjects.end())
        {
            ARMARX_ERROR_S << "RON " << getName() << " has no object with id " << id;
            return;
        }
        //just to be safe
        it->second->forceDeletion();
        remoteHandledObjects.erase(it);
    }
 
    void
    RemoteObjectNode::shutdownAndCleanup()
    {
        shuttingDown = true;
        std::lock_guard<std::mutex> lock(dataMutex);
        for (auto& elem : remoteHandledObjects)
        {
            elem.second->forceDeletion();
        }
 
        auto axManager = getArmarXManager();
        for (auto& obj : persistentManagedIceObjects)
        {
            axManager->removeObjectBlocking(obj);
        }
        persistentManagedIceObjects.clear();
 
        auto adapter = axManager->getAdapter();
        for (auto& ident : persistentIceObjectIdentities)
        {
            adapter->remove(ident);
        }
        persistentIceObjectIdentities.clear();
    }
} // namespace armarx