Process Engine Architecture/Components - FileNet Open Client

This topic provides an architectural overview of the integration of Process services and functions with the FileNet Open Client web application within the context of the Microsoft ASP.NET™ platform technology. This integrated framework allows customers and developers to use the out-of-the-box ASP.NET-based FileNet Open Client Personal Workflow Manager (or User Inbox), Step Processor, and Launch Step Processor that come with the Open Client installation, or you may customize these applets as required (source code is provided with the FileNet Open Client installation). The ASPX top-level pages host the Process modules so that they can be launched either from the FileNet Open Client web application or via email notification messages.

Process Engine Architecture - FileNet Open Client

The following figure illustrates the Process Engine architecture and its interfaces with the web server and other FileNet components within the context of the .NET platform. The architecture for the FileNet Open Client Process model is based upon the "MVC" model, where:

The FileNet Open Client framework provides a nearly seamless integration, except that the Process Designer, Linker, Tracker, Step Processor, Launch Step Processor, Administration, and Configuration must run in browser popup windows (by invoking JavaScript APIs on the client to open the popup windows). A .js file contains the JavaScript API methods used to open the popup window (see figure below).

This figure is Process Engine-specific; that is, the figure describes the Process Engine architecture and other components in terms of how they relate to Process Engine components and operations. Although environments can be set up with multiple Process Engines (a Primary Process Engine and Additional Process Engine servers), for the sake of simplicity, this figure illustrates a single Primary Process Engine configuration. For additional information on the Process Engine's components and communications access protocols shown in the figure, see below.

 

Process Engine Architecture


Basic Process Components

The Process with FileNet Open Client architecture consists of the server-side components and client-side components (including connectors for FileNet functional expansions, add-on components, etc.).

Note: Not shown in the figure above (for simplicity) is the Sun JRE, which provides the Java runtime environment on the web server, the Process Engine, and the client. For details, see Java Runtime Environment (JRE) below.

Server-side Components

FileNet Open Client

FileNet Open Client is a web application that provides a web services automation layer between an ASP.NET-based Process application (via PJAC for FileNet Open Client) and a client (via the web server [e.g., MS IIS, etc.]). FileNet Open Client automatically downloads the Process Java APIs, the Process applets, the client-side JavaScript API (to open popup windows), and the JRE to the client, the first time the client accesses FileNet Open Client services on the web server.

FileNet Open Client includes the following subcomponents (as shown in the figure above); click on the link for details:

To access an ASPX-hosted application in a web browser on the client, a user logs into the web server and either launches a workflow or participates in an already-running workflow, e.g., by opening an Open Client HTML or Java Step Processor application. Client HTTP requests that do not require interaction with the Process Engine via a Java applet/application are passed to the FileNet Open Client services and PJAC for FileNet Open Client components, which send them via the Process Java APIs and the JiGlue COM Bridge to the ASPX-hosted application. For a description of what happens when a client uses a Process Java applet or application, see Client-side Components below.

If a Process applet/application on the client requests IDM objects from FileNet Image or Content Services (e.g., attachments needed for a step in a workflow), FileNet Open Client services retrieve them via Remote Procedure Calls (RPCs) to the FileNet Image Services server and/or the FileNet Content Services server and provide the web services to make them available to the client.

PJAC for FileNet Open Client

The Process Java Applets Connectivity (PJAC) component combines Java with an interface to the automation layer of FileNet Open Client to provide integration and connectivity between FileNet Open Client and the Process Engine. (Alternatively, PJAC may be used to provide connectivity for FileNet Open Client or in a stand-alone configuration where you are not using a FileNet web application). PJAC is installed by running the PJAC installer on the web server.

The PJAC installer installs the following subcomponents (shown in the figure above) for Open Client:

A number of PJAC versions may be provided with your installation. Each PJAC version (on the web server) provides connectivity/integration between a specific version of the Process Engine and a specific FileNet Open Client version. For example, the PJAC for FileNet Open Client 2.0.1 module provides integration/connectivity between Process Engine 2.0.1 and FileNet Open Client versions 3.2x and 3.3. Or PJAC may be installed in stand-alone mode where you are not using a FileNet web application and simply require connectivity to the Process Engine. For additional information, see Process Java Applets Connectivity (PJAC).

