![]() ![]() |
|
Open Client Developer's Guide | |
Search | Index | Glossary | | |
![]() |
|
![]() |
![]() |
![]() |
Process Open Client Architecture/ComponentsThe 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 ClientThe 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 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.
Basic Process ComponentsThe 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 ClientFileNet 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 ClientThe 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).
ASPX PageIn 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 ProvidersThe 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:
Open Client User Controls / Control Factory ControlsThe 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).
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 APIProcess 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.
Process Integration ServicesAs 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 BridgeJiGlue (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.
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.
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 RouterThe 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 IntegratorThe 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:
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:
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).
.NET Controls/.NET Class LibrariesIn 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 FormThe .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 ObjectsA 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 EngineThe 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 ConnectorThe 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 IntegrationIntegration 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 ComponentsWhen 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 APIAs 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 APIThe 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 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 ComponentsThe 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 Engine Communication ProtocolsAs 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:
|
![]() |
|