ORBit Beginners Documentation
<<< PreviousFirst CORBA ProgramsNext >>>

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 1. Echo IDL file


// 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 2. Echo client C source

/*
 * 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,1023,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.

The echo client as a Perl script

(by Brent Baccala <baccala@freesoft.org>)

The echo client can also be written in Perl. Download and install the CORBA::ORBit package from CPAN (http://www.cpan.org/). Then you can load the same IDL file you used for C into Perl, and load the server's CORBA address from the echo.ior file, and call the CORBA server just like a Perl subroutine: 
#!/usr/bin/perl -w
#
# Sample Perl code (using Owen Taylor's CORBA::ORBit package)
# to interface with Echo server

use CORBA::ORBit idl => [ qw(echo.idl) ];

use Error qw(:try);

use strict;



my $orb = CORBA::ORB_init("orbit-local-orb");

open IOR, "echo.ior";
my $ior = <IOR>;
close IOR;

my $echo = $orb->string_to_object($ior);

print "Type messages to the server\n";
print "End of file (CNTL-D) stops\n";

while (<>) {
    chop;
        $echo->echoString($_);
}

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);

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;
}
In this code, the PortableServer_ServantBase__epv base_epvis the base servant epv. The first NULL refers to _privatedata, the second one to finalizing routine and the third one to the default_POA routine. We don't really care about it so we just leave them NULL. The POA_Echo__epv echo_epv = {...};part refers to something we do care about - table of our methods. These come in the order in which they were defined in the idl file.
<<< PreviousHomeNext >>>
Files at a glanceUpCalculator Client Server