icegridutils.h

/*
 * Orca-Robotics Project: Components for robotics
 *               http://orca-robotics.sf.net/
 * Copyright (c) 2004-2009 Alex Brooks, Alexei Makarenko, Tobias Kaupp
 *
 * This copy of Orca is licensed to you under the terms described in
 * the LICENSE file included in this distribution.
 *
 */

#ifndef ORCAICE_ICEGRID_UTILITIES_H
#define ORCAICE_ICEGRID_UTILITIES_H

#include <IceGrid/Query.h>

#include <orcaice/context.h>
#include <orcaice/configutils.h>
#include <orcaice/exceptions.h>
// #include <orcaice/stringutils.h>  // just for debugging
#include <orcaice/printutils.h>

namespace orcaice
{

bool isRegistryReachable( const Context& context );

IceGrid::QueryPrx getDefaultQuery( const orcaice::Context& context );

Ice::Identity toAdminIdentity( const orca::FQComponentName& );

orca::FQComponentName toComponentName( const Ice::Identity& adminId );

orca::FQComponentName toComponentName( const Ice::ObjectPrx& homePrx );

Ice::ObjectPrx getComponentAdmin( const orcaice::Context& context, const orca::FQComponentName& fqName );

Ice::ObjectProxySeq getAllComponentAdmins( const orcaice::Context& context );

std::string toAdminFacet( const orca::FQComponentName& fqName, const std::string& interfaceType );

bool isAdminInterfaceReachable( const Context& context, const orca::FQComponentName& fqName, const std::string& interfaceType,
                           std::string& diagnostic );

void createAdminInterface( const Context& context, Ice::ObjectPtr& object, const orca::FQComponentName& fqname );

// template<class InterfaceProxyType>
// void connectToAdminInterfaceWithFacet( const Context& context, InterfaceProxyType interfacePrx, const std::string& facet,
template<class InterfaceType, class InterfaceProxyType>
void connectToAdminInterface( const Context& context, InterfaceProxyType& interfacePrx, const orca::FQComponentName& fqname )
{
    orca::FQComponentName resolvedFqname = orcaice::resolveLocalPlatform( context, fqname );

// std::cout<<"DEBUG: "<<__func__<<"(): will look for Admin interface of ="<<orcaice::toString(resolvedFqname)<<std::endl;

    const std::string interfaceType = InterfaceType::ice_staticId();
    const std::string facetName = orcaice::toAdminFacet( resolvedFqname, interfaceType );

// std::cout<<"DEBUG: "<<__func__<<"(): will connect to facet="<<facetName<<std::endl;

    //
    // This is the generic proxy to the Admin object. Cannot be used as such because it does not have a default facet.
    //
    Ice::ObjectPrx objectPrx = orcaice::getComponentAdmin( context, resolvedFqname );

    if ( !objectPrx )
        throw gbxutilacfr::Exception( ERROR_INFO,
            "Registry returned null admin proxy for component "+resolvedFqname.platform+"/"+resolvedFqname.component );

// std::cout<<"DEBUG: "<<__func__<<"(): got admin proxy ="<<objectPrx->ice_toString()<<std::endl;

    //
    // Change proxy to the user-supplied facet name.
    //
    objectPrx = objectPrx->ice_facet( facetName );

    // check with the server that the one we found is of the right type
    // the check operation is remote and may fail (see sec.6.11.2)
    try {
        interfacePrx = InterfaceProxyType::checkedCast( objectPrx );
        // got some answer, check that it's the right type
        if ( !interfacePrx ) {
            // contains another remote call ice_id() !!!
            std::string errString = "Admin interface with facet '" + facetName + "' is of wrong type."+
                "  Tried to connect proxy of type "+InterfaceType::ice_staticId()+
                " to remote interface of type "+objectPrx->ice_id();
            orcaice::initTracerWarning( context, errString );
            throw orcaice::TypeMismatchException( ERROR_INFO, errString );
        }
    }
    catch ( const Ice::ConnectionRefusedException& e )
    {
        std::stringstream ss;
        ss << "(while connecting to Admin interface with facet '" << facetName << "') cannot reach the adaptor: "<<e.what();
        orcaice::initTracerWarning( context, ss.str() );
        throw orcaice::NetworkException( ERROR_INFO, ss.str() );
    }
    catch ( const Ice::ObjectNotExistException& e )
    {
        std::stringstream ss;
        ss << "(while connecting to Admin interface with facet '" << facetName << "') reached the adaptor but not the interface: "<<e.what();
        orcaice::initTracerWarning( context, ss.str() );
        throw orcaice::NetworkException( ERROR_INFO, ss.str() );
    }
    catch ( const Ice::FacetNotExistException& e )
    {
        std::stringstream ss;
        ss << "(while connecting to Admin interface with facet '" << facetName << "') reached the adaptor and the interface but not the facet: "<<e.what();
        orcaice::initTracerWarning( context, ss.str() );
        throw orcaice::NetworkException( ERROR_INFO, ss.str() );
    }
    catch ( const std::exception& e )
    {
        std::stringstream ss;
        ss << "(while connecting to Admin interface with facet '" << facetName << "') something unexpected: "<<e.what();
        orcaice::initTracerWarning( context, ss.str() );
        throw orcaice::NetworkException( ERROR_INFO, ss.str() );
    }
}


} // namespace

#endif