BrokerFactory.cc

Go to the documentation of this file.

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

#include "config.h"

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

#include <iostream>

#include "time_util.h"
#include "HeyParser.hh"
#include "factory_library.h"

#include "ManagerImpl.hh"
#include "RealTimeTaskImpl.hh"
#include "StubRealTimeTask.hh"
#include "StubPolicy.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 any 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 bfHey(CORBA::ORB_ptr orb,
                 PortableServer::POA_ptr poa,
                 HeyParser &hp,
                 ostream &out,
                 ostream &err)
{
    static HeyPropertyInfo suites[] = {
        HeyPropertyInfo("manager",
                        (1L << HeyParser::CREATE_PROPERTY),
                        "",
                        "name:string - The name of the manager.\n"
                        "\n"
                        "Create a Broker::Manager object.  This object is "
                        "used to coordinate\n"
                        "actions with the other Broker objects.  You need to "
                        "have atleast one of\n"
                        "of these active at all times.\n"),
        HeyPropertyInfo("stub-real-time-task",
                        (1L << HeyParser::CREATE_PROPERTY),
                        "",
                        "name:string - The name of the task.\n"
                        "\n"
                        "Create a StubRealTimeTask object.  Mostly used for "
                        "testing.\n"),
        HeyPropertyInfo("stub-policy",
                        (1L << HeyParser::CREATE_PROPERTY),
                        "",
                        "name:string - The name of the policy.\n"
                        "\n"
                        "Create a StubPolicy object.  Mostly used for "
                        "testing.\n"),
        HeyPropertyInfo("real-time-task",
                        (1L << HeyParser::CREATE_PROPERTY),
                        "",
                        "name:string - The name for the task object.\n"
                        "\n"
                        "Create a RealTimeTaskImpl object.  This object is "
                        "used to pass CPU reports\n"
                        "on to the manager object.\n"),
        HeyPropertyInfo::HPI_NULL
    };

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

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

    switch( hp.what() )
    {
    case HeyParser::LIST_PROPERTIES:
        try
        {
            hp.popProperty(prop_name, prop_value);
        }
        catch(const HeyParserException &e)
        {
            out << "manager" << endl;
            out << "stub-real-time-task" << endl;
            out << "stub-policy" << endl;
            out << "real-time-task" << endl;
        }
        break;
    case HeyParser::CREATE_PROPERTY:
        hp.popProperty(prop_name, prop_value);
        if( strcasecmp(prop_name, "manager") == 0 )
        {
            ManagerImpl *mi = new ManagerImpl(hp.withValue("name"));
            PortableServer::ObjectId_var oid;
            Broker::Manager_var manager;

            oid = poa->activate_object(mi);
            manager = Broker::Manager::_narrow(poa->id_to_reference(oid.in()));
            out << orb->object_to_string(manager._retn()) << endl;
            retval = EXIT_SUCCESS;
        }
        else if( strcasecmp(prop_name, "stub-real-time-task") == 0 )
        {
            PortableServer::ObjectId_var oid;
            Broker::RealTimeTask_var rtt;
            StubRealTimeTask *srtt;

            srtt = new StubRealTimeTask(hp.withValue("name"));
            oid = poa->activate_object(srtt);
            rtt = Broker::RealTimeTask::
                _narrow(poa->id_to_reference(oid.in()));
            out << orb->object_to_string(rtt._retn()) << endl;
            retval = EXIT_SUCCESS;
        }
        else if( strcasecmp(prop_name, "stub-policy") == 0 )
        {
            PortableServer::ObjectId_var oid;
            Broker::Policy_var policy;
            StubPolicy *sp;

            sp = new StubPolicy(hp.withValue("name"));
            oid = poa->activate_object(sp);
            policy = Broker::Policy::_narrow(poa->id_to_reference(oid.in()));
            out << orb->object_to_string(policy._retn()) << endl;
            retval = EXIT_SUCCESS;
        }
        else if( strcasecmp(prop_name, "real-time-task") == 0 )
        {
            PortableServer::ObjectId_var oid;
            Broker::TaskParameters tp(2);
            const char *str;

            tp.length(1);

            str = hp.withValue("name");
            tp[0].name = "name";
            tp[0].value <<= str;
            
            RealTimeTaskImpl *rtti = new RealTimeTaskImpl(tp);
            Broker::RealTimeTask_var rtt;

            oid = poa->activate_object(rtti);
            rtt = Broker::RealTimeTask::
                _narrow(poa->id_to_reference(oid.in()));
            out << orb->object_to_string(rtt._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 Broker::Manager 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 bfManagerHey(CORBA::ORB_ptr orb, HeyParser &hp)
{
    static HeyPropertyInfo suites[] = {
        HeyPropertyInfo("policy",
                        (1L << HeyParser::SET_PROPERTY) |
                        (1L << HeyParser::GET_PROPERTY),
                        "",
                        "Get or set the object that implements the contention "
                        "policy.  Policy objects\n"
                        "can be created using the libpolicies library.\n"),
        HeyPropertyInfo("add-task",
                        (1L << HeyParser::EXECUTE_PROPERTY),
                        "",
                        "task:ior - The task to add.\n"
                        "pid:pid_t - The process ID to begin scheduling for.\n"
                        "period:time - The period for the reservation.\n"
                        "deadline:time - The deadline for the reservation.\n"
                        "... - Any additional key/value parameters.\n"
                        "\n"
                        "Add a task to the manager.  Tasks must be added to "
                        "the manager before\n"
                        "they can send a CPU usage report.\n"),
        HeyPropertyInfo("tasks",
                        (1L << HeyParser::LIST_PROPERTIES),
                        "",
                        "List the tasks currently being managed.\n"),
        HeyPropertyInfo("task",
                        (1L << HeyParser::GET_PROPERTY),
                        "name:string - The task name.",
                        "Get the IOR for the task matching the given name.\n"),
        HeyPropertyInfo::HPI_NULL
    };
    
    static HeyPropertyInfo task_suites[] = {
        HeyPropertyInfo("remove",
                        (1L << HeyParser::EXECUTE_PROPERTY),
                        "",
                        "Remove the task from the manager.\n"),
        HeyPropertyInfo::HPI_NULL
    };
    
    const char *prop_name, *prop_value;
    Broker::Manager_var manager;
    int retval = EXIT_FAILURE;
    Broker::TaskList_var tl;
    CORBA::Object_var obj;
    Broker::Task_var task;
    
    obj = orb->string_to_object(hp.who());
    manager = Broker::Manager::_narrow(obj.in());
    if( CORBA::is_nil(manager.in()) )
    {
        throw CORBA::BAD_PARAM();
    }
    
    tl = manager->GetTaskList();
    switch( hp.what() )
    {
    case HeyParser::LIST_PROPERTIES:
        try
        {
            hp.popProperty(prop_name, prop_value);
            if( strcasecmp(prop_name, "tasks") == 0 )
            {
                unsigned int lpc;
                
                for( lpc = 0; lpc < tl->length(); lpc++ )
                {
                    try
                    {
                        cout << tl[lpc]->Name() << endl;
                    }
                    catch(const CORBA::SystemException &e)
                    {
                        cout << orb->object_to_string(tl[lpc]) << endl;
                        cerr << e << endl;
                    }
                }
                retval = EXIT_SUCCESS;
            }
            else
            {
                cerr << "Unknown property: " << prop_name << endl;
            }
        }
        catch(const HeyParserException &e)
        {
            cout << "policy" << endl;
            cout << "add-task" << endl;
            cout << "tasks" << endl;
            cout << "task" << endl;
            retval = EXIT_SUCCESS;
        }
        break;
    case HeyParser::EXECUTE_PROPERTY:
        hp.popProperty(prop_name, prop_value);
        if( strcasecmp(prop_name, "add-task") == 0 )
        {
            Broker::ScheduleParameters sp;
            Broker::Task_var task;
            const char **with_sp;
            unsigned int lpc;
            size_t sp_count;
            
            obj = orb->string_to_object(hp.withValue("task"));
            task = Broker::Task::_narrow(obj.in());
            if( CORBA::is_nil(task.in()) )
            {
                throw CORBA::BAD_PARAM();
            }
            
            hp.with(with_sp, sp_count);
            for( lpc = 0; lpc < sp_count; lpc += 2 )
            {
                if( strcasecmp(with_sp[lpc], "task") != 0 )
                {
                    sp.length(sp.length() + 1);
                    sp[sp.length() - 1].name = with_sp[lpc];
                    sp[sp.length() - 1].value <<= with_sp[lpc + 1];
                }
            }

            try
            {
                manager->AddTask(task.in(), sp);

                cout << "ok" << endl;
            }
            catch(const Broker::DuplicateScheduleParameter &e)
            {
                cerr << e << ": " << e.name << endl;
            }
            catch(const Broker::InvalidScheduleParameter &e)
            {
                cerr << e << ": " << e.message << endl;
            }
            catch(const Broker::MissingScheduleParameter &e)
            {
                cerr << e << ": " << e.name << endl;
            }
        }
        else if( strcasecmp(prop_name, "task") == 0 )
        {
            Broker::Task_var task;

            task = ManagerImpl::ResolveTask(orb, tl, prop_value);
            hp.popProperty(prop_name, prop_value);
            if( strcasecmp(prop_name, "remove") == 0 )
            {
                manager->RemoveTask(task.in());

                cout << "ok" << endl;
                retval = EXIT_SUCCESS;
            }
            else
            {
                cerr << "Unknown property: " << prop_name << endl;
            }
        }
        else
        {
            cerr << "Unknown property: " << prop_name << endl;
        }
        break;
    case HeyParser::GET_PROPERTY:
        hp.popProperty(prop_name, prop_value);
        if( strcasecmp(prop_name, "policy") == 0 )
        {
            Broker::Policy_var policy;
                    
            policy = manager->CurrentPolicy();
            if( CORBA::is_nil(policy.in()) )
            {
                cout << "(none)" << endl;
            }
            else
            {
                cout << orb->object_to_string(manager->CurrentPolicy())
                     << endl;
            }
            retval = EXIT_SUCCESS;
        }
        else if( strcasecmp(prop_name, "task") == 0 )
        {
            Broker::Task_var task;

            task = ManagerImpl::ResolveTask(orb, tl, prop_value);
            cout << orb->object_to_string(task.in()) << endl;
        }
        else
        {
            cerr << "Unknown property: " << prop_name << endl;
        }
        break;
    case HeyParser::SET_PROPERTY:
        hp.popProperty(prop_name, prop_value);
        if( strcasecmp(prop_name, "policy") == 0 )
        {
            Broker::Policy_var policy;
            const char *policy_ior;
            
            policy_ior = hp.to();
            obj = orb->string_to_object(policy_ior);
            if( !CORBA::is_nil(obj.in()) )
            {
                policy = Broker::Policy::_narrow(obj.in());
                if( CORBA::is_nil(policy.in()) )
                {
                    throw CORBA::BAD_PARAM();
                }
            }
            manager->CurrentPolicy(policy.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);
            if( strcasecmp(prop_name, "task") == 0 )
            {
                cout << task_suites;
                retval = EXIT_SUCCESS;
            }
            else
            {
                cerr << "Unknown property: " << prop_name << endl;
            }
        }
        catch(const HeyParserException &e)
        {
            cout << suites;
            retval = EXIT_SUCCESS;
        }
        break;
    default:
        cerr << "Unknown verb..." << endl;
        break;
    }
    return( retval );
}

/**
 * Handle 'hey's directed at a Broker::RealTimeTask 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 bfRealTimeTaskHey(CORBA::ORB_ptr orb, HeyParser &hp)
{
    static HeyPropertyInfo suites[] = {
        HeyPropertyInfo("name",
                        (1L << HeyParser::GET_PROPERTY),
                        "",
                        "Get the name of this task.\n"),
        HeyPropertyInfo("manager",
                        (1L << HeyParser::SET_PROPERTY),
                        "",
                        "Set the manager for this task.  This should not "
                        "be called directly, use\n"
                        "the manager's add-task method instead.\n"),
        HeyPropertyInfo("begin-cpu-scheduling",
                        (1L << HeyParser::EXECUTE_PROPERTY),
                        "",
                        "pid:pid_t - The process ID to begin scheduling for.\n"
                        "period:time - The period for the reservation.\n"
                        "deadline:time - The deadline for the reservation.\n"
                        "... - Any additional key/value parameters.\n"
                        "\n"
                        "Begin CPU scheduling for the task.  This should not "
                        "be called directly, use\n"
                        "the manager's add-task method instead.\n"),
        HeyPropertyInfo("end-cpu-scheduling",
                        (1L << HeyParser::EXECUTE_PROPERTY),
                        "",
                        "End CPU scheduling for this task.  This should not "
                        "be called directly, use\n"
                        "the manager to remove the task instead.\n"),
        HeyPropertyInfo("report-cpu",
                        (1L << HeyParser::EXECUTE_PROPERTY),
                        "",
                        "status.period:int - The application's requested "
                        "length of the next period.\n"
                        "status.compute:int - The application's requested CPU "
                        "time for the next period.\n"
                        "advice.period:int - The requested length of the next "
                        "period.\n"
                        "advice.compute:int - The requested CPU time for the "
                        "next period.\n"
                        "\n"
                        "Make a CPU usage report.\n"),
        HeyPropertyInfo::HPI_NULL
    };
    
    const char *prop_name, *prop_value;
    Broker::RealTimeTask_var rtt;
    int retval = EXIT_FAILURE;
    CORBA::Object_var obj;
    
    obj = orb->string_to_object(hp.who());
    rtt = Broker::RealTimeTask::_narrow(obj.in());
    if( CORBA::is_nil(rtt.in()) )
    {
        throw CORBA::BAD_PARAM();
    }
    
    switch( hp.what() )
    {
    case HeyParser::LIST_PROPERTIES:
        try
        {
            hp.popProperty(prop_name, prop_value);
            cerr << "Unknown property: " << prop_name << endl;
        }
        catch(const HeyParserException &e)
        {
            cout << "name" << endl;
            cout << "report-cpu" << endl;
            retval = EXIT_SUCCESS;
        }
        break;
    case HeyParser::GET_PROPERTY:
        hp.popProperty(prop_name, prop_value);
        if( strcasecmp(prop_name, "name") == 0 )
        {
            cout << rtt->Name() << endl;
        }
        else
        {
            cerr << "Unknown property: " << prop_name << endl;
        }
        break;
    case HeyParser::SET_PROPERTY:
        hp.popProperty(prop_name, prop_value);
        if( strcasecmp(prop_name, "manager") == 0 )
        {
            Broker::Manager_var manager;
            
            obj = orb->string_to_object(hp.to());
            if( !CORBA::is_nil(obj.in()) )
            {
                manager = Broker::Manager::_narrow(obj.in());
                if( CORBA::is_nil(manager.in()) )
                {
                    cerr << "Invalid manager IOR." << endl;
                    throw CORBA::BAD_PARAM();
                }
            }
            rtt->SetManager(manager.in());
            
            cout << "ok\n";
        }
        else
        {
            cerr << "Unknown property: " << prop_name << endl;
        }
        break;
    case HeyParser::EXECUTE_PROPERTY:
        hp.popProperty(prop_name, prop_value);
        if( strcasecmp(prop_name, "report-cpu") == 0 )
        {
            unsigned long long status_period_ull, status_compute_ull;
            unsigned long long advice_period_ull, advice_compute_ull;
            Broker::KeyedReportParameters krp;

            if( string_to_microsec(&status_period_ull,
                                   hp.withValue("status.period")) == 0 )
            {
                cerr << "Invalid status.period value: "
                     << status_period_ull
                     << endl;
            }
            else if( string_to_microsec(&status_compute_ull,
                                        hp.withValue("status.compute")) == 0 )
            {
                cerr << "Invalid status.compute value: "
                     << status_compute_ull
                     << endl;
            }
            else if( string_to_microsec(&advice_period_ull,
                                        hp.withValue("advice.period")) == 0 )
            {
                cerr << "Invalid advice.period value: "
                     << advice_period_ull << endl;
            }
            else if( string_to_microsec(&advice_compute_ull,
                                        hp.withValue("advice.compute")) == 0 )
            {
                cerr << "Invalid advice.compute value: "
                     << advice_compute_ull << endl;
            }
            else
            {
                Broker::CPUReserve status, advice;

                status.Period = status_period_ull;
                status.Compute = status_compute_ull;
                advice.Period = advice_period_ull;
                advice.Compute = advice_compute_ull;
                rtt->ReportCPU(status, advice, krp);
                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 = ENOSYS;

    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:Broker/Manager:1.0") == 0 )
            {
                retval = EXIT_SUCCESS;
            }
            else if( strcmp(attr.hey_server_hint,
                            "IDL:Broker/RealTimeTask:1.0") == 0 )
            {
                retval = EXIT_SUCCESS;
            }
            else
            {
            }
        }
        else
        {
            cout << "\tIDL:Broker/Manager:1.0" << endl
                 << "\tIDL:Broker/RealTimeTask:1.0" << endl;
        }
        break;
    case FLO_HEY:
        if( attr.hey_server_hint != NULL )
        {
            try
            {
                if( strcmp(attr.hey_server_hint,
                           "IDL:Broker/Manager:1.0") == 0 )
                {
                    retval = bfManagerHey(attr.orb, *attr.hey_parser);
                }
                else if( strcmp(attr.hey_server_hint,
                                "IDL:Broker/RealTimeTask:1.0") == 0 )
                {
                    retval = bfRealTimeTaskHey(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 = bfHey(attr.orb,
                           attr.poa,
                           *attr.hey_parser,
                           *attr.out,
                           *attr.err);
        }
        break;
    default:
        break;
    }
    
    return( retval );
}

---