DelegateFactory.cc

Go to the documentation of this file.

/*
 * DelegateFactory.cc
 *
 * Copyright (c) 2003, 2004 The University of Utah and the Flux Group.
 * All rights reserved.
 *
 * This file is licensed under the terms of the GNU Public License.  
 * See the file "license.terms" for restrictions on redistribution 
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

/**
 * @file DelegateFactory.cc
 *
 * The shared library interface for libdelegates.
 */

#include "config.h"

#include <errno.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>

#include <iostream>

#include <assert_pp.h>
#include <HeyParser.hh>
#include <factory_library.h>

#include "RealTimeTaskDelegateImpl.hh"
#include "StrictPolicyDelegateImpl.hh"

#include <AnyPrinter.hh>

using namespace std;

/**
 * Handle 'hey's directed at the library.
 *
 * @param orb Pointer to the ORB.
 * @param poa The POA to use when activating objects.
 * @param hp The HeyParser that describes the action to take.
 * @param out Standard out.
 * @param err Standard error.
 * @return Zero on success, an errno value otherwise.
 */
static int dfHey(CORBA::ORB_ptr orb,
                 PortableServer::POA_ptr poa,
                 HeyParser &hp,
                 ostream &out,
                 ostream &err)
{
    static HeyPropertyInfo suites[] = {
        HeyPropertyInfo("real-time-task-delegate",
                        (1L << HeyParser::CREATE_PROPERTY),
                        "",
                        "Create a RealTimeTaskDelegate object.  This is a "
                        "blank delegate that does\n"
                        "no adaptation.\n"),
        HeyPropertyInfo("strict-policy-delegate",
                        (1L << HeyParser::CREATE_PROPERTY),
                        "",
                        "Create a StrictPolicyDelegate object.  This is a "
                        "blank delegate that does\n"
                        "no adaptation.\n"),
        HeyPropertyInfo::HPI_NULL
    };

    const char *prop_name, *prop_value;
    int retval = EXIT_FAILURE;

    require(!CORBA::is_nil(orb));

    switch( hp.what() )
    {
    case HeyParser::LIST_PROPERTIES:
        try
        {
            hp.popProperty(prop_name, prop_value);
        }
        catch(const HeyParserException &e)
        {
            out << "real-time-task-delegate" << endl;
        }
        break;
    case HeyParser::CREATE_PROPERTY:
        hp.popProperty(prop_name, prop_value);
        if( strcasecmp(prop_name, "real-time-task-delegate") == 0 )
        {
            BrokerDelegates::RealTimeTaskDelegate_var rttd;
            PortableServer::ObjectId_var oid;
            RealTimeTaskDelegateImpl *rttdi;

            rttdi = new RealTimeTaskDelegateImpl();
            oid = poa->activate_object(rttdi);
            rttd = BrokerDelegates::RealTimeTaskDelegate::
                _narrow(poa->id_to_reference(oid.in()));
            out << orb->object_to_string(rttd._retn()) << endl;
            retval = EXIT_SUCCESS;
        }
        else if( strcasecmp(prop_name, "strict-policy-delegate") == 0 )
        {
            BrokerDelegates::StrictPolicyDelegate_var spd;
            PortableServer::ObjectId_var oid;
            StrictPolicyDelegateImpl *spdi;

            spdi = new StrictPolicyDelegateImpl();
            oid = poa->activate_object(spdi);
            spd = BrokerDelegates::StrictPolicyDelegate::
                _narrow(poa->id_to_reference(oid.in()));
            out << orb->object_to_string(spd._retn()) << endl;
            retval = EXIT_SUCCESS;
        }
        else
        {
            err << "Unknown property: " << prop_name << endl;
        }
        break;
    case HeyParser::GET_SUITES:
        try
        {
            hp.popProperty(prop_name, prop_value);
            err << "Unknown property: " << prop_name << endl;
        }
        catch(const HeyParserException &e)
        {
            out << suites;
            retval = EXIT_SUCCESS;
        }
        break;
    default:
        err << "Unknown verb" << endl;
        break;
    }
    return( retval );
}

/**
 * Handle 'hey's directed at a Delegate object.
 *
 * @param orb Pointer to the ORB.
 * @param hp The HeyParser that describes the action to take.
 * @return Zero on success, an errno value otherwise.
 */
