Novell is now a part of Micro Focus

Novell Trader Service Architectural Overview

Articles and Tips: article

JOHN CHRISTENSEN
Lead Engineer Novell Trader
Java Technologies Group

01 Aug 1997


Describes Novell Trader, a new cross-platform "publish and subscribe" service that helps find objects on the network. The Novell Trader uses NDS for its persistence, and it written entirely in Java.

Introduction

Novell Trader is a new cross-platform "publish-and-subscribe" service that helps find objects on the network. Network objects can use the Novell Trader to advertise their capabilities and match their needs to the advertised capabilities of other objects. The Novell Trader is fully CORBA compliant and is based upon the OMG RFP5 submission for a trading object service. The Novell Trader uses NDS for its persistence, and is written entirely in Java.

Because it is 100% Java, the Novell Trader runs on any platform that supports the Java Virtual Machine (JVM). Novell Trader offers several advantages to developers because components of distributed object systems can be written and deployed anywhere on the network to advertise and be dynamically discovered all within the robust management framework of NDS.

One writer recently compared the Internet to the Library of Congress with all of the book shelves dumped over and the lights turned off. Even if something is there, it may be very difficult to find. As network computing progresses through the merging of public and private networks, more objects such as documents, databases, web pages, network devices, software components, and network services are added to the information explosion everyday.

The Internet forces us to look for an increasing number of needles in an unlimited number of haystacks. In response to this growing crisis, Novell is providing for the Internet what it has already provided for Intranets - services that aid in the advertisement, locating, binding, and management of services, devices, information, and network objects.

This article describes the architecture of Novell Trader that addresses this concern that THINGS ARE TOO HARD TO FIND ON THE NETWORK. Novell's Trader Service is a new distributed object service written entirely in Java that provides complimentary functionality to standard naming and location systems.

Because Novell Trader is 100% Java, Novell Trader runs on any platform that supports the Java Virtual Machine (JVM). The cross-platform feature of the Novell Trader allows its deployment at virtually any node in the network.

An Overview of Trading

People find information in the real world through phone books, matchmaking services, classified ads, and mail order. These services all have properties that help understand key notions of the Novell Trader Service.

Telephone books are divided into white pages and yellow pages. This differentiation illustrates the key difference between naming services (white pages) and trader services (yellow pages). White pages are organized by name and are used to find a person or entity that is already known. Yellow pages are organized by category and are used to find or shop for a service from among potential providers. The key to choosing a service provider from the yellow pages rests in the organization of the categories, the available services offered, and the properties associated with each service listed. Yellow pages contain service categories, service listings, and the advertisement specifics of the yellow pages.

Novell's Trader is organized in much the same way with a type repository, an offer repository, and offer properties represented in name-value pairs. Phone books provide a common well-known place to bind people and services together via the telephone system. Naming and trader services provide the same functionality for the network and they compliment each other nicely.

Matchmaking, resume bureaus, or dating services are like a trader service in that they anonymously bring interested parties together in a dynamically changing environment. Interested parties are allowed to enter or advertise a view of themselves that would appeal to other interested parties. This view can change at the discretion of the parties.

Potential clients can anonymously shop for the best possible match based upon their own wide or narrow set of constraints. In this system offers can be freely accepted, rejected, and withdrawn anytime. The trader service uses this anonymous communication to match services and network objects with potential users. This is a powerful feature that enables dynamic system evolution, continuous operation, and integration with legacy systems.

The classified ads in the newspaper provide another parallel to trading services. Classified ads unlike the yellow pages of the phone book come and go dynamically. While information in the yellow pages might be outdated because it is only published annually, the classified ads change daily. In the trader service domain, offers will be much more dynamic than even classified adds.

Offers and properties of the offers can be modified or withdrawn in real-time completely asynchronous to any object shopping in the traders' repositories. Novell trader supports dynamic properties that enable real-time discovery of the state of offers.

One final parallel to trading can be drawn from mail-order catalogs. Advertising, shopping, ordering, and delivery all take place within the same mail-order distribution system. Traders provide a similar framework for distributed object systems. With a trader, service providers can advertise offers, clients can shop for the perfect object, and services are bound to clients with information supplied by the trader.

This integrated system added to Novell's Directory Services (NDS) provides a platform for many complex distributed computing problems such as management, distribution, licensing, software metering, and versioning.

In summary, the Novell Trader Service goes hand in hand with NDS much like the white and yellow pages of the phone book. Dynamic system evolution and continuous operation are supported by the Novell Trader much like a matchmaking service or the classified ads. And like mail-order catalogs, the Novell Trader provides a single point of control for distribution, licensing, management, as well as the framework for many complex distributed computing problems.

How Traders Might be Used

Traders can be used for more than the object-shopping described above. Traders provide the backbone for a federated distributed object system that can scale to millions of objects. Load balancing is achieved when multiple offer instances that meet the constraints of a client and a particular instance is selected based upon how busy it is in relation to the others.

Licensing and software metering can also be enforced by the trader service. Every operation of the trader can be associated with an authenticated network identity and appropriate access controls. When a client attempts to register, discover, lookup, and bind to other network objects the trader can check permissions and enforce licenses and policies.

The trader is a publish-subscribe mechanism in that network objects can dynamically publish (register) with the trader and clients that subscribe to the trader service can go object shopping (lookup) among the set of offers stored in the offer repository. In essence the trader creates a loosely-coupled location service between objects that need not know each other.

This loose coupling allows for transparent use or late binding between service consumers and service providers. Thus a network consumer can use an appropriate service provider, though the requirements of the consumer, the state of the system, and the services in the system may change dynamically.

