Contents

7.1 Object Identification

7.1.1 OrbixWeb Object References

7.1.2 Interoperable Object References

7.1.3 Assigning Markers to OrbixWeb Objects

7.2 Making Object References Available to Clients

7.2.1 Publishing Object References using the Naming Service

7.1 Object Identification

OrbixWeb supports two protocols for communications between distributed applications: the Orbix protocol and the CORBA standard Internet Inter-ORB Protocol (IIOP) for interoperability between different ORB implementations. IIOP is the default protocol and is described in detail in Chapter 9, "ORB Interoperability". Each of the two available protocols requires a different object reference format; the Orbix protocol requires an OrbixWeb object reference format and IIOP requires the CORBA Interoperable Object Reference (IOR) format. In this section, we will introduce each type of object reference and describe how a programmer may use the fields of an object reference.

If an application wishes to bind to an object, then it must have a mechanism for obtaining the information stored in the object reference. There are several ways for a server to make this information available, and these will be discussed in section 7.2.

7.1.1 OrbixWeb Object References

• An object name which, together with the object's interface name, is unique within its server. We refer to this name as the object's marker.
  
• Its server name. This is sometimes called an implementation name in CORBA terminology.
  
• The host name of its server.
  

In more detail, an OrbixWeb object reference is fully specified by the following fields:

• Object marker.
  
• Server name.
  
• Server host.
  
• IDL interface type of the object.
  
• Interface Repository (IR) server in which the definition of this interface is stored.
  
• IR server host.
  

:\server_host:server_name:marker:IR_host:IR_server:IDL_interface

_ObjectRef also provides access to the individual fields of an object reference string via the following set of accessor methods:

 // Java
 // in package IE.Iona.Orbix2.CORBA,
 // in interface _ObjectRef.
 public String _host();
 public String _implementation();
 public String _marker();
 public String _interfaceHost();
 public String _interfaceImplementation();
 public String _interfaceMarker();

7.1.2 Interoperable Object References

An IOR is managed internally by the interoperating ORBs–it is not necessary for an application programmer to know the structure of an IOR. However, an application may wish to publish the stringified form of an object's IOR. In OrbixWeb, the stringified IOR can be by obtained calling the method _object_to_string() on the required object, passing the value IE.Iona.Orbix2._CORBA.IT_INTEROPERABLE_OR_KIND as a parameter.

7.1.3 Assigning Markers to OrbixWeb Objects

An object which has a user-specified name or a name assigned by OrbixWeb may be renamed using the modifier method _marker(String) which is defined on the interface _ObjectRef, in package IE.Iona.Orbix2.CORBA and is available on every OrbixWeb object.

The marker name associated with an object may be found using the accessor method _marker(). The following code demonstrates the use of this method:

 // Java
 import IE.Iona.Orbix2.CORBA.SystemException;
 ...
 
 _AccountRef aRef;
 
 try {
 	aRef = new _tie_Account
 		(new AccountImplementation ());
 	System.out.println ("The marker name chosen " +
 		"by OrbixWeb is " + aRef._marker ());
 }
 catch (SystemException se) {
 	...
 }

• Passing a marker name to the second parameter (of type String) of a TIE-class constructor. For example:
  

   // Java
   import IE.Iona.Orbix2.CORBA.SystemException;
   ...
   
   _BankRef bRef;
   
   try {
   	bRef = new _tie_Bank 
   		(new BankImplementation (), "College_Green");
   }
   catch (SystemException se) {
   	...
   }
  

• Passing a marker name to the first parameter (of type String) of a BOAImpl-class constructor. For example:
  

   // Java
   // Constructor definition in implementation class:
   import IE.Iona.Orbix2.CORBA.SystemException;
   ...
   
   public class BankImplementation
   	extends _boaimpl_Bank {
   
   	BankImplementation (String marker)
   		throws SystemException {
   		super (marker);
   	}
   }
   
   // Usage in server class:
   import IE.Iona.Orbix2.CORBA.SystemException;
   ...
   
   BankImplementation bankImpl;
   
   try {
   	bankImpl = new BankImplementation 
   		("College Green");
   }
   catch (SystemException se) {
   	...
   }
  

