What is ROBIN?

ROBIN is a freeware, CORBA-2.1-based ORB with additional support for:

ROBIN simplifies CORBA, using an architecture like this:

Object Adapters and the DSI are not supported, because they are not needed. Instead, ROBIN implements a dynamic server-side ORB which invokes static skeletons directly. These are true skeletons; the user simply adds code in the marked places to complete them.

ROBIN's CORBA Simplifications

Notice that CORBA says nothing about constructors, generally requiring the "4-step program":

  1. On the server, obtain a reference for the desired object:
    ref = CORBA::BOA::create(..)

  2. "Stringify" it:
    str = CORBA::ORB::object_to_string(ref)

  3. Somehow copy the string to the client

  4. The client then uses:
    obj = CORBA::ORB::string_to_object(str)

Difficult, error-prone, and NOT scalable! Why not just use constructors? ROBIN defines constructors, on both client and service side:

This does NOT limit flexibility - "construction" of a CORBA object does not imply that a new instance of the REAL object must be created each time (the CORBA object could be a "front end" to a controlled set of real objects).

ROBIN Client-side Constructors

C:

"ROBIN" C++:

Unofficial Java Mapping:

Official Java Mapping:

ROBIN Server-side Constructors

C:

ROBIN's IDL compiler generates code to malloc() space for the interface's attributes and some internal data. Implementor can add further "construction" code. The returned pointer serves as the "registration" mechanism; returning anything other than NULL registers the object.

Implementations must be linked as shared libraries (DSOs on UNIX; DLLs on Windows) and use specific filenames. This allows the ROBIN server to automatically activate them.

ROBIN ORB IDs

Another thing left "wide open" in the CORBA spec is the definition of ORB ID: it is a string specifying what ORB to use. ROBIN is a bit more precise - an ORB ID specifies:

It can also have special tags for:

ROBIN's Load Balancing

ROBIN's interpretation of ORB IDs allows support for rudimentary load-balancing. When constructing a new object with a multicast group as the ORB ID:

ROBIN's Redundancy

Building on part of the load-balancing mechanism, ROBIN also supports redundancy. Each server which registers in a multicast group can be given a "ROBIN group number" from 1 to 4. When constructing a new object with a multicast group as the ORB ID and using 2 ROBIN groups:

ROBIN Features

ROBIN 2.3's other features include:

ROBIN 2.4 (due any day now...) adds:

The Road ahead...

ROBIN 2.5 plans:

There are NO plans for:

Example C Client


main( argc, argv )
  int argc;
  char **argv;
  {
  int our_argc;
  char server[64];
  CORBA_Object ourADMEM;
  CORBA_Environment env;
  long status;
  long constants[8192];
  .
  .
  /* get a copy of argc so we can pass its address */
  our_argc = argc;
  .
  /* hard-wire the server to use */
  strcpy( server, "b0sgh.fnal.gov" );
  .
  /* construct the object */
  ourADMEM = CDFonline_ADMEM__alloc( &our_argc, argv, server, &env );
  .
  /* set detector to COT */
  CDFonline_ADMEM__set_DetectorSubsystem( ourADMEM, "COT" );
  .
  .
  /* do our stuff */
  status = CDFonline_ADMEM_Initialize( ourADMEM, 1, &env );
  status = CDFonline_ADMEM_Calibrate( ourADMEM, constants, &env );
  .
  .
  /* destroy the object */
  CDFonline_ADMEM__free( ourADMEM, &env );
  }

Example C++ Client


main( argc, argv )
  int argc;
  char **argv;
  {
  int our_argc;
  char server[64];
  CDFonline_ADMEM *ourADMEM;
  CORBA_Environment env;
  long status;
  long constants[8192];
  .
  .
  // get a copy of argc so we can pass its address
  our_argc = argc;
  .
  // hard-wire server to use
  strcpy( server, "b0sgh.fnal.gov" );
  .
  // construct object
  ourADMEM = new CDFonline_ADMEM( &our_argc, argv, server, &env );
  .
  // set detector to COT
  ourADMEM->DetectorSubsystem( "COT" );
  .
  .
  // do our stuff
  status = ourADMEM->Initialize( 1 );
  status = ourADMEM->Calibrate( constants );
  .
  .
  // destroy object
  delete ourADMEM;
  }

Example Java Client


import omg.corba.*;
import CDFonline.*;

public class CORBAtest {
  .
  .
  public void main( String args[] ) {
    CDFonline.ADMEM ourADMEM;
    int status;
    int constants[8192];
    .
    .
    // hard-wire server to use
    String server = "b0sgh.fnal.gov";
    .
    try {
      // construct object
      ourADMEM = new CDFonline.ADMEM( args, server );
      .
      // set detector to COT
      ourADMEM.DetectorSubsystem( "COT" );
      .
      .
      // do our stuff
      status = ourADMEM.Initialize( 1 );
      status = ourADMEM.Calibrate( constants );
      .
      } catch( omg.corba.CORBAException exc ) {
      System.out.println( "Something went wrong!" );
      }
    }
  }