static int dfDelegateHey(CORBA::ORB_ptr orb, HeyParser &hp)
{
    static HeyPropertyInfo suites[] = {
        HeyPropertyInfo("remote-object",
                        (1L << HeyParser::SET_PROPERTY) |
                        (1L << HeyParser::GET_PROPERTY),
                        "",
                        "Get or set the object the delegate proxies.\n"),
        HeyPropertyInfo("insert",
                        (1L << HeyParser::EXECUTE_PROPERTY),
                        "",
                        "delegate:object - The delegate to insert.\n"
                        "\n"
                        "Insert another delegate between this object and the\n"
                        "remote object.\n"),
        HeyPropertyInfo("<delegate-attribute>",
                        (1L << HeyParser::SET_PROPERTY) |
                        (1L << HeyParser::GET_PROPERTY),
                        "",
                        "Get or set a delegate attribute.\n"),
        HeyPropertyInfo::HPI_NULL
    };
    
    const char *prop_name, *prop_value, *to_value;
    BrokerDelegates::Delegate_var delegate;
    int retval = EXIT_FAILURE;
    CORBA::Object_var obj;
    
    obj = orb->string_to_object(hp.who());
    delegate = BrokerDelegates::Delegate::_narrow(obj.in());
    if( CORBA::is_nil(delegate.in()) )
    {
        throw CORBA::BAD_PARAM();
    }
    
    switch( hp.what() )
    {
    case HeyParser::LIST_PROPERTIES:
        try
        {
            hp.popProperty(prop_name, prop_value);
        }
        catch(const HeyParserException &e)
        {
            cout << "remote-object" << endl;
            retval = EXIT_SUCCESS;
        }
        break;
    case HeyParser::GET_PROPERTY:
        hp.popProperty(prop_name, prop_value);
        if( strcasecmp(prop_name, "remote-object") == 0 )
        {
            obj = delegate->GetDelegateAttributeObject(prop_name);
            cout << orb->object_to_string(obj.in()) << endl;
            retval = EXIT_SUCCESS;
        }
        else
        {
            try
            {
                CORBA::Any *any;

                any = delegate->GetDelegateAttribute(prop_name);
                AnyPrinter::print_to_stream(cout, *any);
            }
            catch(const CORBA::BAD_PARAM &e)
            {
                cerr << "Unknown property: " << prop_name << endl;
            }
        }
        break;
    case HeyParser::SET_PROPERTY:
        hp.popProperty(prop_name, prop_value);
        if( strcasecmp(prop_name, "remote-object") == 0 )
        {
            to_value = hp.to();
            obj = orb->string_to_object(to_value);
            delegate->SetDelegateAttributeObject(prop_name, obj.in());
            cout << "ok" << endl;
            retval = EXIT_SUCCESS;
        }
        else
        {
            try
            {
                CORBA::Any any;

                any <<= hp.to();
                delegate->SetDelegateAttribute(prop_name, any);
                cout << "ok" << endl;
                retval = EXIT_SUCCESS;
            }
            catch(const CORBA::BAD_PARAM &e)
            {
                cerr << "Unknown property: " << prop_name << endl;
            }
        }
        break;
    case HeyParser::EXECUTE_PROPERTY:
        hp.popProperty(prop_name, prop_value);
        if( strcasecmp(prop_name, "insert") == 0 )
        {
            BrokerDelegates::Delegate_var interposer;
            CORBA::Object_var remote_object;
            
            obj = orb->string_to_object(hp.withValue("delegate"));
            interposer = BrokerDelegates::Delegate::_narrow(obj.in());
            if( CORBA::is_nil(interposer.in()) )
            {
                cerr << "Error: delegate value not a Delegate\n" << endl;
                throw CORBA::BAD_PARAM();
            }
            
            remote_object = delegate->
                GetDelegateAttributeObject("remote-object");
            if( CORBA::is_nil(remote_object.in()) )
            {
                cerr << "Error: no remote object to interpose on.\n" << endl;
                throw CORBA::BAD_PARAM();
            }
            
            interposer->SetDelegateAttributeObject("remote-object",
                                                   remote_object.in());
            delegate->SetDelegateAttributeObject("remote-object",
                                                 interposer.in());
            cout << "ok" << endl;
            retval = EXIT_SUCCESS;
        }
        else
        {
            cerr << "Unknown property: " << prop_name << endl;
        }
        break;
    case HeyParser::GET_SUITES:
        try
        {
            hp.popProperty(prop_name, prop_value);
            cerr << "Unknown property: " << prop_name << endl;
        }
        catch(const HeyParserException &e)
        {
            cout << suites;
            retval = EXIT_SUCCESS;
        }
        break;
    default:
        cerr << "Unknown verb..." << endl;
        break;
    }
    return( retval );
}

int FACTORY_METHOD_SYMBOL(factory_library_op_t op, int tag, va_list args)
{
    int retval = EXIT_FAILURE;

    struct {
        const char *hey_server_hint;
        HeyParser *hey_parser;
        CORBA::ORB_ptr orb;
        PortableServer::POA_ptr poa;
        ostream *out;
        ostream *err;
    } attr = {
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
    };
    
    while( tag != FMA_TAG_DONE )
    {
        switch( tag )
        {
        case FMA_ORB:
            attr.orb = va_arg(args, CORBA::ORB_ptr);
            break;
        case FMA_POA:
            attr.poa = va_arg(args, PortableServer::POA_ptr);
            break;
        case FMA_HeyParser:
            attr.hey_parser = va_arg(args, HeyParser *);
            break;
        case FMA_HeyServerHint:
            attr.hey_server_hint = va_arg(args, const char *);
            break;
        case FMA_StandardOut:
            attr.out = va_arg(args, ostream *);
            break;
        case FMA_StandardError:
            attr.err = va_arg(args, ostream *);
            break;
        default:
            break;
        }
        tag = va_arg(args, int);
    }

    switch( op )
    {
    case FLO_QUERY:
        if( attr.hey_server_hint != NULL )
        {
            if( strcmp(attr.hey_server_hint,
                       "IDL:BrokerDelegates/Delegate:1.0") == 0 )
            {
                retval = EXIT_SUCCESS;
            }
            else
            {
            }
        }
        else
        {
            cout << "\tIDL:BrokerDelegates/Delegate:1.0" << endl;
        }
        break;
    case FLO_HEY:
        if( attr.hey_server_hint != NULL )
        {
            try
            {
                if( strcmp(attr.hey_server_hint,
                           "IDL:BrokerDelegates/Delegate:1.0") == 0 )
                {
                    retval = dfDelegateHey(attr.orb, *attr.hey_parser);
                }
                else
                {
                }
            }
            catch(const HeyParserException &he)
            {
                cerr << "Parse error: " << he << endl;
            }
            catch(const CORBA::SystemException &e)
            {
                cerr << "Caught Exception: " << e << endl;
            }
            catch(...)
            {
                cerr << "Caught an unhandled exception" << endl;
            }
        }
        else
        {
            retval = dfHey(attr.orb,
                           attr.poa,
                           *attr.hey_parser,
                           *attr.out,
                           *attr.err);
        }
        break;
    default:
        break;
    }
    
    return( retval );
}

---