Note PJAC for FileNet Open Client provides the runtime Process Java APIs, the JRE, the JiGlue COM Bridge, the Process Services Manager. PJAC for Open Client does not provide shared ASPX, ASCX, JSP, etc. files which may be referenced by a custom Process application (these are provided with the FileNet Open Client web application); for additional information, see PJAC Files for Open Client.

ASPX Page

A key difference between standard ASP pages and the more object-oriented ASPX pages is that whereas a standard .asp page does not yield modularized code (both HTML and Script are included in a single page), an ASPX page allows you to divorce presentation code from the business logic code, where presentation is typically provided in the .aspx page and business logic is provided in its associated "code-behind" file (see Note).

Note: For those familar with ASP, but who are new to creating ASPX pages, each ASPX page (for example, created using Visual Studio) has an associated equivalent class written in a .NET compliant language, such as VB.NET, C#, C++, Managed C++, JavaScript, and so on (FileNet Open Client source code uses VB.NET). This class consists of event handlers, initialization code, and other supporting code for the user interface in the ASPX file. The .aspx.vb file that holds this class is called the "code-behind" file and provides the ASPX file's programmatic implementation.

In the FileNet Open Client Process model, the ASPX page provides the "Controller" layer component of the model. The ASPX page encompasses both the View layer (the various User, Factory, and other Controls that provide the user interface) and the Model layer (XML data supplied by the Data Providers to the ASPX page via XSLT transformation), which have been separately provided. As with all standard ASPX pages, the ASPX page for an Open Client Process application incorporates server controls (for example, the start of the page <BODY> section typically includes the Runat="server" control).

The ASPX page is compiled and instantiated when first requested by the client via an HTTP request. The .NET Web Form (see below), which is the resulting .aspx form, is returned to the client and is also cached on the Web server for reuse.

For information on developing ASPX pages for Process applications, see Developing ASPX Pages for FileNet Open Client.

Process Data Providers

The Process Data Providers are a set of VB.NET classes (.vb files) that are used to provide the Controller layer interface to Process Engine services, such as VWSession, Step elements, etc. In addition, Open Client Data Providers retrieve Image/Content/COM IDM Foundation objects (IDMObjects) instantiated from the Images Services client library via the FileNet Images Services server and from the Content Services client library via the FileNet Content Services server. The Data Providers invoke Open Client Web and Process COM objects to produce either .NET objects or XML data, so that they can be used by the Open Client UI user controls. In effect, the Process Data Providers essentially encapsulate and mask the UI user control interface to Process Engine services, as well as to the Image/Content/COM IDM Foundation objects.

Process-specific Data Providers are used to provide Process-related functionality as follows:

Process DP Class

Description

FnProcessBaseDP The base Process Data Provider abstract class (inherits FnBase). This class also includes Open Client wrapper classes for corresponding Process Data Provider classes to provide Process-related functionality, such as setting an FnProcessSession object to a VWSession object (needed to establish a Process session), converting an Process VWQueueElement to an FnQueueElement, and so on.
FnProcessLauncherDP

Process public class Data Provider to provide Process Launcher functionality (inherits FnProcessBaseDP).

FnProcessPWMDP

Process public class Data Provider to provide Process Personal Work Manager functionality (inherits FnProcessBaseDP).

FnProcessSessionDP

Process public class Data Provider to handle Process authentication, unified logon (so the user does not have to logon more than once) and logoff (inherits FnProcessBaseDP).

FnProcessStepProcDP

Process public class Data Provider to provide Process Step Processor and Launch Step Processor functionality (inherits FnProcessBaseDP).

FnProcessUserPrefsDP

Process public class Data Provider to provide base Process user preferences support and integration (inherits FnBase).

Open Client User Controls / Control Factory Controls

The Open Client User Controls are a set of VB.NET .ascx files provided by FileNet that, in conjunction with the FileNet Open Client Control Factory controls and the .NET server controls (and associated .NET classes), provide the building blocks of the Open Client user interface (the "View" part of the MVC model).

