Having problems with your account or logging in?
A lot of changes are happening in the community right now. Some may affect you. READ MORE HERE
OpenFusion - Blog
Make a selection from the options in the gray area below:

OpenFusion - Blog

Community Manager kgroneman Community Manager
Community Manager

Make it better. Make it faster. Make it CORBA. (by John McHugh)

Guy-Manuel de Homem-Christo and Thomas Bangalter. You may not recognise the names, but you most likely know them by their other name. They emerged on the music scene in 1993 (the same year we first released Orbix) and have been behind a huge number of worldwide hits. One of those songs, “Harder, Better, Faster, Stronger,” was recently performed on German TV by a 15 piece orchestra. The song contains lyrics such as "Work it harder / Make it better / Do it faster / Makes us stronger / More than ever... Our work is never over.”  

As a Product Manager, one of my responsibilities is to understand customer and market requirements and ensure these feed directly into our product strategy. These lyrics remind me of the input we probably all get at one time or another from our peers, bosses or family members. Okay, not quite as generic as "make it better" or "faster", but sometimes the important details behind the request get lost along the way and what ends up being finally communicated is not much more than asking for a general improvement in a general area without a specific target or measurement in mind. 

Here at Micro Focus we are committed to evolving our solutions and delivering products that meet the needs of our users. We have a very strong and proven heritage in ensuring our customers get the maximum value from their existing investments. Our motto of “Bridging the old to the new” is central to everything we do.  This is especially true with our portfolio of CORBA solutions.  Our philosophy requires collecting good quality feedback directly from our users and ensuring our product strategy matches the expectations of our customers.

To help achieve this, we ask for your help. Just launched is the 2017 Micro Focus CORBA User Survey, a wide ranging examination of how we can better meet your future needs. This survey is focused on understanding how you use our products, and how we can develop those products in today's changing landscape of Cloud, DevOps and IoT.  We understand your time is precious, so while it should take under 10 minutes to provide your feedback, everyone who completes the survey will be entered for a chance to win one of several $25 Amazon gift cards.

Oh, and if you are still wondering who the two gentlemen I mentioned at the start of the post are... they form the electronic musical duo, Daft Punk.

Complete the survey today and help make CORBA better, faster: 2017 Micro Focus CORBA User Survey

John McHugh - Product Manager

Read more
0 0 273
Community Manager kgroneman Community Manager
Community Manager

Micro Focus is pleased to announce the availability of OpenFusion TAO 2.3.1, OpenFusion JacORB 3.7, and OpenFusion CORBA Services 5.0.1.

At the heart of the OpenFusion suite of products are the Micro Focus editions of the open source TAO and JacORB CORBA solutions. TAO 2.3.1 and JacORB 3.7 are complementary solutions that allow organizations to build and deploy highly scalable, performant, and secure CORBA based solutions using C++ or Java respectively. Each are enhanced over the community distributions to offer a more robust solution, suiting all types of use cases from Embedded to Enterprise.

Both OpenFusion TAO and JacORB are delivered pre-built, but they remain closely aligned to their community edition counterparts. This allows for a seamless transition between the Micro Focus distributions and their open source equivalents, thereby avoiding vendor lock-in.

Selection of Newly Supported Platforms:

  • Solaris 11 SPARC with Sun Studio 12.2
  • Solaris 11 Intel with Studio 12.
  • SUSE Linux Enterprise Server 12
  • RedHat Enterprise Linux 7
  • Microsoft Windows with Visual Studio 2013
  • Microsoft Windows Server 2012, Windows 8.1, Windows 10

For the most up-to-date supported platform list, please see the SupportLine website here.

For the full list of changes, please see the product release notes available here.

Read more
0 0 479
helen_field Absent Member.
Absent Member.

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 
two-phase commit.

 

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.

Names

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:

 

Naming Service FAQs - v2

 

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:

  • Random
  • RoundRobin
  • FirstBound
  • Random_Active
  • RoundRobin_Active
  • FirstBound_Active
  • Random_RemoveCurrent
  • FirstBound_RemoveCurrent
  • Random_Active_RemoveCurrent
  • 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.

Naming Service FAQs - 3

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.

Read more
0 0 1,892
helen_field Absent Member.
Absent Member.

OpenFusion RTOrb Java Edition

OpenFusion RTOrb Java Edition is Micro Focus's real-time CORBA-compliant ORB for the RTSJ. Based on international standards the architecture of OpenFusion RTOrb Java Edition is open, flexible and highly performant.

Based on Tried and Tested RT ORB Architecture

OpenFusion RTOrb Java Edition is based on a product core that has been tried and tested in demanding applications in both the military and commercial sectors.

