What is the Naming Service?
The Naming Service is a simple mechanism to associate meaningful names with an object, and then use those names in a lookup facility. For example, in a Banking application, the name given to a Checking Account object registered with the Naming Service, might be the name of the account owner. The Naming Service will then allow a lookup based on the account name, returning a reference to the matching Checking Account object.
Why should I use the Naming Service?
One of the issues facing all CORBA developers is 'How do I find the objects within my system?'. The Naming Service is one of the preferred mechanisms of exposing objects for others to find. The Naming Service supports a hierarchical name space, similar to that used by file systems on Unix and Microsoft Windows operating systems. This allows you to create 'folders' (called naming contexts) that contain other 'folders' and objects. The Naming Service is often compared with the telephone white pages, in that objects register themselves by name so that other objects can locate them. Together with the Trading Service (which is comparable with the telephone yellow pages), these two services are the preferred ways to locate objects and bootstrap a distributed application. The Naming and Trading Services can be resolved in a standard way via the ORB runtime system i.e. using the resolve_initial_references( ) operation.
What functionality is in the latest version of the Naming Service?
Version 5.x of OpenFusion contains the following functionality:
- Full implementation of the OMG's Naming Service specification, including naming trees, naming contexts, tree navigation, binding and name retrieval.
- Full implementation of the OMG's Interoperable Naming Service (INS) specification.
- Ability to reference naming data via the COSNaming or JNDI interfaces.
- Configurable caching and purging policies.
- Automatic garbage collection.
- Service replication across multiple databases.
- Deployment in clustered server environments for load balancing and failover. A number of default load balancing policies are included.
- Highly performant and scalable multithreaded implementation.
- Persistence of naming data to commercial databases.
- Dynamic instrumentation of binding, unbinding and rebinding counts.
In version 5.x the Naming Service has had improvements made to its reliability, availability and scalability.
Additional configurable parameters have been made available to allow users to dynamically tune the caching and load balancing operations of the OpenFusion Naming Service. These are:
- Read cache maximum / minimum size.
- Load balance enable.
- Load balance object activity check timeout.
The load balancing API is also available so that users can configure their own load balancing algorithms. These parameters provide more flexibility allowing users to configure the Naming Service for maximum scalability and performance.
Support for database connection pooling has also been added which allows database persistence schemes for the naming tree to be reliably and flexibility deployed.
Support for JDBC 2.0 drivers in latest versions of databases (Oracle, Sybase, Informix,
SQL Server) has been added to take advantage of new features in JDBC 2.0 such as
A number of additional features have been provided to significantly improve the performance of the Naming Service. These include:
- Speed improvements with write cache.
- Optimize get (implicit list into cache).
- Improved multi-user access, more robust implementation.
- Improvements to leaf creation algorithm data.
The above work to significantly improve performance when navigating the naming tree, binding objects, and working with cached data.
Support has also been added for the latest POA ORBs.
How do you specify the names in the Naming Service?
The Naming Service provides a straightforward mechanism to support name-to-object associations. The association between a name and an object is termed a name binding. Name bindings are, in turn, collected into sets called naming contexts. A naming context is set of name bindings where each name is unique within that context (although the same name may appear in other naming contexts). Each name binding refers to another naming context or to a CORBA object. Multiple names can be bound to the same naming context or object.
The Naming Service allows users to create, modify and examine name bindings within a naming context. The service also supports operations to create new naming contexts as well as destroying them when they are no longer required. Finally, the Naming Service provides support for enumerating the contents of naming contexts.
What is the difference between the Naming Service and the Trading Service?
The Naming and Trading Services are very similar in the services that they provide. These two services are the preferred ways to locate objects and bootstrap a distributed application. However, they do offer different levels of service. The following table illustrates these differences:
As the table shows, the services provide similar functions (i.e. locating objects), but they do it in very different ways.
Where does the Naming Service store data persistently?
The OpenFusion Naming Service is built on the OpenFusion Server Framework, which provides support for plug-in persistent storage modules. This allows the service to be configured to provide persistent storage in the way that you want it. For example, the Naming Service is supplied with two 'default' plug-ins; file and JDBC. The former saves the Naming Service data to a file (the data is serialized) and the latter uses JDBC to store the data into a relational database. However, other database plug-ins will be available, including ones for Oracle, Sybase, and Microsoft SQL Server databases.
How do I configure the OpenFusion Naming Service?
The OpenFusion Naming Service can be configured using the OpenFusion Administration Manager. This allows you to specify the persistence mechanism (file, JDBC, specific database type, etc.), diagnostic logging options, client location options, etc. The Administration Manager is an intuitive GUI-based tool, that provides a common configuration point for all of the OpenFusion J2EE and CORBA Services.
What is Load Balancing and why would I use it?
Load Balancing allows multiple objects to be bound into the same name within a naming context. This is useful because you could bind a number of replicated CORBA servers into the same name. The Naming Service will return one of these CORBA services according to the LoadBalancing algorithm supplied by the user. This means that if a server is in use a lot the load can be shared between a number of different servers. The default algorithms supplied by OpenFusion are:
- The mechanism supports plugins thereby allowing users to write their own algorithms when the default algorithms are not sufficient.
How do JNDI and the Naming Service interoperate?
The OpenFusion Naming Service is layered on top of the Java™ Naming and Directory Interface (JNDI) JNDI is an API that provides naming and directory functionality to applications written in the Java™ programming language. The JNDI is defined to be independent of any specific directory service specification, so clients may access a variety of directory services in a common fashion.
This picture shows the layering of JNDI with OpenFusion.
The JNDI architecture consists of the JNDI Application and Programming interface (API) and the JNDI Service Provider (SPI). The JNDI API allows Java applications to access a variety of naming and directory services. The SPI allows arbitrary naming and directory service providers to allow their implementations to be accessed from the client Java™ application. These service providers map through the generic calls to the specific implementation e.g. to an LDAP server. OpenFusion has its own Service Provider that implements the javax.naming.Context interface. This allows basic operations such as adding a name-to-object binding, looking up names, removing bindings, creating and destroying subcontexts etc.
Visit the OpenFusion Naming Service webpage.