Echo client and server

The aim for this example is to run a client which accepts typed input and this is printed out on the server on stdout

The echo functionality is represented in the following very short IDL.

Example 5-1.


// MyFirstOrbit program - The Echo object
//
// All this does is pass a string from the
// client to the server.

interface Echo {
	void echoString(in string input);
};

The interface definition is the key part of the definition. Each interface defines an object which can have methods on it. In this case there is one method, which takes a string argument and returns nothing. The in declaration before the argument indicates that this arguments is only passed into the method. Generally all arguments are in arguments, for the first case.

This idl is found in the file echo.idl. To compile the idl one does the following steps: $ orbit-idl echo.idl

Echo client

The client code is shown here

Example 5-2.

/*
 * MyFirstOrbit program. Client. Hacked by Ewan Birney
 * birney@sanger.ac.uk from echo test suite.
 *
 */

#include "stdio.h"
#include "orb/orbit.h"

/*
 * This header file was generated from the idl
 */

#include "echo.h"

/*
 * This is our Echo Object
 */

Echo echo_client;

int
main (int argc, char *argv[])
{
    CORBA_Environment ev;
    CORBA_ORB orb;

    FILE * ifp;
    char * ior;
    char filebuffer[1024];

    /*
     * Standard initalisation of the orb. Notice that
     * ORB_init 'eats' stuff off the command line
     */

    CORBA_exception_init(&ev);
    orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", &ev);

    /*
     * Get the IOR (object reference). It should be written out
     * by the echo-server into the file echo.ior. So - if you
     * are running the server in the same place as the client,
     * this should be fine!
     */

    ifp = fopen("echo.ior","r");
    if( ifp == NULL ) {
      g_error("No echo.ior file!");
      exit(-1);
    }

    fgets(filebuffer,1024,ifp);
    ior = g_strdup(filebuffer);

    fclose(ifp);
    /*
     * Actually get the object. So easy!
     */

    echo_client = CORBA_ORB_string_to_object(orb, ior, &ev);
    if (!echo_client) {
	printf("Cannot bind to %s\n", ior);
	return 1;
    }

    /*
     * Ok. Now we use the echo object...
     */

    printf("Type messages to the server\n. as the only thing on the line stops\n");
    while( fgets(filebuffer,1024,stdin) ) {
      if( filebuffer[0] == '.' && filebuffer[1] == '\n' ) 
	break;

      /* chop the newline off */
      filebuffer[strlen(filebuffer)-1] = '\0';
      
      /* using the echoString method in the Echo object               */
      /* this is defined in the echo.h header, compiled from echo.idl */

      Echo_echoString(echo_client,filebuffer,&ev);

      /* catch any exceptions (eg, network is down) */

      if(ev._major != CORBA_NO_EXCEPTION) {
	printf("we got exception %d from echoString!\n", ev._major);
	return 1;
      }
    }
      
    /* Clean up */
    CORBA_Object_release(echo_client, &ev);
    CORBA_Object_release((CORBA_Object)orb, &ev);

    return 0;
}
The client can be broken down into three distinct sections.

The key part of the client is when it calls the echoString method on the server. The idl definition
     void echoString(in string input);
Ends up becoming the following definition in the echo.h header file generated from the idl
extern void Echo_echoString(Echo _obj, CORBA_char * astring, CORBA_Environment *ev);
This follows the accepted rules for Object based programming in C, that is

Of course, you don't have to follow this in your own code, but this is how the CORBA C mapping works, and it is not a bad solution.

Echo Server

The server is basically more complicated than the client, but has some commonality with the client. The server has to at the end of the day go into a main loop where it listens to connections. Before that it has to create the orb and bind its own implementations of the objects to the orb.

In real life servers, this gets much more complicated, but as this is an example, it is pretty simple once you get through the orb initialisation process


/*
 * MyFirstOrbit program - server. Hacked
 * from Echo test suite by birney@sanger.ac.uk
 */

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "signal.h"
#include "orb/orbit.h"
#include "echo.h"

/* This is so we can get out a valid IOR later... */
Echo echo_client = CORBA_OBJECT_NIL;

/* declaration of the meat of the process*/
static void
do_echoString(PortableServer_Servant servant,
	      CORBA_char *astring,
	      CORBA_Environment *ev);

/*
 * I have **no** idea what this bit does
 */
PortableServer_ServantBase__epv base_epv = {
  NULL,
  NULL,
  NULL
};
POA_Echo__epv echo_epv = { NULL, do_echoString };
POA_Echo__vepv poa_echo_vepv = { &base_epv, &echo_epv };
POA_Echo poa_echo_servant = { NULL, &poa_echo_vepv };

int
main (int argc, char *argv[])
{
    PortableServer_ObjectId objid = {0, sizeof("myEchoString"), "myEchoString"};
    PortableServer_POA poa;

    CORBA_Environment ev;
    char *retval;
    CORBA_ORB orb;
    FILE * ofp;

    signal(SIGINT, exit);
    signal(SIGTERM, exit);

    CORBA_exception_init(&ev);
    orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", &ev);

    POA_Echo__init(&poa_echo_servant, &ev);

    poa = (PortableServer_POA)CORBA_ORB_resolve_initial_references(orb, "RootPOA", &ev);
    PortableServer_POAManager_activate(PortableServer_POA__get_the_POAManager(poa, &ev), &ev);
    PortableServer_POA_activate_object_with_id(poa,
					       &objid, &poa_echo_servant, &ev);

    echo_client = PortableServer_POA_servant_to_reference(poa,
							  &poa_echo_servant,
							  &ev);
    if (!echo_client) {
	printf("Cannot get objref\n");
	return 1;
    }

    retval = CORBA_ORB_object_to_string(orb, echo_client, &ev);

    ofp = fopen("echo.ior","w");

    fprintf(ofp,"%s", retval);
    fclose(ofp);

    CORBA_free(retval);

    fprintf(stdout,"Written the file echo.ior with the IOR of this server.\n Now waiting for requests...\n");
    fflush(stdout);
    CORBA_ORB_run(orb, &ev);

    return 0;
}

static void
do_echoString(PortableServer_Servant servant,
	      CORBA_char *astring,
	      CORBA_Environment *ev)
{
  g_message("[server] %s", astring);
  return;
}
More stuff on the server here by someone who understands