Marker names cannot contain the character `:' and cannot contain the null character.

An object's interface name together with its marker name must be unique within a server. If a chosen marker is already in use when an object is named, OrbixWeb will (silently) assign a different marker to the object (and the object with the original marker will be unaffected). There are two ways to test for this, depending on how a marker is assigned to an object:

• If _marker(String) is used, the programmer can test for a false return value (a false return value indicates a name clash).
  
• If the marker is assigned when calling a TIE-class or a BOAImpl-class constructor, then the server programmer can test for a name clash by calling the accessor method _marker() (with takes no parameters) on the new object and comparing the marker with the one the programmer tried to assign.
  

• Use an OrbixWeb daemon process to manage the server. This can be done by registering the server in the Implementation Repository, or by configuring the OrbixWeb daemon to allow unregistered servers and specifying the server name in a call to impl_is_ready(). Either approach allows clients to obtain references to server objects using the OrbixWeb _bind() method, which does not require all the object reference field values to be specified.
  
• Pass the object reference from the server to the client as a parameter to an IDL operation. When the object reference enters the client's address space, OrbixWeb will automatically create a proxy for the object.
  
• Publish the stringified object references (in Orbix or IOR format) for server objects in a well-known location. A client can then retrieve the strings and convert them to object references using the OrbixWeb method string_to_object() (called on the _CORBA.Orbix object).
  
• Publish the object references using the CORBA Naming Service.
  

Passing an object reference as a parameter is very useful and is frequently implemented in CORBA applications. However, it is important to note that this system implies that the client is already connected to a server object. Therefore, it must be used in conjunction with one of the other approaches.

The CORBA Naming Service approach is suitable for a wide range of applications. The Naming Service is defined as part of the CORBAservices specification and allows ORB applications to assign abstract names to objects in a distributed system. These names can be assigned, and the objects associated with the names can be retrieved, through a standard IDL interface.

For example, if an OrbixWeb application assigns a name to an IOR for one of its objects, then this object can be located using the Naming Service interface by an application implemented using any ORB. In section 7.2.1, we will illustrate how to use the Naming Service in this context.

7.2.1 Publishing Object References using the Naming Service

A server that holds an object reference can register it with the Naming Service, giving it a name that can be used by other components of the system to subsequently find the object. The Naming Service has a number of interfaces defined in IDL that allow the components of the system to use its facilities. OrbixNames, IONA Technologies' implementation of the CORBA Naming Service,. runs as an Orbix (or OrbixWeb) server.

One of the advantages of the Naming Service is that the names it associates with objects are independent of any properties of the objects they refer to: in particular, a name is independent of an object's interface, server or host name. This allows application designers to chose any appropriate naming system for locating objects, independent of object reference formats.

For details of how the Naming Service operates, the reader should refer to the OrbixNames Guide. In summary, a name is always resolved within a given naming context. The naming context objects in the system are organised into a naming graph, which may form a naming hierarchy, much like that of a filing system. This gives rise to the notion of a compound name. The first component of a compound name gives the name of a NamingContext, in which the second name in the compound name is looked up. This process continues until the last component of the compound name has been reached.

The following code segment shows how to build naming contexts objects and objects.banks, and then to bind the name objects.banks.national to the object reference for a Bank implementation object.

 // Java
 // An OrbixWeb server
 // (and client of a Naming Server).
 // In file BankServer.java.
 package idl_demo;
 
 import CosNaming._NamingContextRef;
 import CosNaming.Name;
 import IE.Iona.Orbix2._CORBA;
 import IE.Iona.Orbix2.CORBA.SystemException;
 import IE.Iona.Orbix2.CORBA._ObjectRef;
 
 public class BankServer {
 	public static void main (String args[]) {
 		// Declare object types.
 		BankImplementation bankImpl = 
 			new BankImplementation ();
 		_BankRef bankRef;
 
 		// Declare Naming service types.
 		_ObjectRef initRef;
 		_NamingContextRef initContext; 
 		_NamingContextRef objectsContext; 
 		_NamingContextRef banksContext;
 		Name name;
 
 		try {
 			bankRef = new _tie_Bank (bankImpl);
 		}
 		catch (SystemException se) {
 			// Details omitted.
 		}
 
 		try {
 			// Find initial naming context.
 			initRef = 
 				_CORBA.Orbix.resolve_initial_references
 				("NameService");
 			initContext = NamingContext._narrow 
 				(initRef);
 
 			// A CosNaming.Name is simply a sequence 
 			// of structs.
 			name = new Name (1);
 			name.buffer[0].id = 
 				new String ("objects");
 			name.buffer[0].kind = new String ("");
 
 			// (In one step) create a new context, 
 			// and bind it relative to the 
 			// initial context:
 			objectsContext = 
 				initContext.bind_new_context (name);
 
 			name.buffer[0].id = 
 				new String ("banks");
 			name.buffer[0].kind = new String ("");
 
 			// (In one step) create a new context, 
 			// and bind it relative to the 
 			// objects context:
 			banksContext = 
 				objectsContext.bind_new_context (name);
 
 			name.buffer[0].id = 
 				new String ("national");
 			name.buffer[0].kind = new String ("");
 
 			// Bind name to object bankRef in context
 			// objects.banks:
 			banksContext.bind (name, bankRef);
 		}
 		catch (SystemException se) {
 			// Details omitted.
 		}
 
 		try {
 			// Wait for incoming requests.
 			_CORBA.Orbix.impl_is_ready ("BankSrv");
 		}
 		catch (SystemException se) {
 			// Details omitted.
 		}
 	}
 };