Note In some cases, a User Control is similar to a subpage that encapsulates both user interface and logic; i.e., in these cases, the User Control is more like a Controller component than a View component.

A key advantage of User Controls is that they are reusable; that is, Open Client User Controls are reusable, object-oriented, event-driven controls that can be loaded either into ASPX pages or into other User Controls. FileNet Open Client User Controls either display the data, or they represent available operations for the displayed data, or some combination of these. Each User Control defines its data format (for example, XML for Process-related controls).

For basic information on using Process User Controls when developing an ASP.NET-based Step Processor, see Developing an Open Client HTML Step Processor. For additional information, see the description of Open Client User Controls and Control Factory Controls in the FileNet Open Client Developer's Guide.

Process Java API

The runtime Process Java API classes are provided in the pw.jar file, which is included with the Process Development Environment. The pw.jar file also contains the Process client classes, Task Manager classes, third party classes [e.g., for Xerces], etc. The pw.jar file should reside on the Process Engine (if there is more than Process Engine server, the file should reside on every Process Engine in your environment) and also, if used, on the Process Analyzer).

Process applications for FileNet Open Client require a JRE on the web server, the Process Engine (on the Primary Process Engine and on each Additional Process Engine), and on each client machine, respectively (the JRE is automatically downloaded the first time the client accesses FileNet Open Client). For additional information, see Java Runtime Environment (JRE) below.

In addition to the runtime Process Java API classes, a number of other API classes and files that relate to Process Engine operations are provided in .jar files with your installation. These include:

In order to use the Process Java APIs on a .NET-compliant platform, you will need to use the JiGlue COM Bridge (allows you to make COM-based calls equivalent to native Java statements). For additional information, see JiGlue COM Bridge below.

Process Integration Services

As with the Process Engine with FileNet Web Services model, in the FileNet Open Client Process model, the Process Integration Services module serves requests from a Java application or applet (via the Process Java APIs) to enable the Java applet/application to access Image/Content/COM IDM Foundation objects from FileNet Image or Content Services. The Process Integration Services module manages these requests and implements the JNI methods that provide the bridge to the IDM Foundation objects. For example, the Process Integration Services interface enables the Process Designer on the client to retrieve top-level folders from the FileNet Content Services library for initial UI display.

To enable this integration, the Process Integration Services module provides the following services:

JiGlue COM Bridge

JiGlue is a COM object that serves as a COM Bridge to Process Engine services. JiGlue provides a translation layer between the Process Java APIs and COM. In other words, using the JiGlue COM Bridge provides the ability to make calls (for example, in VB.NET within the ASP.NET context) with the effect of native Java statements for nearly all Windows programming tasks. As illustrated in the figure above, the Process Data Providers use the JiGlue COM Bridge to interface to the Process Java APIs.

Note The Sun Java Runtime Environment (JRE is not shown in the figure above) must be installed in its default directory in order for JiGlue to work properly.

In the FileNet Open Client Process model, use of JiGlue is specified in the appropriate Process Data Provider (for example, in the FnProcessStepProcDP Data Provider for the out-of-the-box HTML Step Processor). This is done in order to insulate the ASPX page and the User Controls from JiGlue and the Process Engine server. When developing a custom Process application with FileNet Open Client, you should not reference JiGlue outside the Process Data Provider.

For example, a typical Process-related use of JiGlue might be to use it to enable the Open Client's PWM (Personal Work Manager) FnProcessPWMDP Data Provider to retrieve items from the "Inbox" queue and provide them to the presentation layer. Another use might be to use JiGlue to dimension and instantiate a Process VWSession object and logon (you need to create and instantiate a Process session object in order to perform nearly all Process Engine-related operations), and so on.

Caution There are a number of known issues related to using JiGlue with ASP.NET. For information on these JiGlue .NET-related issues and development guidelines, see Using JiGlue with ASP.NET - Issues and Guidelines.

