Stringified Object References

 

The example in section 3.3.2 already used the ORB methods object_to_string() and string_to_object() to make a stringified representation of an object reference and to turn back this string into an object, respectively.

When separating client and server you have to find a way to transmit the stringified object reference from the server to the client. If client and server run on machines that share a single file system you can make the server write the string into a file which is read by the client. Here is how to do it:

 1: // file account_server.cc
 2:
 3: #include <iostream.h>
 4: #include <fstream.h>
 5: #include "account.h"
 6: 
 7: class Account_impl : virtual public Account_skel
 8: {
 9:   // unchanged, see section "MICO Application"
10:   // ...
11: };
12: 
13: 
14: int main( int argc, char *argv[] )
15: {
16:   // ORB initialization
17:   CORBA::ORB_var orb = CORBA::ORB_init( argc, argv, "mico-local-orb" );
18:   CORBA::BOA_var boa = orb->BOA_init( argc, argv, "mico-local-boa" );
19: 
20:   Account_impl* server = new Account_impl;
21:   CORBA::String_var ref = orb->object_to_string( server );
22:   ofstream out ("/tmp/account.objid");
23:   out << ref << endl;
24:   out.close ();
25:
26:   boa->impl_is_ready( CORBA::ImplementationDef::_nil() );
27:   orb->run ();
28:   CORBA::release( server );
29:   return 0;
30: }

Account_impl, the implementation of the account object in lines 7-11 is the same as in section 3.3.2. The main() function performs ORB and BOA initialization in lines 16-18, which will evaluate and remove CORBA specific command line options from argv, see section 4.1.1 for details. In line 20 an account object is created, lines 21-24 obtain a stringified object reference for this object and write it to a file called account.objid.

In line 26 the impl_is_ready() method of the BOA is called to activate the objects implemented by the server. The ORB method run(), which is invoked in line 27 will enter a loop to process incoming invocations. Just before returning from main(), CORBA::release() is used in line 28 to destroy the account server object.

 1: // file account_client.cc
 2:
 3: #include <iostream.h>
 4: #include <fstream.h>
 5: #include "account.h"
 6: 
 7: int main( int argc, char *argv[] )
 8: {
 9:   // ORB initialization
10:   CORBA::ORB_var orb = CORBA::ORB_init( argc, argv, "mico-local-orb" );
11:   CORBA::BOA_var boa = orb->BOA_init( argc, argv, "mico-local-boa" );
12:
13:   ifstream in ("/tmp/account.objid");
14:   char ref[1000];
15:   in >> ref;
16:   in.close ();
17:
18:   CORBA::Object_var obj = orb->string_to_object (ref);
19:   Account_var client = Account::_narrow( obj );
20: 
21:   client->deposit( 700 );
22:   client->withdraw( 250 );
23:   cout << "Balance is " << client->balance() << endl;
24:
25:   return 0;
26: }

After ORB and BOA initialization the client's main() function reads the stringified object reference in lines 13-16 and turns it back into an account object stub in lines 18-19. After making some method invocations in lines 21-23 client will be destroyed automatically because we used and Account_var smart pointer.

Compile the client and server programs like this:

  mico-c++ -I. -c account_server.cc -o account_server.o
  mico-c++ -I. -c account_client.cc -o account_client.o
  mico-c++ -I. -c account.cc -o account.o
  mico-ld -o server account_server.o account.o -lmico2.2.3
  mico-ld -o client account_client.o account.o -lmico2.2.3

First run server and then client in a different shell. The output from client will look like this:

  Balance is 450

Note that running the client several times without restarting the server inbetween will increase the balance the client prints out by 450 each time! You should also note that client and server do not necessarily have to run on the same machine. The stringified object reference, which is written to a file called /tmp/account.objid, contains the IP address and port number of the server's address. This way the client can locate the server over the network. The same example would also work in a heterogeneous environment. In that case you would have to compile two versions of account.o, one for each hardware architecture. But the conversion of the parameters due to different data representations is taken care of by MICO.