CORBA_quo.java

Go to the documentation of this file.

/*
 * CORBA_quo.java
 *
 * 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 CORBA_quo.java
 *
 * Contains a QuO enabled communications model for the ATR.
 */

import java.io.*;

import imagerec.corba.CORBA;

import FrameManip.Frame;

import org.omg.CORBA.ORB;
import org.omg.CORBA.Policy;
import org.omg.PortableServer.POA;
import org.omg.PortableServer.POAHelper;
import org.omg.PortableServer.Servant;
import org.omg.PortableServer.ThreadPolicy;
import org.omg.PortableServer.ThreadPolicyValue;

import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper;
import org.omg.CosNaming.NameComponent;

import omg.org.CosPropertyService.Property;

import imagerec.graph.ImageData;

import imagerec.util.ImageDataManip;

import com.bbn.quo.*;
import com.bbn.quo.corba.*;

import Broker.Manager;
import Broker.NamedValue;
import Broker.TaskFactory;
import Broker.RealTimeTask;

import unix.Process;

/**
 * A CORBA CommunicationsModel for the ATR that includes support for QuO.
 */
public class CORBA_quo
    extends CORBA
{
    /**
     * Load some native libraries.
     */
    static {
        System.loadLibrary("JavaUnixUtils"); // XXX grr stupid!
    }

    /**
     * Convert a file:// style IOR into an IOR: style one.
     *
     * XXX Technically, this shouldn't be needed.
     *
     * @param ior An IOR to parse and optionally convert.
     * @return An IOR that JacORB will like.
     */
    private static String readFileIOR(String ior)
    {
        String retval = null;
        
        if( ior.startsWith("file://") )
        {
            try
            {
                String filename = ior.substring(7);
                byte bits[];
                
                bits = new byte[(int)new File(filename).length()];
                new FileInputStream(filename).read(bits);
                retval = new String(bits);
            }
            catch(FileNotFoundException e)
            {
                e.printStackTrace();
            }
            catch(IOException e)
            {
                e.printStackTrace();
            }
        }
        else
        {
            retval = ior;
        }
        return retval;
    }

    /**
     * The IOR for the Broker::Manager object.
     */
    private static final String MANAGER_IOR =
        readFileIOR(System.getProperty("edu.utah.broker.manager",
                                       "file://manager.ior"));

    /**
     * The IOR for the Broker's QuoKernel object.
     */
    private static final String QUO_KERNEL_IOR =
        readFileIOR(System.getProperty("edu.utah.broker.quo-kernel",
                                       "file://quoKernel.ior"));

    /**
     * The IOR for the Broker::TaskFactory object.
     */
    private static final String TASK_IOR =
        readFileIOR(System.getProperty("edu.utah.broker.task"));

    /**
     * Arguments to the ORB.
     */
    private String args[];

    /**
     * The main ORB object.
     */
    private ORB orb;

    /**
     * Construct a CORBA_quo object.
     *
     * @param args The arguments to the ORB.
     */
    public CORBA_quo(String args[])
    {
        super(args);
        
        this.args = args;
        this.orb = ORB.init(args, null);
    }

    /**
     * Attach the given Servant object to the ORB and interpose it with a
     * broker delegate.
     *
     * @param name The name of the object.
     * @param servant The servant to activate.
     */
    protected void runServer(String name, final Servant servant)
        throws Exception
    {
        POA root_poa;

        /* Standard init stuff... */
        root_poa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
        root_poa.the_POAManager().activate();

        /* Make sure requests are single threaded. */
        ThreadPolicy thread =
            root_poa.create_thread_policy(ThreadPolicyValue.
                                          SINGLE_THREAD_MODEL);

        POA poa = root_poa.create_POA("SingleThread",
                                      root_poa.the_POAManager(),
                                      new Policy[] {
                                          thread
                                      });

        /* Activate the real object and */
        poa.activate_object(servant);

        /* ... add it to the NameService, but prefix the name with 'real_'. */
        NamingContextExt namingContext = namingContext(orb);
        namingContext.rebind(namingContext.to_name("real_" + name),
                             poa.servant_to_reference(servant));
        
        RealTimeTask rtt;
        Manager manager;
        QuoKernel qk;

        /* Get references to the broker objects. */
        qk = QuoKernelHelper.
            narrow(this.orb.string_to_object(QUO_KERNEL_IOR));
        
        rtt = Broker.RealTimeTaskHelper.
            narrow(this.orb.string_to_object(TASK_IOR));

        manager = Broker.ManagerHelper.
            narrow(this.orb.string_to_object(MANAGER_IOR));

        org.omg.CORBA.Any period_any = orb.create_any();
        period_any.insert_string("500ms");
        
        org.omg.CORBA.Any pid_any = orb.create_any();
        pid_any.insert_long(Process.getProcessID());

        manager.AddTask(rtt, new NamedValue[] {
            new NamedValue("period", period_any),
            new NamedValue("pid", pid_any),
        });
        
        ATRWrapper aw = new ATRWrapper(rtt, 500000, 500000);

        /* Wire everything up. */
        aw.initSysconds(qk);
        aw.initCallbacks();
        aw.linkContract(qk);
        aw.linkRemoteObject(FrameManip.ProcessorHelper.
                            narrow(servant._this_object()));
        
        poa.activate_object(aw);

        try
        {
            ImageData id;

            id = ImageDataManip.create((int)0, (long)0);
            aw.process(new Frame(id.time,
                                 new Property[0],
                                 id.header,
                                 ImageDataManip.writePPM(id)));
        }
        catch(Throwable th)
        {
            System.gc();
            System.gc();
        }

        /* Register with the NameService, this time, using the real name. */
        namingContext.rebind(namingContext.to_name(name),
                             poa.servant_to_reference(aw));
        
        orb.run();
    }
}

---