ServerMain_T.hh

Go to the documentation of this file.

/*
 * ServerMain_T.hh
 *
 * 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 ServerMain_T.hh
 *
 * Contains a function template for setting up and running a single object
 * server.
 */

#ifndef _server_main_t_hh
#define _server_main_t_hh

#include "config.h"

#include <unistd.h>

#include <iostream>

#include <assert_pp.h>

#include <BrokerC.h>

#include "NamingHelper_T.h"

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

/*
 * The ServerMainDefaults structure is used to specify the default values for
 * any command line arguments recognized by the server.
 *
 * smd_Name - The name of the object in the NamingService.
 * smd_IOR - The name of the file that the IOR should be stored in or NULL if
 *           no file should be written.
 */
struct ServerMainDefaults {
    const char *smd_Name;
    const char *smd_IOR;
};

/*
 * The ServerMainData structure holds any global data for the program.
 */
struct ServerMainData {
#if defined(HAVE_LIBRK)
    rk_resource_set_t smd_ResourceSet;
#endif
} server_main_data;

/**
 * Handler for SIGINT/SIGTERM signals.
 *
 * @param sig The actual signal received.
 */
void sigexit_handler(int sig)
{
    require((sig == SIGINT) || (sig == SIGTERM));
    
#if defined(HAVE_LIBRK)
    if( server_main_data.smd_ResourceSet != NULL )
    {
        rk_resource_set_destroy(server_main_data.smd_ResourceSet);
    }
#endif
    exit(EXIT_SUCCESS);
}

/**
 * Output the usage message for this program to standard error.
 *
 * @param prog_name The program name, as given on the command line.
 * @param smd The default values for this program.
 */
void server_main_usage(char *prog_name, struct ServerMainDefaults &smd)
{
    require(prog_name != NULL);
    
    cerr << "Usage: " << prog_name << " [options]" << endl

         << endl

         << smd.smd_Name << " object server." << endl

         << endl

         << "Options:" << endl

         << "\t-h\t\tThis help message." << endl

         << "\t-n <name>"
         << "\tThe name for the object in the NamingService. "
         << "(default: " << smd.smd_Name << ")" << endl
        
         << "\t-o <ior file>"
         << "\tThe IOR output file. "
         << "(default: "
         << (smd.smd_IOR == NULL ? "<none>" : smd.smd_IOR)
         << ")" << endl;
}

/**
 * Template function for a server that exports a single object.
 *
 * @param T The object implementation class.  The constructor is expected to
 *          take a 'const char *' argument that contains the object name.
 * @param U The object's _var smart pointer class.
 * @param smd The defaults for the command line parameters.
 * @param argc The argc passed to the real main.
 * @param argv The argv passed to the real main.
 * @return EXIT_FAILURE or runs for forever.
 */
template <class T, class U> int server_main(struct ServerMainDefaults &smd,
                                            int argc,
                                            char *argv[])
{
    int retval = EXIT_FAILURE;

    require(smd.smd_Name != NULL);
    require(smd.smd_IOR != NULL);
    require(argc > 1);
    require(argv != NULL);

    signal(SIGINT, sigexit_handler);
    signal(SIGTERM, sigexit_handler);
    try
    {
        /* ORB 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();

        /* Get the NamingService. */
        CosNaming::NamingContext_var nc;
        
        nc = NamingHelper<CosNaming::NamingContext>::
	    resolve_init(orb.in(), "NameService");

        if( !CORBA::is_nil(nc.in()) )
        {
            const char *obj_name = smd.smd_Name;
            const char *obj_ior = smd.smd_IOR;
            int ch;

            retval = EXIT_SUCCESS;
            while( ((ch = getopt(argc, argv, "hn:o:")) != -1) &&
                   (retval == EXIT_SUCCESS) )
            {
                switch( ch )
                {
                case 'n':
                    break;
                case 'o':
                    break;
                case 'h':
                case '?':
                default:
                    server_main_usage(argv[0], smd);
                    retval = EXIT_FAILURE;
                    break;
                }
            }

            if( retval == EXIT_SUCCESS )
            {
#if defined(HAVE_LIBRK)
                {
                    rk_resource_set_t rs;
                
                    if( (rs = rk_resource_set_create(obj_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 = 10000000;
                        cra.period.tv_sec = 1;
                        cra.period.tv_nsec = 0;
                        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) )
                        {
                            server_main_data.smd_ResourceSet = rs;
                        }
                        else
                        {
                            rk_resource_set_destroy(rs);
                        }
                    }
                    else
                    {
                        perror("rk_resource_set_create");
                    }
                }
#endif
                
                /* Create our object. */
                T *spi = new T(obj_name);
                U sobj;
                
                PortableServer::ObjectId_var oid = st_poa->
                    activate_object(spi);
                
                sobj = spi->_this();
                
                /* Write out the IOR, if they so desire. */
                if( obj_ior != NULL )
                {
                    ofstream ostr(obj_ior);
                    ostr << orb->object_to_string(sobj.in()) << endl;
                    ostr.close();
                }
                
                /* Register with the NamingService. */
                CosNaming::Name name;
                
                name.length(1);
                name[0].id = CORBA::string_dup(obj_name);
                name[0].kind = CORBA::string_dup("");
                
                nc->rebind(name, sobj.in());
                
                /* Light the candle! */
                orb->run();
                
                /* Candle in the wind... */
                orb->shutdown();
                
#if defined(HAVE_LIBRK)
                if( server_main_data.smd_ResourceSet != NULL )
                {
                    rk_resource_set_destroy(server_main_data.smd_ResourceSet);
                }
#endif
            }
        }
        else
        {
            cerr << "Could not find name service!" << endl;
        }
    }
    catch(const CORBA::SystemException &e)
    {
        cerr << "Caught Exception: " << e << endl;
    }
    catch(...)
    {
        cerr << "Caught an unhandled exception" << endl;
    }

    return( retval );
}

#endif

---