rt_server.cc

Go to the documentation of this file.

/*
 * rt_server.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 rt_server.cc
 *
 * Server for a single RTServer object.
 *
 * @sa RTServerImpl.hh
 * @sa RTServer.idl
 * @sa rt_client.cc
 */

#include "config.h"

#include <signal.h>
#include <fstream>
#include <time_util.h>

#include <iostream>

#include <BrokerC.h>
#include <BasicTaskKernelImpl.h>

#include "RTServerImpl.hh"
#include "RTServerWrapper.hh"

#include "RealTimeTaskImpl.hh"
#include "MaxDecayTaskAdvocate.hh"

using namespace std;

/**
 * Global data for the tool.
 */
static struct {
    /**
     * The CORBA ORB for this process.
     */
    CORBA::ORB_var orb;
    /**
     * The server object.
     */
    RTServerImpl *rtsi;
    /**
     * The manager for this machine.
     */
    Broker::Manager_var manager;
    /**
     * The task for this process.
     */
    Broker::RealTimeTask_var rtt;
} rts_data;

/**
 * Handle a signal by exiting cleanly.
 *
 * @param sig The actual signal received.
 */
static void sigexit(int sig)
{
    if( !CORBA::is_nil(rts_data.manager.in()) &&
        !CORBA::is_nil(rts_data.rtt.in()) )
    {
        rts_data.manager->RemoveTask(rts_data.rtt.in());
    }

    if( !CORBA::is_nil(rts_data.orb.in()) )
    {
        rts_data.orb->shutdown();
    }
    
    if( rts_data.rtsi != NULL )
    {
        delete rts_data.rtsi;
    }
    
    exit(EXIT_SUCCESS);
}