For additional general information on JiGlue (including guidelines on developing Process applications for COM, an overview of the JiGlue COM Bridge, setting up and developing for JiGlue, conversions between COM data types and Java data types, etc.), see Developing for COM Overview.

Process Engine Router

The Process Engine Router (on the web server) is used to route and access objects and services to the Process Engine. The interface to Process Engine Java API methods is accomplished through the router via the RMI protocol (see Process Engine Communication Protocols). A Process Engine Router can route to more than one Process Engine and you may install a Process Engine Router anywhere you need to interface to a Process Engine. If there are multiple Process Engines in your environment, the Process Engine Router will route the request to the appropriate Process Engine. Typically, the Process Engine Router is installed on the web server, where it acts as an RMI server (see Process Engine Communication Protocols) to route workflow event process requests to the Pooled Process Manager (PPM) on the Process Engine. For example, when a Step Processor application makes a workflow-related request, the Process Engine Router (on the web server) receives the request and routes it via RMI to the PPM on the Process Engine server. The PPM responds to the API call by either starting a Process Engine process or allocating the request to an existing process.

Process Component Integrator

The Process Component Integrator is a service (runs on the web server) that provides application integration by enabling the importing of simple Java components and interfaces in order to make them available in Process workflows, using the Process Engine Configuration Console, Designer, and Task Manager tools. The Process Component Integrator may be used to help develop a custom Process work performer. The Component Integrator contains the following modules:

For additional information, see Building a Component Integrator-based Work Performer.

Java Runtime Environment (JRE)

Process applications for FileNet Open Client Process require a Sun JRE (not shown in the figure) on the web server, the Process Engine (on the Primary Process Engine and on each Additional Process Engine), the Process Analyzer (if present), and on each client machine, respectively (the appropriate JRE is automatically downloaded the first time the client accesses FileNet Open Client).

On the Open Client server, PJAC installs the Sun JDK 1.3.1. The JRE provides the runtime environment for the following components:

On the client, JRE provides the runtime environment support for the Java Plug-in.

When setting up for Open Client, be sure to install JRE in its default directory in order to ensure that JiGlue (provides the COM Bridge between the Open Client Data Providers and Process services) works correctly; for details, see JiGlue COM Bridge below.

Note This assumes a Windows OS. If you are running FileNet Open Client on an AIX, HP-UX, or Solaris web server, use JRE 1.3.0 instead of JRE 1.3.1. However, be aware that JRE 1.3.0 cannot be used with Process VWServices because the processes invoked by this service are killed when the user logs off the server.

For the latest information on which JRE versions are supported for Process services, see the Process Compatibility/Dependency/Server Matrix document, located at http://www.css.filenet.com web site (go to Product Tech Info > Process Services > Products - Compatibility & Dependency > Process Compatibility/Dependency/Hardware Matrix).

.NET Controls/.NET Class Libraries

In addition to the FileNet Open Client user controls (both Process-specific and non-Process-specific), developers can also use the standard .NET controls and .NET class libraries to help customize the user interface defined in the ASPX page. The .NET Framework comprises over 3,400 standard classes that you can also apply to the ASPX page in order to help customize the user interface (by comparison for those new to the .NET platform, there are seven standard objects built-in in an ordinary ASP Framework — the Application, ASPError, ObjectContext, Request, Response, Server, and Session objects). Normally, you would use the .NET controls and classes in those instances where the presentation element was not already provided by an available FileNet Open Client user control.

For additional information on ASP.NET controls, see http://www.microsoft.com/net.

.NET Web Form

The .NET Web Form is the ASPX form that is provided to the client in response to a client HTTP form request. When an ASPX page is first requested, it is compiled and cached on the server. The .NET Web Form is the container of the Model and View layers provided to the client. The .NET Web Form comprises both the ASPX page and its related "code-behind file", written in a .NET-compliant language (for the Process Open Client samples provided with Open Client, in VB.NET), that provides event handlers, initialization code, and other supporting code for the user interface in the ASPX file.

Image/Content/COM API Foundation Objects

