Topics in this section include:
The CORBA COS (Common Object Services) Naming Service provides a tree-like directory for object references much like a filesystem provides a directory structure for files. The Naming Service provided with Java IDL is a simple implementation of the COS Naming Service specification.
Object references are stored in the namespace by name and each object reference-name pair is called a name binding. Name bindings may be organized under naming contexts. Naming contexts are themselves name bindings and serve the same organizational function as a file system subdirectory. All bindings are stored under the initial naming context. The initial naming context is the only persistent binding in the namespace; the rest of the namespace is lost if the Java IDL naming service process halts and restarts.
For an applet or application to use COS naming,
its ORB must know the port of a host running a naming
service or have access to a stringified initial naming context for that
naming service. The naming service can either be the Java IDL naming service
or
another COS-compliant naming service.
Starting the Java IDL Naming Service
You must start the Java IDL naming service before an application or applet that uses its naming service. Installation of the Java IDL product creates a script (Solaris: tnameserv) or executable file (Windows NT: tnameserv.exe) that starts the Java IDL naming service. Start the naming service so it runs in the background.
If you do not specify otherwise, the Java IDL naming service listens on port 900 for the bootstrap protocol used to implement the ORB resolve_initial_references() and list_initial_references() methods, as follows:
tnameserv -ORBInitialPort nameserverport
If you do not specify the name server port, port 900 is used by default. When running Solaris software, you must become root to start a process on a port under 1024. For this reason, we recommend that you use a port number greater than or equal to 1024. To specify a different port, for example, 1050, from a UNIX command shell, enter:
tnameserv -ORBInitialPort 1050
From an MS-DOS system prompt (Windows), enter:
start tnameserv -ORBInitialPort nameserverport
Clients of the name server must be made aware of the new port number. Do this by setting the org.omg.CORBA.ORBInitialPort property to the new port number when creating the ORB object.
- -Joption
- Pass option to the Java virtual machine, where option is one of the options described on the reference page for the java application launcher. For example, -J-Xms48m sets the startup memory to 48 megabytes. It is a common convention for -J to pass options to the underlying virtual machine.
To stop the Java IDL naming service, use the relevant operating system command, such as kill. Note that names registered with the Java IDL naming service disappear when the service is terminated.
The following sample program illustrates how to add names to the namespace. It is a self-contained Naming Service client that creates the following simple tree.
In this example, plans is an object reference and Personal is a naming context that contains two object references: calendar and schedule.
import java.util.Properties;
import org.omg.CORBA.*;
import org.omg.CosNaming.*;
public class NameClient
{
public static void main(String args[])
{
try {
In the above section,
Starting the Java IDL Naming Service,
the nameserver was started on port 1050. The following code ensures that the
client
program is aware of this port number.
Properties props = new Properties();
props.put("org.omg.CORBA.ORBInitialPort", "1050");
ORB orb = ORB.init(args, props);
This code obtains the initial naming context and assigns it to
ctx. The
second line copies ctx into a dummy object reference
objref
that we'll attach to various names and add into the namespace.
NamingContext ctx =
NamingContextHelper.narrow(orb.resolve_initial_references("NameService"));
NamingContext objref = ctx;
This code creates a name "plans" of type "text" and binds it to our dummy object
reference. "plans"
is then added under the initial naming context using rebind. The
rebind method allows us to run this program over and over again
without getting
the exceptions we'd get from using bind.
NameComponent nc1 = new NameComponent("plans", "text");
NameComponent[] name1 = {nc1};
ctx.rebind(name1, objref);
System.out.println("plans rebind sucessful!");
This code creates a naming context called "Personal" of type "directory". The
resulting
object reference, ctx2, is bound to the name and added under the
initial
naming context.
NameComponent nc2 = new NameComponent("Personal", "directory");
NameComponent[] name2 = {nc2};
NamingContext ctx2 = ctx.bind_new_context(name2);
System.out.println("new naming context added..");
The remainder of the code binds the dummy object reference using the names
"schedule" and
"calendar" under the "Personal" naming context (ctx2).
NameComponent nc3 = new NameComponent("schedule", "text");
NameComponent[] name3 = {nc3};
ctx2.rebind(name3, objref);
System.out.println("schedule rebind sucessful!");
NameComponent nc4 = new NameComponent("calender", "text");
NameComponent[] name4 = {nc4};
ctx2.rebind(name4, objref);
System.out.println("calender rebind sucessful!");
} catch (Exception e) {
e.printStackTrace(System.err);
}
}
}
The following sample program illustrates how to browse the namespace.
import java.util.Properties;
import org.omg.CORBA.*;
import org.omg.CosNaming.*;
public class NameClientList
{
public static void main(String args[])
{
try {
In the above section,
Starting the Java IDL Naming Service,
the nameserver was started on port 1050. The following code ensures that the
client
program is aware of this port number.
Properties props = new Properties();
props.put("org.omg.CORBA.ORBInitialPort", "1050");
ORB orb = ORB.init(args, props);
The following code obtains the intial naming context.
NamingContext nc =
NamingContextHelper.narrow(orb.resolve_initial_references("NameService"));
The list method lists the bindings in the naming context. In this
case,
up to 1000 bindings from the initial naming
context will be returned in the BindingListHolder; any remaining bindings are
returned
in the BindingIteratorHolder.
BindingListHolder bl = new BindingListHolder();
BindingIteratorHolder blIt= new BindingIteratorHolder();
nc.list(1000, bl, blIt);
This code gets the array of bindings out of the returned BindingListHolder. If
there
are no bindings, the program ends.
Binding bindings[] = bl.value;
if (bindings.length == 0) return;
The remainder of the code loops through the bindings and prints the names out.
for (int i=0; i < bindings.length; i++) {
// get the object reference for each binding
org.omg.CORBA.Object obj = nc.resolve(bindings[i].binding_name);
String objStr = orb.object_to_string(obj);
int lastIx = bindings[i].binding_name.length-1;
// check to see if this is a naming context
if (bindings[i].binding_type == BindingType.ncontext) {
System.out.println( "Context: " +
bindings[i].binding_name[lastIx].id);
} else {
System.out.println("Object: " +
bindings[i].binding_name[lastIx].id);
}
}
} catch (Exception e) {
e.printStackTrace(System.err);
}
}
}
| Home |