int main(int argc, char *argv[])
{
    int retval = EXIT_FAILURE;

#if defined(HAVE_ACE)
    /* Put a sock in ACE */
    ACE_Log_Msg::instance()->priority_mask(0, ACE_Log_Msg::PROCESS);
#endif

    {
        struct sigaction sa;
        sigset_t sigmask;
        
        sigemptyset(&sigmask);
        sigaddset(&sigmask, SIGINT);
        sigaddset(&sigmask, SIGTERM);
        sigaddset(&sigmask, SIGALRM);
        sa.sa_mask = sigmask;
        sa.sa_flags = 0;
        sa.sa_handler = sigexit;
        if( (sigaction(SIGINT, &sa, NULL) == -1) ||
            (sigaction(SIGTERM, &sa, NULL) == -1) )
        {
            ensure(0);
        }
    }
    
    try
    {
        /* Start up the ORB and */
        rts_data.orb = CORBA::ORB_init(argc, argv);

        CORBA::Object_var obj = rts_data.orb->
            resolve_initial_references("RootPOA");

        PortableServer::POA_var root_poa =
            PortableServer::POA::_narrow(obj.in());
        PortableServer::POAManager_var mgr = root_poa->the_POAManager();
        mgr->activate();

        quo::QuoKernel_var qk;
        
        try
        {
            /* ... check for an IOR from the Java QuOKernel. */
            obj = rts_data.orb->string_to_object("file://quoKernel.ior");
            qk = quo::QuoKernel::_narrow(obj.in());
            if( CORBA::is_nil(qk.in()) || qk->_non_existent() )
            {
                qk = quo::QuoKernel::_nil();
            }
        }
        catch(const CORBA::SystemException &e)
        {
            qk = quo::QuoKernel::_nil();
        }
        if( CORBA::is_nil(qk.in()) )
        {
            Qosket::Basic::BasicTaskKernelImpl *btki;
            
            /* ... no joy on Java QuOKernel, create our own. */
            btki = new Qosket::Basic::BasicTaskKernelImpl(rts_data.orb);
            qk = btki->_this();
        }

        /* Setup the argument defaults, */
        const char *manager_ior = "file://manager.ior";
        const char *obj_ior = "rtserver.ior";
        const char *period = "1s"; /* _must_ match period_ul */
        CORBA::ULong period_ul = 1000000; /* _must_ match period */
        struct {
            CORBA::ULong data[128];
            CORBA::ULong length;
        } compute = { { 0 }, 0 };
        const char *task_ior = NULL;
        const char *task_name = NULL;
        unsigned long run_time = 0;
        int lpc, ch, g2g = 1;

        /* ... parse the options, */
        while( ((ch = getopt(argc, argv, "hVm:t:n:P:f:o:")) != -1) && g2g )
        {
            switch( ch )
            {
            case 'm':
                manager_ior = optarg;
                if( strlen(manager_ior) == 0 )
                {
                    cerr << argv[0] << ": Manager IOR is empty" << endl;
                    throw CORBA::BAD_PARAM();
                }
                break;
            case 't':
                if( task_name != NULL )
                {
                    cerr << argv[0]
                         << ": The -n and -t options are mutually exclusive"
                         << endl;
                    throw CORBA::BAD_PARAM();
                }
                task_ior = optarg;
                if( strlen(task_ior) == 0 )
                {
                    cerr << argv[0] << ": Task IOR is empty" << endl;
                    throw CORBA::BAD_PARAM();
                }
                break;
            case 'n':
                if( task_ior != NULL )
                {
                    cerr << argv[0]
                         << ": The -n and -t options are mutually exclusive"
                         << endl;
                    throw CORBA::BAD_PARAM();
                }
                task_name = optarg;
                if( strlen(task_name) == 0 )
                {
                    cerr << "Task name is empty" << endl;
                }
                break;
            case 'P':
                {
                    unsigned long long period_ull;
                    
                    period = optarg;
                    if( string_to_microsec(&period_ull, period) )
                    {
                        period_ul = period_ull;
                    }
                    else
                    {
                        cerr << "Period value not a time: "
                             << period
                             << endl;
                        throw CORBA::BAD_PARAM();
                    }
                }
                break;
            case 'f':
                {
                    unsigned long long run_time_ull;
                    
                    if( string_to_microsec(&run_time_ull, optarg) )
                    {
                        run_time = run_time_ull;
                    }
                    else
                    {
                        cerr << argv[0]
                             << ": Run for value not a time: "
                             << period
                             << endl;
                        throw CORBA::BAD_PARAM();
                    }
                }
                break;
            case 'o':
                if( strlen(optarg) == 0 )
                {
                    cerr << argv[0]
                         << ": IOR output file name is empty"
                         << endl;
                    throw CORBA::BAD_PARAM();
                }
                obj_ior = optarg;
                break;
            case 'V':
                cout << PACKAGE_VERSION << endl;
                exit(0);
                break;
            case 'h':
            case '?':
            default:
                g2g = 0;
                break;
            }
        }

        /* ... parse the compute times, and */
        for( lpc = optind; lpc < argc; lpc++ )
        {
            unsigned long long compute_ull;

            if( compute.length >= 128 )
            {
                cerr << "Too many compute values." << endl;
                throw CORBA::BAD_PARAM();
            }
            else if( string_to_microsec(&compute_ull, argv[lpc]) )
            {
                compute.data[compute.length] = compute_ull;
                compute.length += 1;
            }
            else
            {
                cerr << "Compute value is not a time: "
                     << argv[lpc]
                     << endl;
                throw CORBA::BAD_PARAM();
            }
        }
        /* ... make sure we are good to go. */
        if( (task_ior == NULL) && (task_name == NULL) )
        {
            cerr << "No task name or IOR specified" << endl;
            g2g = 0;
        }
        if( g2g )
        {
            /* Set an alarm if there is a run time limit. */
            if( run_time > 0 )
            {
                struct itimerval itv;
                
                signal(SIGALRM, sigexit);
                itv.it_interval.tv_sec = 0;
                itv.it_interval.tv_usec = 0;
                itv.it_value.tv_sec = run_time / 1000000;
                itv.it_value.tv_usec = run_time % 1000000;
                if( setitimer(ITIMER_REAL, &itv, NULL) < 0 )
                {
                    perror("setitimer");
                }
            }

            /* Setup a default compute time if none was given. */
            if( compute.length == 0 )
            {
                for( lpc = 0; lpc < 15; lpc++, compute.length++ )
                {
                    compute.data[lpc] = period_ul / 4;
                }
                for( ; lpc < 20; lpc++, compute.length++ )
                {
                    compute.data[lpc] = period_ul / 2;
                }
            }

            /* Get a handle on the manager. */
            obj = rts_data.orb->string_to_object(manager_ior);
            rts_data.manager = Broker::Manager::_narrow(obj.in());
            if( CORBA::is_nil(rts_data.manager.in()) )
            {
                cerr << "Invalid manager IOR: "
                     << manager_ior
                     << endl;
                throw CORBA::BAD_PARAM();
            }

            /* Get a handle on the task or create one, and */
            if( task_ior != NULL )
            {
                obj = rts_data.orb->string_to_object(task_ior);
                rts_data.rtt = Broker::RealTimeTask::_narrow(obj.in());
                if( CORBA::is_nil(rts_data.rtt.in()) )
                {
                    cerr << "Invalid task factory IOR: "
                         << task_ior
                         << endl;
                    throw CORBA::BAD_PARAM();
                }
            }
            else if( task_name != NULL )
            {
                /* No existing object given, create a default. */
                try
                {
                    Broker::RealTimeTask_var rtt;
                    MaxDecayTaskAdvocate *mdta;
                    Broker::TaskParameters tp;
                    RealTimeTaskImpl *rtti;
                    CORBA::Any value;
                    
                    tp.length(1);
                    tp[0].name = "name";
                    tp[0].value <<= task_name;
                    rtti = new RealTimeTaskImpl(tp);
                    rtt = rtti->_this();
                    mdta = new MaxDecayTaskAdvocate();
                    value <<= rtt.in();
                    mdta->SetDelegateAttribute("remote-object", value);
                    rts_data.rtt = mdta->_this();
                }
                catch(const Broker::DuplicateTaskParameter &e)
                {
                    ensure(0);
                }
                catch(const Broker::InvalidTaskParameter &e)
                {
                    ensure(0);
                }
                catch(const Broker::MissingTaskParameter &e)
                {
                    ensure(0);
                }
            }
            else
            {
                ensure(0);
            }

            /* ... start scheduling for this process. */
            try
            {
                Broker::ScheduleParameters sp;
                
                sp.length(2);
                sp[0].name = "period";
                sp[0].value <<= period;
                sp[1].name = "pid";
                sp[1].value <<= (CORBA::Long)getpid();
                rts_data.manager->AddTask(rts_data.rtt.in(), sp);
            }
            catch(const Broker::DuplicateScheduleParameter &e)
            {
                cerr << e << endl;
                cerr << e.name << endl;
                throw CORBA::BAD_PARAM();
            }
            catch(const Broker::InvalidScheduleParameter &e)
            {
                cerr << e << endl;
                cerr << e.message << endl;
                throw CORBA::BAD_PARAM();
            }
            catch(const Broker::MissingScheduleParameter &e)
            {
                cerr << e << endl;
                cerr << e.name << endl;
                throw CORBA::BAD_PARAM();
            }

            /* Construct the actual server and */
            rts_data.rtsi = new RTServerImpl(period_ul,
                                             &compute.data[0],
                                             compute.length);
            RTServer_var real_rts;
            
            real_rts = rts_data.rtsi->_this();

            /* ... its wrapper. */
            RTServerWrapper *rtsw = new RTServerWrapper(rts_data.rtt.in(),
                                                        period_ul,
                                                        period_ul);
            RTServer_var rts;
            
            rts = rtsw->_this();
            
            rtsw->initSysconds(qk);
            rtsw->initCallbacks(rts_data.orb);
            rtsw->linkContract(qk);
            rtsw->linkRemoteObject(real_rts.in());

            /* Dump our IOR for the client to pickup later. */
            if( obj_ior != NULL )
            {
                ofstream ostr(obj_ior);
                ostr << rts_data.orb->object_to_string(rts.in()) << endl;
                ostr.close();
            }

            cout << "RT server ready, waiting for connection from rt_client..."
                 << endl;

            rts_data.orb->run();

            if( !CORBA::is_nil(rts_data.rtt.in()) )
            {
                rts_data.manager->RemoveTask(rts_data.rtt.in());
            }
                
            rts_data.orb->shutdown();

            retval = EXIT_SUCCESS;
        }
        else
        {
            /* Somethings wrong, print the usage. */
            cerr << "CORBA Server that exerts synthetic CPU load." << endl
                 << "Usage: "
                 << argv[0]
                 << " [options] [<compute-time1> <compute-time2> ...]\n"
                
                 << endl
                
                 << "  -m <ior>\tThe Broker::Manager IOR."
                 << "  (Default: " << manager_ior << ")" << endl
                
                 << "  -n <name>\tThe name of the task to create." << endl
                
                 << "  -t <ior>\tThe Broker::RealTimeTask IOR." << endl
                
                 << "  -o <file>\tThe file name for the object's IOR."
                 << "  (Default: " << obj_ior << ")" << endl
                
                 << "  -P <time>\tThe task's period."
                 << "  (Default: " << period << ")" << endl
                
                 << "  -f <time>\tThe amount of time to run for."
                 << "  (Default: forever)" << endl
                
                 << endl
                
                 << "Package: " << PACKAGE_STRING << endl
                 << "Contact: " << PACKAGE_BUGREPORT << endl;
        }
    }
    catch(const CORBA::SystemException &e)
    {
        cerr << "Caught Exception: " << e << endl;
    }
    catch(...)
    {
        cerr << "Caught an unhandled exception" << endl;
    }
    return( retval );
}

---