Skip navigation FileNet logo
  Open Client Developer's Guide
  Search  |  Index  |  Glossary   |  
Open menu Overview
Open menu Open Client Architecture
Close menu Developing for Process
  Close menu Process Overview
    Architecture/Components
    Close menu Expansions and Add-ons
      Process Analyzer
      Architecture
      Rules Engine
    Close menu Web Footprint
      Directory Contents and Structure
      Directories of Resources/Controls Used By Process
  Open menu Preparing for Development
  Open menu HTML Step and Launch Processors
  Java Processors
  Component-Integrator Work Performer
  Open menu Deploying Process Applications
Open menu Error and Exception Handling
Open menu Customizing the Framework
Globalization / Localization
Open menu General Information
   

Process Open Client Architecture/Components

The architecture of the Open Client model integrates Process services, components, and FileNet Functional Expansions and add-on components with the FileNet Open Client Web application within the context of the Microsoft .NET framework.

Subtopics include:

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:

  • Model: The Process Data Providers provide the "Model" or data layer component of the model.
  • View: The Open Client User Controls, Factory Controls, .NET server controls, .NET Web controls, and the associated .NET class library combine to provide the "View" or presentation layer component of the model.
  • Controller: The ASPX page (and its associated code-behind file) provides the "Controller" layer component of the model.

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 services-specific; that is, the figure describes the Process Open Client architecture and other components in terms of how they relate to Process Engine components and services. 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, see links below the figure.

 

Process Engine Architecture


Basic Process Components

The Process with FileNet Open Client architecture consists of the following basic server and client components (including connectors for FileNet functional expansions, add-on components, etc.); for details, click on the bulleted link:

Server Side Components

  • FileNet Open Client: Provides the Web services/application automation layer for applications and an interface with PJAC for FileNet Open Client (see next item). FileNet Open Client components include:
    • ASPX Page: Provides the Controller layer — encompasses both the View layer (incorporating the various User and other Controls that provide the user interface) and the Model layer (the XML data provided by the Data Providers) components.
    • Process Data Providers: The Process Open Client Data Providers provide the Controller layer interface to Process Engine services and also to the FileNet Image Services and Content Services client libraries by converting Image/Content/COM API Foundation objects provided by those services into either .NET objects or XML, which can then be used by the UI user controls.
    • Open Client User Controls/Control Factory Controls: Provides Open Client UI user controls and Control Factory controls that provide (in conjunction with the .NET server controls) the building blocks of the user interface "View" or presentation layer.
  • PJAC for FileNet Open Client: Provides connectivity/integration between a specific version of the Process Engine and FileNet Open Client (PJAC is also available for FileNet Web Services [ActiveX clients] or in a stand-alone configuration). PJAC components include:

    Note: PJAC components are shown in the figure above. To avoid needlessly complicating the figure, PJAC itself is not shown separately.

    • Process Java API: Runtime Process Java Application Programming Interfaces (APIs) to support interfaces between the ASPX page (via the Process Data Providers) and the Process Engine (via the Process Engine Router).
    • Process Integration Services: Provides services to enable the Java applets/applications, through the Process Java APIs, to access Foundation IDM objects from FileNet Image or Content Services. Also provides NT functions to support a unified logon.
    • JiGlue COM Bridge: Provides the interface between the COM-based Process Data Providers and the Process Java APIs.
    • Process Engine Router: Routes workflow process requests to the Pooled Process Manager (PPM) on the Process Engine.
  • Process Component Integrator: Process Engine service that enables the importing of Java components and interfaces in order to make them available in workflows. The Process Component Integrator may be used to help develop a Component Integrator-based custom work performer.
  • Java Service Adapter: A Java Service Adapter is provided with the Process Component Integrator to execute the interface to the component.
  • Java Runtime Environment (JRE): The Sun JRE (not shown in the figure) provides the Java runtime environment on both the Web server and the client (The JRE — currently JRE 1.4.0 — must reside on the client as well as the server in order for Process applets to run).
  • .NET Controls/.NET Class Libraries: Provides the standard .NET Framework controls and .NET class libraries to help customize the user interface.
  • .NET Web Form: The ASPX form that is provided in response to an HTTP request from the client.
  • Image/Content/COM API Foundation Objects: A set of Foundation COM API objects (IDMObjects) from the FileNet Image Services and/or Content Services client libraries.
  • FileNet Process Engine: Provides services that allows users to create, modify, and manage business processes (workflows). Process Engine components available for Open Client include:
    • Process Services (including PPM): Manages requests from a Process Engine router by allocating the request to the appropriate Process Engine server process.
    • Process Analyzer Connector: Provides the interface between the Process Engine and the (optional) Process Analyzer.
    • Rules Engine Integration: Provides the interface between the Process Engine and the FileNet-provided Rules daemon on the (optional) iLog Rules Engine (iLog JRules™, which resides on the Primary Process Engine server).

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 active 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 (formerly "Web WorkFlo") 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 Web Services 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 (for information, see the PJAC Installation Guide on the Process Documentation for FileNet Image Manager CD).