Architecture Supports Full CORBA Operations

The OpenFusion RTOrb Java Edition architecture comprises not just minimumCORBA, as is the case with most real-time ORBs, but a fully capable, enterprise level ORB and, unlike many real-time ORBs, OpenFusion RTOrb Java Edition includes enterprise level functionality. This is a rarity in real-time ORBs, let alone one written in the Java language! It is therefore uniquely positioned to provide a single solution for different needs and uses, supporting both real-time and business applications in a single ORB.

Latest Platform Support

OpenFusion RTOrb Java Edition includes support for the new Java Real-Time System platform from Sun Microsystems on the Solaris Operating System.

High Performance

OpenFusion RTOrb Java Edition builds on Micro Focus’s strong heritage of providing highly performant ORBs. The product has been optimized by Micro Focus CORBA experts so that users can fully benefit from its high performance architecture.

Platform Support

OpenFusion RTOrb Java Edition is supported on a number of leading operating systems and JVMs including:

  • Operating Systems: Solaris 10; Red Hat Enterprise Linux 4
  • JVMs: JDK 1.5, 1.6
  • Real-Time JVMs: Sun Java Real-Time System v1.0; IBM WebSphere(R) Real Time

Summary: The OpenFusion RTOrb Java Edition Advantage

Amongst the key features of OpenFusion RTOrb Java Edition are:

  • CORBA 3.0 ORB,
  • RT CORBA v1.2 support on a RTSJ compliant JVM with low jitter comparable to that obtained with C or C++ applications,
  • CORBA Object Services– bundled Naming Service,
  • Java language bindings based on the OMG’s IDL to Java language mapping specification,
  • Full POA implementation,
  • Multithreaded support,
  • Comprehensive Portable Interceptor support,
  • Support for ValueTypes,
  • Request Timeouts from the CORBA Messaging specification,
  • Extensible Transport Framework (ETF)

Visit OpenFusion RTOrb Java Edition web page

Read more
0 0 525
helen_field Absent Member.
Absent Member.

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.

Reliability

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

Scalability

  • 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

Flexibility

  • 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.

Interoperability

  • 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

Read more
0 0 1,113
helen_field Absent Member.
Absent Member.

What is the Trading Service?

The Trading Service is a sophisticated mechanism for locating server objects based on a description of requirements, rather than simple names. Objects register their services with the Trading Service, specifying a set of property values that describe the service that they are offering. Other objects can use the Trading Service to locate a server that provides a required service, based on these property values. The Trading Service matches the required service property values with those supplied by the servers when they registered.

Why should I use the Trading Service?

We often locate resources by searching for them not by their name, but by searching for a resource that can provide a particular service to us. For example, we look for a builder who can repair the roof, or for a printer that can print a document in color, or for a telephone service provider with cheap long distance calls. Rather than searching through the telephone white pages until we happen upon a building firm we recognize, we reach for the yellow pages and call on a business listed in the Building section. The Trading Service is similar to the yellow pages; it allows objects that can provide a service to register their abilities and it then allows clients to locate those services by describing the functionality they require. From then on, the client deals directly with the service provider object.

While the Naming Service provides a simple mechanism to locate objects ('services') by a name, this can quickly become unmanageable. For example, consider a system that manages printer queues. We can partition the printers into postscript and non-postscript printers. This is easy to model in a hierarchical manner using the Naming Service. However, if we also want to categorize printers by other capabilities, e.g. color or black and white printing, this becomes more complex. If you then add further categories, such as ink jet or laser printers, the hierarchical model very quickly becomes too complex to manage. Imagine the hierarchy levels that would be needed to categorize printers with varying throughput speed (in pages per minute) this can range from 1 to more than 16 pages per minute! Using the Trading Service, we would define a service type of 'printer' and specify properties that will allow us to categorize the different printers e.g.

service printer 

interface IDL:PrinterQueue:1.0; 
mandatory property boolean postscript; 
mandatory property short ppm; // Pages per minute 
readonly property Boolean colour; 
readonly property Boolean laser; 
};

This allows any Trading Service user to query for a printer service based on the printer properties e.g. 'postscript == TRUE and PPM> 6'. You can also specify the order in which the matching service offers are returned. For the above example, you may want the printer service offerings listed by their throughput speed (PPM). You would specify this ordering as 'max PPM in the query return order criteria. Therefore, the Trading Service offers an object location facility that is more sophisticated than that offered by the Naming Service. The ability to search for objects on multiple criteria and to control the order of the returned matches greatly increases the flexibility and usability of the Trading Service.

What is the latest version of the Trading Service?

