AllupFactory.cc

Go to the documentation of this file.

/*
 * AllupFactory.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 AllupFactory.cc
 *
 * The shared library interface for libbroker_allup.
 */

#include "config.h"

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

#include <iostream>

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

#include "AllupImpl.hh"
#include "FactoryLibrary_ltdl.hh"

/**
 * Handle 'hey's directed at an edu::utah::pces::Allup 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 afAllupHey(CORBA::ORB_ptr orb, HeyParser &hp)
{
    static HeyPropertyInfo suites[] = {
        HeyPropertyInfo("library",
                        (1L << HeyParser::CREATE_PROPERTY),
                        "",
                        "name:string - The library name/path.\n"
                        "\n"
                        "Create a FactoryLibrary object for a particular "
                        "shared library.\n"
                        "If the library is already loaded, return its IOR.\n"),
        HeyPropertyInfo("libraries",
                        (1L << HeyParser::LIST_PROPERTIES),
                        "",
                        "List the names of the libraries currently open in "
                        "the server.\n"),
        HeyPropertyInfo::HPI_NULL
    };
    
    const char *prop_name, *prop_value;
    edu::utah::pces::Allup_var allup;
    int retval = EXIT_FAILURE;
    CORBA::Object_var obj;

    require(!CORBA::is_nil(orb));
    
    obj = orb->string_to_object(hp.who());
    allup = edu::utah::pces::Allup::_narrow(obj.in());
    if( CORBA::is_nil(allup.in()) )
    {
        throw CORBA::BAD_PARAM();
    }

    switch( hp.what() )
    {
    case HeyParser::LIST_PROPERTIES:
        try
        {
            hp.popProperty(prop_name, prop_value);
            if( strcasecmp(prop_name, "libraries") == 0 )
            {
                edu::utah::pces::FactoryLibraryList_var fll;
                unsigned int lpc;
                
                fll = allup->Libraries();
                for( lpc = 0; lpc < fll->length(); lpc++ )
                {
                    CORBA::String_var name;

                    name = fll[lpc]->Name();
                    cout << name << endl;
                }
            }
            else
            {
                cerr << "Unknown property: " << prop_name << endl;
            }
        }
        catch(const HeyParserException &e)
        {
            cout << "library" << endl;
            cout << "libraries" << endl;
            retval = EXIT_SUCCESS;
        }
        break;
    case HeyParser::CREATE_PROPERTY:
        hp.popProperty(prop_name, prop_value);
        if( strcasecmp(prop_name, "library") == 0 )
        {
            try
            {
                edu::utah::pces::FactoryLibrary_var fl;
                
                fl = allup->OpenLibrary(hp.withValue("name"));
                if( !CORBA::is_nil(fl.in()) )
                {
                    cout << orb->object_to_string(fl.in()) << endl;
                    retval = EXIT_SUCCESS;
                }
                else
                {
                    cerr << "Unknown error..." << endl;
                }
            }
            catch(const edu::utah::pces::NoSuchLibrary &e)
            {
                cerr << "Error: No such library '"
                     << e.name
                     << "': "
                     << e.message
                     << endl;
            }
            catch(const HeyParserException &e)
            {
                cerr << "Name not specified!\n";
            }
        }
        else
        {
            cerr << "Unknown property: " << prop_name << endl;
        }
        break;
    case HeyParser::SHUTDOWN:
        try
        {
            allup->Shutdown();
        }
        catch(const CORBA::COMM_FAILURE &e)
        {
            // ...
        }
        cout << "ok" << endl;
        retval = EXIT_SUCCESS;
        break;
    case HeyParser::GET_SUITES:
        try
        {
            hp.popProperty(prop_name, prop_value);
        }
        catch(const HeyParserException &e)
        {
            cout << suites;
            retval = EXIT_SUCCESS;
        }
        break;
    default:
        cerr << "Unknown verb..." << endl;
        break;
    }
    return( retval );
}

/**
 * Handle 'hey's directed at an edu::utah::pces::FactoryLibrary 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 afFactoryLibraryHey(CORBA::ORB_ptr orb, HeyParser &hp)
{
    edu::utah::pces::FactoryLibrary_var fl;
    CORBA::String_var out, err;
    int retval = EXIT_FAILURE;
    CORBA::Object_var obj;

    require(!CORBA::is_nil(orb));
    
    obj = orb->string_to_object(hp.who());
    fl = edu::utah::pces::FactoryLibrary::_narrow(obj.in());
    if( CORBA::is_nil(fl.in()) )
    {
        throw CORBA::BAD_PARAM();
    }

    retval = fl->Hey(edu::utah::pces::ArgV(hp.getArgCount(),
                                           hp.getArgCount(),
                                           (char **)hp.getArgValues()),
                     out.out(),
                     err.out());

    cout << out;
    cerr << err;
    
    return( retval );
}

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

    struct {
        const char *hey_server_hint;
        HeyParser *hey_parser;
        CORBA::ORB_ptr orb;
        PortableServer::POA_ptr poa;
    } attr = {
        NULL,
        NULL,
        NULL,
        PortableServer::POA::_nil(),
    };

    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;
        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:edu/utah/pces/Allup:1.0") == 0) ||
                (strcmp(attr.hey_server_hint,
                        "IDL:edu/utah/pces/FactoryLibrary:1.0") == 0) )
            {
                retval = EXIT_SUCCESS;
            }
            else
            {
            }
        }
        else
        {
            cout << "\tIDL:edu/utah/pces/Allup:1.0" << endl
                 << "\tIDL:edu/utah/pces/FactoryLibrary:1.0" << endl;
        }
        break;
    case FLO_HEY:
        if( attr.hey_server_hint != NULL )
        {
            try
            {
                if( strcmp(attr.hey_server_hint,
                           "IDL:edu/utah/pces/Allup:1.0") == 0 )
                {
                    retval = afAllupHey(attr.orb, *attr.hey_parser);
                }
                else if( strcmp(attr.hey_server_hint,
                                "IDL:edu/utah/pces/FactoryLibrary:1.0") == 0 )
                {
                    retval = afFactoryLibraryHey(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
        {
        }
        break;
    default:
        break;
    }
    
    return( retval );
}

---