The PJAC installer installs the following subcomponents (shown in the figure above) for Open Client; click on the link for details:

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, and 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, also see PJAC Files for Open Client.

ASPX Page

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 general information on developing ASPX pages, 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

FneprocessBaseDP 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 FneprocessSession object to a VWSession object (needed to establish a Process session), converting an Process VWQueueElement to an FnQueueElement, and so on.
FneprocessLauncherDP

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

FneprocessPWMDP

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

FneprocessSessionDP

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 FneprocessBaseDP).

FneprocessStepProcDP

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

FneprocessUserPrefsDP

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 Step Processor User Controls.

Process Java API

Process Java API classes (on the Web Server, the Process Engine, and the client) enable Process applications (e.g., hosted by ASPX) to access Process Engine workflow services. The Process Java APIs are available for developers who wish to create a custom Process application, such as a custom Step Processor, Launch Step Processor, Work Performer, and so on. The runtime Process Java API classes are provided in 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, pw.jar should reside on every Process Engine in your environment) and also, if used, on the Process Analyzer). The pw.jar file is included with the Process Development Environment.

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.

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.

Note: In addition to the runtime Process Java API classes, etc. provided in the pw.jar file, a number of other API classes and files that relate to Process Engine operations are provided in the following JAR files:

  • vwpanel.jar — contains the "Process Java Step Processor UI Toolkit" which 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 (vwpanel.jar is included with your Process Development Environment; for additional information, see Installing the Process Development Environment - FileNet Open Client).
  • jaas.jar — contains the the Java Authentication and Authorization Service classes, used to provide user authentication.
  • xerces.jar — contains the Xerces Java XML parser files.

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:

  • Process Integration NT service: A Java process, running on the FileNet Open Client Web server, that provides the RMI interface to PJAC for Open Client, which is accessed from the client. This process also provides NT functions to support unified logon.

    Note: The Process VWServices.exe is an executable that runs as an NT service.

  • vwidmcom.dll Module: This module implements the JNI methods that provide the bridge to the Image/Content/COM IDM Foundation object.

    Note: The Process Engine router process also uses this vwidmcom.dll for encryption/decryption of the tokens.

JiGlue COM Bridge

JiGlue (pronounced "JIG-LOO") is a Multi-Threaded Apartment (MTA) COM object that serves as a COM Bridge to Process Engine services (all other Open Client IDM COM objects are Single-Threaded Apartment — STA). 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 framework) with the effect of native Java statements for nearly all Windows programming tasks. As illustrated in the figure above, the Process Data Providers require the JiGlue COM Bridge in order 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 with Open Client.

In the FileNet Open Client Process model, use of JiGlue is specified in the appropriate Process Data Provider (for example, in the FneprocessStepProcDP 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) FneprocessPWMDP 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, see Using JiGlue with ASP.NET Issues.

For information on setting up JiGlue and JiGlue programming guidelines, see Setting Up for JiGlue and JiGlue Programming Guidelines, respectively. 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, using JiGlue, VB and VBScript coding examples, etc.), see the Developing for COM Overview in the Help for Process Developers on the Process Documentation for FileNet Image Manager CD.

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 (for example, from third party or existing applications or data sources) in order to make them available in Process workflows, using the Process 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:

  • Component Manager: At runtime the Component Manager polls Component Queues for work items that request processing by Java components. The Component Manager connects a work item that is requesting a component to the Java Adapter.
  • Component Adapter (Java): A Java Service Adapter executes the interface to the component.

For a summary description, see Building a Component-Integrator-based Work Performer. For a more detailed description and usage examples, see Building a Component Integrator-based Work Performer in the Help for Process Developers on the Process Documentation for FileNet Image Manager CD.

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:

  • JiGlue
  • IDM Services
  • VWLaunch (C with JNI)
  • Process Router

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. For information on whick JDK/JRE to use and how to configure your JRE for Process development, see Configuring the Java Runtime Environment (JRE). 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 > eProcess Services > Products - Compatibility & Dependency > Process Compatibility/Dependency/Hardware Matrix).

Note: 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.

.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 (formerly called "WorkFlo Services") 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 Process Analyzer Connector provides the interface between the Process Engine and the (optional Functional Expansion) Process Analyzer Engine. This Connector provides event, process, resources, and XML configuration data to the Data Collector on the Process Analyzer Engine. For additional information and a figure that illustrates these components, see Process Analyzer Usage and Process Analyzer Architecture.

Rules Engine Integration

Integration with the iLog Rules Engine is accomplished via workflow definitions (created by the Process Designer on the client). The workflow definitions contain calls to rule sets that are provided to the VWRules shared library on the Process Engine. The VWRules library on the Process Engine provides the interface with the FileNet-provided Rules daemon on the iLog Rules Engine (iLog JRules™), which resides on the Primary Process Engine server. For additional information and a figure that illustrates these components, see Rules Engine Usage and Rules Engine Architecture.

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: Opens the browser popup windows.
  • Process Java API: A set of Java Application Programming Interfaces (APIs) to support interfaces between the ASPX page (via the Process Data Providers) and the Process Engine.

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:

  • Document Popups
    • Open
    • View
    • ShowPropertiesDialog
    • CheckoutOpen
    • CancelCheckout
    • Checkin
    • ShowVersionListWindow
  • Folder Popups
    • ShowPropertiesDialog
    • Open
  • Stored Search Popups
    • ShowPropertiesDialog
    • Open

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:

  • Runtime APIs: Used to create session objects, retrieve work objects, query queues, retrieve Step Processor information, attachments, and to perform other workflow-related operations.
  • Workflow Definition APIs: Used to create, modify, and validate workflow definitions.
  • Administration and Configuration APIs: Used to define and modify queues, rosters, logs, Step Processor operations, Step Processor information, indexes, exposed system fields, and user information.

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 in the Help for Process Developers on the Process Documentation for FileNet Image Manager CD. For information on the Java Step Processor UI Toolkit, see Building a Step Processor with the Java Step Processor UI Toolkit in the Help for Process Developers on the Process Documentation for FileNet Image Manager CD.

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 (for details, click on the bulleted link):

  • Process Analyzer: Provides analysis of Process workflow data by leveraging OLAP technology (On-Line-Analytical Processing) to enable users to "slice and dice" data collected by the Process Engine. Process analysis enables users to isolate problems, control the data elements being reviewed, and generate useful chart-based reports. The Process Engine provides event, process, resources, and XML configuration data to the Data Collector on the Process Analyzer Engine. The Process Analysis Data Collector, in turn, stores these in a MS SQL Server data warehouse on the Process Analyzer Engine. Data from a SQL Server data mart is imported and aggregated in an OLAP cube by the OLAP server (also on the Process Analyzer Engine). Analysis and reporting information from the OLAP cube is then provided in response to a query from an MS Excel client.
  • Rules Engine: The Process Engine comes with FileNet-provided integration built-in for the iLog Rules Engine (iLog JRules™), which may be independently added (FileNet does not provide the iLog Rules Engine) to provide an add-on capability that enables business rules to be independently applied to workflows.

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:

  • RMI — Java Remote Method Invocation (RMI) is a protocol which enables the user to create and access the methods of remote Java objects in a distributed environment. RMI is used to access Java methods distributed between the Process Java APIs on the client and on the Web server. RMI is also used to enable creation and instantiation of Process Java API objects on the Web server and the PPM on the Process Engine (via the Process Engine router).
  • COM — ASPX-hosted Process applications use Component Object Model (COM) interfaces to access Image/Content/COM IDM Foundation objects and also (via the JiGlue COM Bridge) to access Process Java API objects.
  • HTTP — Hypertext Transfer Protocol (HTTP) is used for Web communications. For Process applications for FileNet Open Client, the .NET Web Form is provided from the ASPX page in response to an HTTP request from the browser on the client.
  • JNI — Java Native Interface (JNI) is a standard programming interface for writing Java native methods and embedding the Java VM into native applications. The Process Integration Services module implements the JNI methods that provide the bridge to the Image/Content/COM IDM Foundation objects retrieved from FileNet Image and/or Content services. JNI is also used to implement the JNI methods that provide the interface between the JiGlue COM Bridge and the Process Java APIs.
  • RPC — Remote Procedure Call (RPC). The Image/Content/COM IDM Foundation objects are retrieved via RPCs from the FileNet Image Services and FileNet Content Services servers.