The CORBA Trading Object Service

The object trading service is part of the Common Object Request Broker Architecture (CORBA) defined by the Object Management Group (OMG). CORBA defines an object-oriented approach to creating reusable software components that can be shared across a network. The Novell Trader is fully CORBA compliant and is based upon the OMG RFP5 submission for a trading object service.

Four classes or categories of traders are identified by the CORBA specification and are being implemented incrementally in the Novell trader. These classes include the following:

  • simple trader

  • stand alone trade

  • linked trader

  • full service trader

Each of these classes defines interfaces to functional areas of the trader that operate upon service types and offers as described below.

Service Types and Offers

Traders are made up of two repositories containing known service types and the service offers associated with those types. These repositories are known as the service type repository and the offer repository. The service type repository is a hierarchical organization of information that serves as the schema or template for all offers known to the trader. Specifications for interfaces, properties, and attributes of advertised services are described in the service type repository.

An offer repository contains object references to actual instances of a service type. Each offer in the offer repository must conform to the specification for a given service, and provide name-value pairs that differentiate it from other offers of the same service type. The offer type, and the name value pairs for properties of a given service type provide the foundation for successful trading.

Simple Trader

The first phase of the Novell Trader called the simple trader was released as an Alpha version in March of 1997. There is nothing "simple" about a simple trader. It might also be called the base-line or core trader upon which complex, scalable, federated systems of interworking traders can be built. It provides complete functionality to begin writing applications that use the trader service.

A simple trader is fully functional for advertising and locating service within the network. A register interface provides the export(), withdraw(), describe(), and modify() operations for advertisers of services. Service consumers use a query() function of the lookup interface to shop among service offers that meet their needs. An OMG constraint language is used by the query() function to specify how offers in the offer repository are matched by the trader to a consumer request. The Novell Simple Trader also supports dynamic properties that provide a call-back mechanism to modify offer properties in real-time.

Standalone Trader

The second phase of the Novell Trader is called the stand alone trader. It will be released as an FCS version in the fall of 1997. Stand alone traders provide all of the same functionality as a simple trader, but add an administration interface to allow deployment of the trader in production systems. The administration interface provides the capability to set policies of the trader and an alternate method to list contents of the Type and Offer repositories. The admin interface provides an open program interface to integrate with network administration tools.

Linked Trader

The CORBA trader architecture is very scalable and provides a framework for interworking between traders and trader federation. Links between traders provide much of this functionality. A link interface provides the mechanism for traders to register with each other and to share information contained in their respective offer repositories. A simple trader and a linked trader are nearly equivalent but the linked trader can scale to very large systems with thousands of offers. A third phase of the Novell trader will be delivered in Alpha release in the winter of 1997.

Full Service Trader

The fourth phase of the Novell trader is the full service trader scheduled for an end of year Beta release. The full service trader adds a proxy interface to the link, admin, lookup, and register interfaces. The proxy interface provides a hook to allow service discovery and creation within legacy systems. Thus the full service trader provides a federated object system that spans many domains, and technologies.

Architectural Highlights

The Novell Trader is 100% compliant to the standard open interfaces described by OMG for a trading object service. In addition to the interfaces, several key architectural points add value to Novell's implementation of the CORBA specification.

  • Platform coverage:100% Java provides a true cross-platform implementation so that Novell Trader will run with any JVM.

  • Leverages strengths of NDS: an NDS-based management framework for distributed objects, uses ACLs for fine-grained access control over registration, discovery, binding, and execution of network objects, and uses NDS replication for scalability.

  • Open architecture provides for multiple persistence models: although the preferred deployment of the Novell Trader is with NDS, it can be deployed with an in-memory-only, a flat file, or any LDAP compliant name system for its persistence. Versions of the Novell Trader that support ODBC/JDBC are under development.

  • Multiple query languages: besides the OMG Constraint language, the Novell Trader has been architected to use other query languages such as SQL and a natural languagequery.

  • CORBA ORB independence: the Novell ORB is currently deployed with the Visibroker for Java 3.0 ORB, but it is designed to be easily integrated with other ORBs.

  • Administration utilities: the Novell Trader can be administered directly through NDS using a NWAdmin snap-in. It is also integrated with Novell's web-based administration utilities. The administration interface also provides for administration utility independence.

Conclusion

In conclusion, the Novell Trading service is an alternative to standard naming systems. It is used to find objects on the network based upon advertised types and properties of the object. The Novell Trader uses anonymous communication to match services and network objects with potential users. This is a powerful feature that enables dynamic system evolution, continuous operation, and integration with legacy systems.

Like the Novell Trader, web crawlers maintain databases of information on object types and properties, however the Novell Trader provides a mechanism for the objects themselves to create their own properties and to advertise and modify them accordingly. Novell's Trader maintains a dynamic repository of information on objects within the network. The Novell Trader service in essence is a distributed object system that manages system-wide meta data including the location and the basic capabilities of all services, and objects on the network.

The Novell Trader is the only trader service which provides a scalable cross-platform open architecture that supports late binding, location independence, reliable replicated persistence, transparent distribution, and authenticated identities, all with a single point of control for management. Any trading system for finding objects on the network should addresses each of these architectural points.

* Originally published in Novell AppNotes

Disclaimer

The origin of this information may be internal or external to Novell. While Novell makes all reasonable efforts to verify this information, Novell does not make explicit or implied claims to its validity.

© Copyright Micro Focus or one of its affiliates