Version 4.x of OpenFusion contained the following functionality

  • Full implementation of mandatory and optional parts of the OMG's Trading Service specification, including all interfaces (full-service trader), complete trader constraint language, and service type repository.
  • 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 service type and offer data to commercial databases.
  • Dynamic instrumentation of service type and offer counts.

Version 4.x contains additional configurable parameters to allow users to dynamically tune the dynamic operations of the OpenFusion Trading Service providing more options for reliability and scalability.

Support for database connection pooling has been added allowing database persistence schemes for the service offers to be reliably and flexibly deployed.

Support for JDBC 2.0 drivers in latest versions of databases (Oracle, Sybase, Informix, SQL Server) has also been added to take advantage of new features in JDBC 2.0 such as two-phase commit.

A number of additional features are provided to significantly improve the performance of the OpenFusion Trading Service, these include:

  • Speed improvements with write cache.
  • Improved multi-user access, more robust implementation.
  • Improved offer search algorithm.
  • Optimization of persistence mechanisms
  • Which significantly improves performance when writing and retrieving offers.
  • Support for latest POA ORBs
  • OpenFusion 4.x allows interoperability and federation of the CORBA Trading Service across VisiBroker, Orbix and Orbacus platforms.
  • Ability to output diagnostics information via HTTP.
  • A new GUI tool for configuration and management is provided.

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:

 Naming Service and the Trading Service

 

 

As the table shows, the services provide similar functions (i.e. locating objects), but they do it in very different ways.

What are the different types of Traders?

The OMG's CORBA Object Trading Service specification defines six different types of traders, depending upon the functionality that they support. The Trading Service specification defines five functional interfaces for a trader:

  • Lookup allows clients to query the trader for offers
  • Register allows services to be 'exported' (advertised) to the trader.
  • Admin allows the trader property to be configured.
  • Link supports the linking (federation) of traders.
  • Proxy supports the delayed evaluation of offers and can be used to encapsulate legacy systems.
  • The types of traders are determined by the interfaces that they support i.e.

Trading service components

The OpenFusion Trading Service implementation supports all five functional interfaces and is, therefore, a full-service trader.

How do I link Traders?

The operations on the Link interface allow traders to be linked together, so that a trader can make the offer spaces of other Trading Services available to its own clients. A link describes the knowledge that the trader has of the target trader. To link to a target trader, we must have a reference to the Lookup interface of the target and we will need to give the target trader a name. The link operation can also define policies for 'link following' i.e. when, and to what extent, the link should be followed in the resolution of a query e.g.

link.add_link( "Link to remote trader 2", 
remote_2, 
org.omg.CosTrading.FollowOption.if_no_local, 
org.omg.CosTrading.FollowOption.always 
);

In this example, we have named the link as "Link to remote trader 2" and remote_2 is a reference to the Lookup interface on the remote trader. We have also set the 'link following' policy as: if_no_local. which means follow the link to the remote trader, if no local matches are found, always which means a client may override the default setting (above) to always follow the link. More details on linking traders can be found in the OpenFusion Developer's Guide.

What is the Service Type Repository?

The Service Type Repository is a centralized location for storing service type details. Service types can be added, modified, and deleted from the repository. The repository allows service types to be preloaded into a trader, so that the service definitions are ready for service providers (exporters) and clients (importers). The OpenFusion Trading Service implementation supports a Service Type Repository and provides utility tools to load service type descriptions from a text file. The service type descriptions can also be extracted from the repository and written to a text file. A single Service Type Repository can be shared by many traders.

How do I administer a Trading Service?

The Trading Service specification defines an Admin interface, which provides operations for configuring the service. These operations can be accessed programmatically or, for ease of use, they can be controlled via a GUI-based administration tool. The tool (called the Trader Manager) can be launched from the OpenFusion Administration Manager. It provides a intuitive user interface for configuring and managing a trader, and allows navigation to linked traders so that they can be managed in the same manner.

How well does the Trading Service perform?

The OpenFusion Trading Service has been proven to by far the most performant implementation available. OpenFusion 4.x has raised the bar further with significantly increased performance in all, and in some cases orders of areas and an order of magnitude improvement in performance over previous versions.

Visit OpenFusion Trading Service web page

Read more
0 0 1,024
The opinions expressed above are the personal opinions of the authors, not of Micro Focus. By using this site, you accept the Terms of Use and Rules of Participation. Certain versions of content ("Material") accessible here may contain branding from Hewlett-Packard Company (now HP Inc.) and Hewlett Packard Enterprise Company. As of September 1, 2017, the Material is now offered by Micro Focus, a separately owned and operated company. Any reference to the HP and Hewlett Packard Enterprise/HPE marks is historical in nature, and the HP and Hewlett Packard Enterprise/HPE marks are the property of their respective owners.