A set of Web API (Foundation) COM objects (IDMObjects) are provided from the Images Services client library via the FileNet Image Services server and/or the Content Services client library via the FileNet Content Services server. These objects are provided for the purpose of retrieving or updating folder content, document properties, and attachments from those libraries for workflow items.

These Image/Content/COM IDM objects are retrieved via Remote Procedure Calls (RPCs) and are provided to Open Client Data Providers, which invoke the COM objects to render them as either .NET objects or XML data so that they can be used by the Open Client UI User Controls.

FileNet Process Engine

The Process Engine is the FileNet component that allows users to create, modify, and manage business processes (workflows) implemented by applications, enterprise users, or external users (such as partners and customers). For FileNet Image Manager (including FileNet Open Client), the Process Engine is currently supported on MS Windows 2000 and the following Unix platforms: Solaris, HP-UX, and AIX.

The Process Engine consists of the following subcomponents (shown in the figure above); click on the link for details:

Process Services (including PPM)

The Pooled Process Manager (PPM) on the Process Engine manages workflow requests that it receives from a Process Engine Router. The PPM either starts a Process Engine process (VWJ process) for the request, or it allocates the request to an existing process. The PPM will balance the load between VWJ processes; that is, if the existing VWJ process is busy, the PPM will start another process. Note that in a multiserver configuration, the PPM on each Process Engine server (that is, the Primary Process Engine server and each additional Process Engine server) must be running.

Process Analyzer Connector

The optional Process Analyzer provides a way to easily generate chart-based reports based on statistical information gathered from the Process Engine. The Process Analyzer Connector provides the interface between the Process Engine and the Process Analyzer Engine. This Connector provides event, process, resource, and XML configuration data to the Data Collector on the Process Analyzer Engine. The Process Analysis Data Collector, in turn, stores this data in a SQL Server data warehouse on the Process Analyzer Engine. For additional information, see Process Analyzer User Guide and Process Analyzer Configuration and Administration.

Rules Engine Integration

Integration with the iLog Rules Engine is accomplished via workflow definitions. The workflow definitions contain calls to rule sets defined with the iLog Rules Editor on the Rules Engine client. The VWRules shared library on the Process Engine provides the interface with the FileNet-provided Rules daemon on the iLog Rules Engine. For additional information, see Using Rules Engine.

Client-side Components

When the client accesses FileNet Open Client for the first time, a package containing the Sun JRE and the Process pw.jar file is downloaded to the client. The JRE (not shown in the figure above) provides the runtime environment support for the Java Plug-in and must be on the client in order to run a Process Open Client applet/application.The Process Open Client components that reside on the client include:

JavaScript API

As previously indicated, the Process Designer, Linker, Tracker, Step Processor, Launch Step Processor, Admin, and Config run in browser popup windows (these invoke JavaScript APIs on the client to open the popup windows). A JavaScript file, FnWindowHelper.js, contains the JavaScript methods used to open the popup window. The JavaScript API methods allow the Processor to invoke the following Open Client popups:

Process Java API

The Process Java API classes provide access to the Process Engine server workflows and workflow items (RMI is used to access Java methods distributed between the Process Java APIs on the client and the web server). The Process Java API enables you to access the runtime, administration, configuration, and workflow functionality supported in the Process server, as follows:

In addition to customizing the Open Client user interface for ASP.NET Step Processors, for those who wish to use Java to customize the user interface, the Java Step Processor UI Toolkit provides Java Swing-based interfaces and beans that are used to provide the user controls for the Java Step Processor and Launch Step Processor samples provided with the Process Development Environment with your PJAC installation.

For additional information on the Process Java APIs, see Using Process Java API Classes. For information on the Java Step Processor UI Toolkit, see Building a Step Processor with the Java Step Processor UI Toolkit.

FileNet P8 Functional Expansions and Add-on Components

The following FileNet functional expansions and add-on components are optionally available as additional features to enhance current FileNet Open Client Process capabilities and functionality:

Process Engine Communication Protocols

As indicated in the above figure, communication and interaction between Process Engine components, other (non-Process) FileNet components and other (non-FileNet) applications or services are accomplished via one or more of the following communication protocols: