3 minute read time

About OpenFusion Trading Service

by in Application Modernization

OpenFusion Trading Service

A highly flexible method of registering and finding resources in distributed systems. A flexible mechanism for locating resources based on a description of requirements rather than by simple name matching. The resources are located by queries on the Trading Service, with support for complex queries. The Trading Service also provides a dynamic, load balancing mechanism that is essential for large systems.

When to use the Trading Service

In large-scale object-based systems, an application may not know the reference to a particular system resource, such as one unique printer. However, it may know the required type and condition of any available resource (e.g. any color printer with less than three print jobs in the queue) it needs to carry out a job. Using the Trading Service, the application can submit a query of arbitrary complexity, and the Trading Service will match this with available resources and return an appropriate reference. The application can then invoke the required operations on the resource. Often, when system resources are routinely added or removed, the Trading Service is the only efficient means by which applications can easily access the full, current range of resources across the system.

In e-commerce applications, a fundamental workflow involves clients querying a remote system to find the services (such as pricing models, databases, ticket availability, etc.) they require. The clients certainly don't know the direct object references within the system, but they do know what sort of service they want. The Trading Service is a natural way of facilitating this interaction. The e-commerce vendor registers and de-registers services with the Trading Service on an ongoing basis as products or features are added or revised. Customers can then submit queries via the Trading Service to find the exact product or information they require.

In finance, a huge number of different algorithms for risk assessment of an impending transaction may be available across the system. The dealer can submit a query to the Trading Service to find and invoke the particular type of risk application required for the deal at hand, without needing to know where the application is physically located on the network.

The OpenFusion Advantage

The OpenFusion Trading Service is a full service, highly reliable, scalable, performant, flexible and interoperable implementation of the OMG's specification - the premier implementation available today. It helps users build and apply truly flexible schemes to dynamically manage system resources.

OpenFusion Trading Service is the ideal basis on which to build an open, standards-based resource management infrastructure - it is currently being used in large-scale, mission-critical applications in the Telecoms, Finance, Travel and other sectors, giving our customers a firm basis upon which their systems can expand and adapt to future demands.

Technical Features

OpenFusion Trading Service is a full service implementation of the latest OMG® specification, including support for all five interfaces, and a full service type loader and repository. Key system requirements such as reliability, scalability, flexibility and interoperability are built into the product by specific features such as trader federation, service type persistence to relational databases, and multi-threading. In addition, the Trading Service benefits from OpenFusion's powerful plug-and-play architecture.


  • Automatic garbage collection of expired service offers
  • Automatic server failover mechanisms


  • Trader federation over multiple hosts - facilitates load balancing and performance tuning
  • Service type persistence to commercial databases via optimized stored procedures
  • Automatic service activation on demand
  • Multi-threaded implementation


  • Full service type loader and repository support provided.
  • Tools to export and load service type definitions to and from XML files - aids service replication.
  • Complex service querying using a powerful constraint grammar.
  • Support for user-configured service type plugins to obtain optimum performance for queries on a particular service type.
  • JMX / SNMP-based monitoring.
  • Dynamically update service configuration properties without the need to re-start service.
  • Secure access to service via pluggable authentication and authorization modules.
  • Powerful GUI-based management tools.


  • Interoperation and federation with other compliant Trading Services.
  • Ability to invoke Trading Service as an EJB entity bean.
  • Multi-platform support - Unix and Windows NT, ORBs and application servers.

Benefiting from OpenFusion's Plug-and-Play Architecture

OpenFusion's unique strength comes from an innovative architecture that guarantees high flexibility through a plug-and-play layer and industrial strength through common scalability and performance-oriented functions. All key resources required by the OpenFusion Trading Service are accessed through generic "plug-in" sockets. This enables complete flexibility through the use of connectors provided with OpenFusion or customizations using open APIs.

  • Configurable qualities of service (QoS) for JMX / SNMP-based monitoring.
  • Powerful GUI-based management tools to connect and configure and administer object groups.
  • ORBs: JacORB 2.3, 3.0; VisiBroker 7, 8
  • Databases: Oracle; Sybase
  • Operating Systems: Solaris 10; Red Hat Enterprise Linux 5, 6; Windows XP, 2003, 7 
  • JVMs: JDK 1.6, 1.7
  • Other plug-ins provide access to leading system management, licensing, security and diagnostic products.
  • Open architecture for easy addition of new plug-ins to other products.

Visit OpenFusion Trading Service web page