broker_allup.cc

Go to the documentation of this file.

/*
 * broker_allup.cc
 *
 * Copyright (c) 2003 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 broker_allup.cc
 *
 * Main file for an edu::utah::pces::Allup server.
 */

#include "config.h"

#include <stdlib.h>
#include <signal.h>

#include <sys/time.h>

#include <assert.h>
#include <assert_pp.h>

#if defined(HAVE_LIBRK)
#include <rk/rk.h>
#include <rk/rk_error.h>
#endif

#include <iostream>

#include <AllupImpl.hh>

using namespace std;

/**
 * Global data for the server.
 *
 * ba_ResourceSet - The resource set for this process.
 */
static struct {
    const char *ba_IORFileName;
#if defined(HAVE_LIBRK)
    rk_resource_set_t ba_ResourceSet;
#endif
} ba_data;

/**
 * Signal handler for 
 *
 * @param sig The actual signal number received.
 */
static void sig_exit_handler(int sig)
{
#if defined(HAVE_LIBRK)
    if( ba_data.ba_ResourceSet != NULL_RESOURCE_SET )
    {
        rk_resource_set_destroy(ba_data.ba_ResourceSet);
    }
#endif
    exit(EXIT_SUCCESS);
}

/**
 * Print out the usage statement to standard error.
 *
 * @param prog_name The program name.
 */
static void baUsage(const char *prog_name)
{
    require(prog_name != NULL);

    cerr << "Server for CPU broker objects." << endl
         << "Usage: "
         << prog_name
         << " [options]\n"
         << endl
         << "Options:\n"
         << "  -h\t\tThis help message.\n"
         << "  -V\t\tShow the version number.\n"

         << "  -o\t\tThe IOR file name. (Default: "
         << ba_data.ba_IORFileName << ")" << endl

         << endl
        
         << "Package: " << PACKAGE_STRING << endl
         << "Contact: " << PACKAGE_BUGREPORT << endl

        ;
}

/**
 * Process the command line options.
 *
 * @param argc_inout Reference to main's argc variable.  On return, the
 * variable will contain the number of arguments remaining after option
 * processing.
 * @param argv_inout Reference to main's argv variable.  On return, the
 * variable will contain the remaining argument values.
 * @return True if the options were processed correctly, false otherwise.
 */
static int baProcessOptions(int &argc_inout, char **&argv_inout)
{
    int ch, retval = 0;
    char *prog_name;
    char **argv;
    int argc;
    
    argc = argc_inout;
    argv = argv_inout;
    prog_name = argv[0];
    while( ((ch = getopt(argc, argv, "hVo:")) != -1) && (retval == 0) )
    {
        switch( ch )
        {
        case 'o':
            if( strlen(optarg) == 0 )
            {
                cerr << "Empty IOR file name" << endl;
                retval = 1;
            }
            else
            {
                ba_data.ba_IORFileName = optarg;
            }
            break;
        case 'V':
            cerr << PACKAGE_VERSION << endl;
            retval = -1;
            break;
        case 'h':
        case '?':
        default:
            retval = 1;
            break;
        }
    }
    argc_inout -= optind;
    argv_inout += optind;
    return( retval );
}

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

    /* Default values. */
    ba_data.ba_IORFileName = "allup.ior";
    
    signal(SIGINT, sig_exit_handler);
    signal(SIGTERM, sig_exit_handler);
    
#if defined(HAVE_ACE)
    /* Put a sock in ACE */
    ACE_Log_Msg::instance()->priority_mask(0, ACE_Log_Msg::PROCESS);
#endif

#if defined(HAVE_LIBRK)
    {
        char set_name[RK_NAME_LEN];
        rk_resource_set_t rs;

        snprintf(set_name, sizeof(set_name),
                 "allup.%d",
                 getpid());
        if( rk_proc_get_rset(getpid()) != NULL_RESOURCE_SET )
        {
            /* Already have a resource set. */
        }
        else if( (rs = rk_resource_set_create(set_name)) != NULL )
        {
            struct cpu_reserve_attr cra;
            rk_reserve_t cr;
            
            memset(&cra, 0, sizeof(cra));
            cra.compute_time.tv_sec = 0;
            cra.compute_time.tv_nsec = 100000;
            cra.period.tv_sec = 0;
            cra.period.tv_nsec = 500000000;
            cra.deadline = cra.period;
            cra.reserve_type.sch_mode = RSV_SOFT;
            cra.reserve_type.enf_mode = RSV_SOFT;
            cra.reserve_type.rep_mode = RSV_SOFT;
            cra.processor = RK_ANY_CPU;
            if( (rk_cpu_reserve_create(rs, &cr, &cra) == RK_SUCCESS) &&
                (rk_resource_set_attach_process(rs, getpid()) == RK_SUCCESS) )
            {
                ba_data.ba_ResourceSet = rs;
            }
            else
            {
                rk_resource_set_destroy(rs);
            }
        }
        else
        {
            perror("rk_resource_set_create");
        }
    }
#endif
    
    try
    {
        int rc;
        
        /* ORB/POA setup */
        CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
        CORBA::Object_var obj = 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();
        
        PortableServer::ThreadPolicy_var thread = root_poa->
            create_thread_policy(PortableServer::SINGLE_THREAD_MODEL);
        
        CORBA::PolicyList policy_list;
        policy_list.length(1);
        policy_list[0] = PortableServer::ThreadPolicy::_duplicate(thread.in());
        
        PortableServer::POA_var st_poa = root_poa->
            create_POA("SingleThread",
                       PortableServer::POAManager::_nil(),
                       policy_list);
        
        thread->destroy();

        rc = baProcessOptions(argc, argv);
        if( rc == 0 )
        {
            edu::utah::pces::Allup_var allup;
            AllupImpl *ai;
            
            ai = new AllupImpl();
            allup = ai->_this();
            
            {
                ofstream ostr(ba_data.ba_IORFileName);
                
                ostr << orb->object_to_string(allup.in()) << endl;
                ostr.close();
            }
        
            orb->run();
        }
        else
        {
            if( rc >= 0 )
            {
                baUsage(prog_name);
            }
        }
        
        orb->shutdown();
    }
    catch(const CORBA::SystemException &e)
    {
        cerr << "Caught CORBA exception: " << e << endl;
    }
    catch(...)
    {
        cerr << "Caught unknown exception..." << endl;
    }
    
#if defined(HAVE_LIBRK)
    sig_exit_handler(0);
#endif
    
    return( retval );
}

---