Configuring Microservices

Most components have a set of configurable parameters which can be set to appropriate values to customize instances of the component for a particular Fiorano application. Configuration is captured within a configuration property sheet (CPS) as described in the following sections.

CPS for Component Instance Configuration

Most components have a GUI-based Configuration Property Sheet (CPS). This is usually a dialog or wizard which has a list of configurable parameters for the component. These customizable parameters have their own editors to facilitate the end user in adding appropriate values.

Launching the CPS

Right-click the component and select the Configure option from the menu list or double-click the component to open the CPS

Figure 1: Launching the CPS

Figure below illustrates the loaded CPS of a DB component as an example.

Figure 2: A typical CPS

Customizable and Expert Properties

One component's customizable properties are typically different from that of the other. Some properties are hidden by default and are shown only when the Show Expert Properties checkbox is selected. These are a set of advanced properties that are specific to the particular component instance.

You can see additional properties highlighted in figure below, which are advanced properties which are not visible in Figure 6.

Figure 3: CPS with Expert Properties enabled in DB CPS

Component Help

Apart from this Online Help, component help is available attached to the components as well; select the component and press F1 to open the Component Help.

Other the the entire help content, description for a selected property appears under the Description section (see the figure above) present at the bottom of the each CPS panel.

Runtime Arguments

On selecting a component in the Fiorano eStudio, the runtime arguments for the component are displayed in the Properties window (as shown in the figure below). These runtime arguments can be accessed within the component at runtime through the parameters passed to the component when launching it using a launcher. A standard runtime argument added for all Java components is "JVM_PARAMS". This captures the JVM parameters which the end user might want to pass when the component is launched as a separate process. Runtime arguments for a component can be added using the Fiorano eStudio.

If the component's launch mode is changed to 'In Memory', the JVM_PARAMS property will not be displayed in Properties view. To use the properties passed as JVM_PARAMS for an InMemory launched component, these properties need to be added to peer server's configuration file under <java.system.props> tag before starting the peer server. Peer server's configuration file can be located as either $FIORANO_HOME/esb/server/bin/server.conf or $FIORANO_HOME/esb/fps/bin/fps.conf depending on the script being used to run the peer server.

Figure 4: Fiorano eStudio showing runtime arguments in properties window

Component Dependencies and System Libraries

Every component has a set of dependencies on various libraries such as JAR files, DLLs, property files, configuration XML or any file which the component would require either at configuration time or at runtime. Fiorano already provides some standard libraries (some of them being Third Party), which can be directly added to the list of dependencies for a component. If there is a library which is needed only for a particular component, it can be added exclusively for that component, which is explained further.

Microservice Repository helps to add dependencies to an existing component as shown in Figure 5 and explained in more detail later in this section. You can right-click the component for which you need to add a dependency and select Edit (as shown in Figure 6 and 7). The dialog shows two sections:

• The first section is where you add dependencies which are applicable only for a particular component. A copy of the dependency library is kept with the component.
• The second section is where you add dependencies which are already registered with Fiorano. These are called system libraries. In this case a copy of library is not added the component. There is reference created in the component to locate where to find the dependency library files.

Figure 5: Explorer view of Fiorano eStudio showing the component repository

Viewing the Resources of a Component

To view the resources of a component, right-click on the component and choose Edit from the drop-down menu.


Figure 6: Using the Edit option to add resources using the Fiorano Studio

In the ServiceDescriptor.xml window, the Deployment section (last tab present at the lower-left part of the screen) carries the resources and dependencies of the SMTP component as an example.

Figure 7: List of dependencies and resources of SMTP component

Add New Library Dependencies

There are system libraries which are already registered with the Fiorano Enterpriser Server as dependencies to each service/component. New dependency libraries and resources can be added as mentioned in the below sections.

Adding Service Dependencies

To add a Service Dependency to a particular component from the dependencies already registered with the Fiorano Enterprise Server, click Add/Remove button present under Service Dependencies section (see Figure 14 above). This gives a list of exiting services from which dependencies can be added.

Figure 8: List of dependencies that can be added to the existing dependencies of the component

The following table lists the system libraries developed by Fiorano to use within component implementations. 

Adding New Resource

To add new resources to a component, click Add button present under Resource section (see the figure above) and select the file from the location where it is saved.

Component Classpath Generation

1. Add Component_Home directory, a Depth First Traversal of the dependency tree of component is carried out.
2. All resources of the leaf node of dependency tree added in the following fashion:
   1. If the dependency directory contains any required resource other than java archive such as jar/zip, the directory is added; then, all available java archive files are added
   2. At the end, the fmq client jar, the licenses dir, the xml-catalog dir and the server profiles dir is added.

Example:

Figure 9: Component Classpath Generation example

.../fmq-rtl.jar (addition order 11)
.../licenses (addition order 12)
.../xml-catalog (addition order 13)
.../esb/server/profiles (addition order 14)

Legend:

1. {} – enclosed elements are all java archives
2. [] – enclosed elements are all non-java archives like .properties file etc.
   
   

Configuring Logging Parameters

For every service component, the log settings can be configured in the Properties window. For a chosen service instance, the log settings are available under the categories Log Manager and Log Module Instances.

Figure 11: Log Module Instances

For every log module, the log level can be configured from the drop down list. The different log levels at which the details can be logged are Severe, Warning, Info, Config, Fine, Finer, Finest and All.

Figure 12: Log levels

Severe is the highest logging level and All the lowest. A log module accepts all messages that are logged at the levels greater than or equal to the configured level. That is, if the configured log level for a log module is Severe, only the messages at Severe level is logged. If the specified level is Info, the messages at Info, Warning and Severe is logged. Specifying All logs the messages at all levels.

Log handlers can be configured in Log Manager as shown in the figure below.

Figure 13: Configuring Log Handler

File Handler: When the log handler is a File Handler, the logs are written to files.

Example: When an event process named 'Logging' is created and run, a directory LOGGING is created at <FIORANO_HOME>/runtimedata/PeerServers/<profile>/FPS/run/logs which in turn contains a folder for every service instance. These folders contain the files for out and error logs.

Figure 14: Log files

Console Handler: When the log handler is a Console Handler, the messages are logged on the console of the peer server on which the component is running. Figure 24 shows the logs on the peer console when the event process Logging is launched with the SMTP component configured with the log settings shown in Figure 25.

Figure 15: Log settings

Figure 16: Logs on the peer server console

Custom Handler

Service instances can be configured for custom handlers as well. Custom Log handler allows redirecting the log messages to user defined location like file, console, JMS destination, and so on.
To add the handler for the service instances that should use the custom handler,

1. In the properties pane, select Log Manager > Type as Custom Handler.
2. Specify the class for Log Manager > Class Name property. This should be a fully qualified class name.
3. Save the application.

Custom Handler implementation

The custom handler should be an instance of java.util.logging.Handler and should implement the abstract methods:

• public void publish(LogRecord record)
• public void flush()
• public void close()

This class should be made available to the peer server on which the component runs by adding appropriate classpath entry under <java.classpath> section of %FIORANO_HOME%\esb\fps\bin\fps.conf.