IBM FileNet P8, Version 5.2.1            

Getting Started

The Content Engine APIs are platform-independent APIs for building applications that access and manipulate objects that are stored on a FileNet® Content Platform Engine server. Three main application types are supported by the Content Engine APIs: run time, administration, and metadata authoring. Runtime applications interact with object stores and documents, administration applications perform configuration tasks, and metadata authoring applications create class definitions and properties. The APIs expose all of the operations that are supported by the Content Engine server. Using the Content Engine APIs, you can create applications that address all of these application types.

Important: In the development of your applications, use only the exposed classes and interfaces that are documented in the Content Engine Java™ and .NET API reference help, except for those that are marked in the reference help as internal use only. The exposed classes and interfaces in the Java API are those in subpackages of com.filenet.api. The exposed classes and interfaces in the .NET API are in subnamespaces of FileNet.Api. Do not use the internal, non-exposed classes and interfaces; that is, those marked in the reference help as internal use only, and those not documented in the API reference help. In particular, do not use any classes or interfaces in Java subpackages of com.filenet.apiimpl or .NET subnamespaces of FileNet.Apiimpl. Non-exposed classes and interfaces are subject to change at any time and without notice. Their use is not supported.

Developer Requirements

To begin your development, you must have certain versions of the framework software that support your development environment and language. See the following topics for the steps you need to take for setting up various development environments:

The Sample IDE Setups topic contains samples that show you how to set up integrated development environment (IDE) projects for client FileNet P8 application development. Samples are provided for the Eclipse IDE and the Microsoft Visual Studio IDE and address development environments on all of the supported application servers.

Content Engine API Compatibility with Server Versions

Client applications that use version N of the Content Engine APIs are supported against Content Platform Engine server version N and version N+1. This API support policy does not extend to server versions N+2 or higher. An application that uses a newer API version is not supported against an older server version.

To ensure compatibility with new Content Platform Engine server versions, it is recommended that client applications use the Content Engine Client Download Service. The Content Engine Client Download Service enables you to build version-compatibility checks and automatic updates into client applications. For more information, see Content Engine Client Download Service.

Starting with the 5.2.1 version of the Content Platform Engine server, the Content Engine Java API includes the Cross-Release Class Loading (CRCL) feature, allowing a single instance of a Java application to connect to multiple Content Platform Engine server releases simultaneously, including server versions that are older than the application's Content Engine API. For more information, see Developing a Cross-Release Application.

Finding Required Files

You can get the development-support files by running the Content Platform Engine Client Installer, which is included with the Content Platform Engine. To install the Content Engine Client files that you need for application development, select the Other Applications option from the installer's Select FileNet P8 Applications window.

Required Java and .NET Versions

The Content Engine APIs require certain minimum levels of the Java 2 Standard Edition (J2SE) and Microsoft .NET Framework environments. For information on these requirements, see IBM® FileNet P8 Hardware and Software Requirements.

Required Java Archive (JAR) Files

The Content Engine Java API requires several other JAR files (including third-party JAR files) during run time. The required JAR files are installed with the Application Engine software. The supplied versions of these JAR files are required; do not substitute other copies of JAR files with the same names. (For specific installation instructions for your environment, see Installing or upgrading IBM FileNet P8.) If you are writing a stand-alone Java application that uses the Content Engine Java API, the required JAR files must be in your class path. A missing JAR file can lead to errors and "class not found" exceptions. The following table lists the required JAR files according to your transport option, Content Engine Web Service (CEWS) or Enterprise JavaBeans (EJB).

.jar File Description
Required for a Content Engine Java API CEWS transport client
Jace.jar The core FileNet JAR file for the Content Engine Java API.
log4j.jar The LOG4J framework for Content Engine Java API logging. You can also use the identical log4j-<version>.jar file, where <version> is the supported version that is installed with the FileNet P8 Platform software. Example: log4j-1.2.14.jar.
stax-api.jar Provides CEWS transport support.
xlxpScanner.jar Provides CEWS transport support.
xlxpScannerUtils.jar Provides CEWS transport support.
p8cel10n.jar Provides localized exception messages for the Content Engine server and the Content Engine Java API. The p8cel10n.jar file must be from the same Content Engine version as Jace.jar.

For a client application, this JAR file is required to receive exception messages in the language of the client's locale. If this JAR file is omitted from the client runtime environment, then exception messages display in English.

Required for a Content Engine Java API EJB transport client
Jace.jar The core FileNet JAR file for the Content Engine Java API.
log4j.jar The LOG4J framework for Content Engine Java API logging. You can also use the identical log4j-<version>.jar file, where <version> is the supported version that is installed with the FileNet P8Platform software. Example: log4j-1.2.14.jar.
p8cel10n.jar Provides localized exception messages for the Content Engine server and the Content Engine Java API. The p8cel10n.jar file must be from the same Content Engine version as Jace.jar.

For a client application, this JAR file is required to receive exception messages in the language of the client's locale. If this JAR file is omitted from the client runtime environment, then exception messages display in English.

One or more application server-specific .jar files If these JAR files are already in an application server, they are not required. They are required only if you are using a stand-alone JVM.
Required for a Content Java API Compatibility Layer client
javaapi.jar The class implementation files for the Content Java API compatibility layer.
p8cjares.jar The localizable resource strings for Content Engine Java API compatibility layer classes.
listener.jar FileNet P8 System Manager listener API. Required only if you are developing a System Manager logging client or if you want the compatibility layer API to do System Manager performance monitoring. The compatibility layer uses the file if present; otherwise, it is ignored. (For information about System Manager logging, see FileNet System Manager Help for Developers.)
All .jar files for a Content Engine Java API client of the applicable transport. See the previous sections for your transport.

Required .NET Components

The Content Engine .NET API supports Microsoft Windows Communication Foundation (WCF) and maintains compatibility with earlier versions of Microsoft Web Services Extensions (WSE) 3.0. However, WSE support is deprecated and support will be discontinued in a future release. For this reason, continued use of WSE is discouraged.

If you have applications that were developed for a .NET Framework with WSE that you want to run in a .NET Framework 3.0 with WCF, you must update their authentication mechanisms. For more information, see Upgrading Custom Applications.

To begin development with the Content Engine .NET API, you install the Microsoft .NET Framework 3.0 or later (WCF is built in to this framework). This environment allows you to create your own custom applications.

To develop applications that use the Microsoft Visual Studio .NET API, you must first add a reference in your project to the .NET API. In the Visual Studio Add Reference dialog, select the Browse tab and navigate to <drive>:\Program Files\FileNet\Content Engine\. From this folder, select the entry FileNet.Api.dll and click OK. You can now use the Content Engine .NET API from your project.

Java Packages and .NET Namespaces

Usually, public Java packages and .NET namespaces map to one another in functionality. However, where the functionality of a Java package has no equivalent in the .NET environment, or vice versa, the column is marked as N/A (not applicable). The following table lists the Java packages and .NET namespaces, with brief descriptions.

Java Package .NET Namespace Notes®
com.filenet.api.action FileNet.Api.Action Classes that are related to changing to objects.
com.filenet.api.admin FileNet.Api.Admin Classes and interfaces that are used in the administration of a Content Engine server.
N/A FileNet.Api.Authentication Classes and interfaces that allow applications to run in either a .NET framework 2.0 with Microsoft Web Services Extensions (WSE) 3.0 or a .NET Framework 3.0 with Microsoft Windows Communication Foundation (WCF) environment.
com.filenet.api.collection FileNet.Api.Collection Type-safe interfaces related to collections of objects.
com.filenet.api.constants FileNet.Api.Constants Classes defining collections of related, type-safe constant values.
com.filenet.api.core FileNet.Api.Core Classes and interfaces that are related to the core business objects of the API.
com.filenet.api.engine N/A Classes and interfaces that are used when you are writing code that runs within the Content Engine server (for example, an event action). FileNet.Api.Events Event-handling framework for the Content Engine.
com.filenet.api.exception FileNet.Api.Exception Exception-reporting framework for the Content Engine.
com.filenet.api.jdbc N/A Classes that are related to using the Java Database Connectivity (JDBC) provider for the Content Engine database.
com.filenet.api.meta FileNet.Api.Meta Classes and interfaces that are related to Content Engine object property metadata. FileNet.Api.Property Classes and interfaces that are related to Content Engine object properties.
com.filenet.api.publishing FileNet.Api.Publishing Interfaces related to publishing.
com.filenet.api.query FileNet.Api.Query Classes that are related to constructing and running Content Engine searches. FileNet.Api.Security Interfaces related to authentication, authorization, and user- and group-specific data.
com.filenet.api.util FileNet.Api.Utility Utility classes and interfaces.

Transport Protocols

The Content Platform Engine supports three basic transport protocols: Enterprise Java Beans (EJB), Web Service for Content Engine and for Process Engine, and HTTP for Process Engine. The following diagram shows the interaction of these protocols with the Content Platform Engine.

Image for Content Platform Engine supported transport protocols.

The following section focuses on the transport protocols that are used by the Content Engine. For information about the Process Engine, see Process Java Developer's Guide, Process Engine Web Service, and Process Engine REST Service.


The Content Platform Engine implements its functionality through the EJB container layer of the Java Platform, Enterprise Edition application server. The EJB protocol (often RMI-IIOP based) passes serialized Java objects across the network for requests/responses to/from the Content Platform Engine server. The Content Engine Java API configured to run over the EJB transport is often the fastest interface available in FileNet P8, but relative performance is use case dependent.

The EJB Listener provides a private EJB interface (not available to API callers) to the Content Engine, and provides both local and remote interfaces. The local interface is used by Java Platform, Enterprise Edition components that are bundled with the Content Engine EAR file (deployed to the application server). The remote interface is used by a remote Java API. The EJB interface is leveraged by the Content Engine Java API. It leverages the application server provided protocols for communicating between server nodes and for providing automatic propagation of security and transaction contexts.

Content Engine Web Service

The Content Engine Web Service (CEWS) transport is based on the SOAP protocol. The CEWS transport is the only means by which the .NET API can access the Content Engine. In addition to the EJB transport, the Java API can also access the Content Engine by using the CEWS transport. Content Engine objects are represented in XML, which are serialized and passed across the network over HTTP from the client application to the Content Engine.

The CEWS Listener is implemented as a servlet that runs in the Web container layer of the Java Platform, Enterprise Edition application server. Except for transaction propagation and differences in available authentication methods, the CEWS layer exposes the same Content Engine functionality to Web service clients as the EJB layer exposes to Java clients by providing a pure Web services-based interface to the Content Engine server. The CEWS Listener forwards Web services calls to the EJB layer to access the Content Engine.

Transport Selection

You can specify either the EJB or CEWS transport when you establish a connection to the Content Engine server. A Connection object represents a logical connection to a FileNet P8 domain and holds the Universal Resource Identity (URI) for the connection. The URI carries the information that is required to establish a connection to the Content Engine server, such as the transport protocol, host, and port that is used for server communication.

A Content Engine Java API-based client determines which transport to use to communicate with the server. It selects the transport based on the URI parameter when it creates a Connection object.

See Getting a Connection for examples.

Transport Differences

There are differences to note when you are using one transport protocol versus the other:

Client Configuration

Several client-side configuration-related files are installed by the Content Engine installation process. These files have default values that you can modify with a text editor for your environment. You can programmatically change some of the values within certain files, and those changes override the value that is specified in the configuration file. For more information, see the Configuration class and the ConfigurationParameter class.

For Java applications, you are assumed to have a JAAS login context that is configured with Java Runtime Environment (JRE) in place. The Content Engine Java API depends on JAAS for authentication.

Configuration Files

Depending on whether you have a Java or a .NET client environment, you have access to specific files for configuring your client environment.

.NET configuration files

The app.config file (or web.config for ASP.NET applications) is an application-specific configuration file that contains XML statements that specify the parameters to be used for your application. (Note that the use of this file for a .NET application is optional. If this file is not present, the recommended defaults are used.) You must rename this file to match the .NET application to which it applies. For information about the app.config file, refer to the "Application Configuration Files Explained" article in the Microsoft MSDN documentation.

A section named "filenet.api" is available in which to set configuration parameters for your FileNet P8 application. The contents of the following section represent the settings for such things as the number of concurrent upload threads, block size of the content chunks to use for uploading content, trace logging options, metadata caching parameters, and so on. The keys that you use to set the values map to ConfigurationParameter enumerations. For example, the key cmc enabled maps to the ConfigurationParameter.CMC_ENABLED constant.

The following app.config file example illustrates the "filenet.api" section:

<?xml version="1.0" encoding="utf-8" ?>
     <section name="filenet.api" type="FileNet.Api.Util.FileNetConfigHandler, FileNet.Api, 
         Version=, Culture=neutral, PublicKeyToken=63fc2fb3fdeef4f1" />
     <cmc enabled="true" timetolive="3000" />
     <connection fullwsspecheaders="true" />
     <content maxuploadthreads="4" putblocksizekb="1024" getblocksizekb="32" />

You can also apply these settings globally by placing them into a system-wide machine.config file (or web.config file for ASP .NET applications). If you choose to do so, you must split the two sections (<section name="filenet.api"> and <filenet.api>) and merge them into different parts of the machine.config file. The app.config file has a <configSections> section with one entry, followed immediately by the <filenet.api> section. A machine.config file already has an existing <configSections> section that has many entries. To add this information to the machine.config file, you must insert the <section name="filenet.api"> section into the existing <configSections> area, and place the <filenet.api> section at an appropriate point that is separate from the <configSections> section. Although it does not need to be at the end of the file, it is typically placed there. For more information about the machine.config file, see your .NET developer documentation. In the following example, the <section name="filenet.api"> and <filenet.api> sections are inserted in separate locations):

      <section name=... />
      <section name=... />
      <sectionGroup name=...>
         <section name=... /> 
         <section name=... />
      <section name=... /> 
       <section name="filenet.api" type=FileNet.Api.Util.FileNetConfigHandler, FileNet.Api, Version=, 
         Culture=neutral, PublicKeyToken=63fc2fb3fdeef4f1" />
   <configProtectedData ... >
   <runtime />
</configuration> file

This file, which is optional, contains entries for setting configuration values (see the types of configuration items in the ConfigurationParameter class). The following output is an example of two cache-management entries in a file:


The API attempts to find the configuration file in the following directories in the order that is shown:

If the file is not found in one of those directories, the API tries to find it on the class path.

JAAS configuration files

The Content Engine Java API assumes that a JAAS context has been established prior to any issued requests. There is existing support for the username/password model through the UserContext class. Even when you are using that model, the client environment must include a proper JAAS configuration (the API does an internal JAAS login).

The Content Engine installation process creates a samples directory that contains samples of the JAAS configuration file for each supported application server environment: jaas.conf.WebLogic, jaas.conf.WebSphere, jaas.conf.JBoss, and jaas.conf.WSI. These sample files are not intended to be used as is. Use them as a guide in creating your own JAAS configuration. (Consult your JDK or application server documentation for precise details of creating a JAAS configuration.)

When you are using the EJB transport, the application server's normal JAAS configuration (or a site's customization of it) is sufficient. When you are using the CEWS transport, a FileNet-specific login module must be included in the JAAS configuration, whether you are establishing the JAAS login context outside of the API or you are using the legacy support in UserContext. That login module is of the following form when the CEWS transport is used:

tag {com.filenet.api.util.WSILoginModule REQUIRED;}; 

When you are using the legacy support in UserContext, you can supply a tag to indicate which JAAS stanza to use for the login. If you supply null, the API defaults to "FileNetP8". The normal overall JAAS fallback of "other" is used if "FileNetP8" is not present. You can also integrate the login module with existing JAAS configuration stanzas.

After you configure JAAS correctly, you can perform a JAAS login. For a code sample, see Obtaining a LoginContext.

JNDI configuration files

The file, which is not used with the CEWS transport, and is optional with the EJB transport, specifies the application server-specific JNDI InitialContextFactory class and provider URL. This file is a standard JNDI configuration mechanism and is not FileNet specific. If this file is not present, default values are used for its parameters. The values for the parameters can also be specified by using the java.naming.factory.initial and java.naming.provider.url system parameters.

Logging configuration files

Client API logging is controlled by an optional log4j configuration file, which might be in Java property file format or XML format ( or log4j.xml). The installer provides a sample file (which must be renamed before use). Entries from that file can also be merged with an established site configuration file for log4j.

FileNet P8 Domain

The FileNet P8 domain represents a logical grouping of physical resources (such as object stores) and the Content Engine servers that provide access to those resources. It is also associated with one or more security realms for authorizing users. The resources of the domain share common attributes, such as marking sets and AddOns. In addition to sharing common attributes, the logical grouping also provides context by which cross-object store searches and updates can be conducted. Each resource, and each Content Engine server, belongs to only one domain. A Content Engine server can access any resource in the domain, but cannot access any resource that lies outside of its associated domain. For more information about the FileNet P8 domain, refer to the FileNet P8 Domains in the Content Engine Administration help.

The Global Configuration Database (GCD) contains definitions of the common set of attributes that control functional characteristics of the collection of resources and services for the FileNet P8 domain it represents. It provides general, hierarchical object storage and contains bootstrapping data and global configuration information for the FileNet P8 domain. The GCD defines domain resources, such as sites (and their related virtual servers and server instances), object store databases, full-text index areas, fixed content storage areas, content cache areas, AddOns, marking sets, and so on.

The Content Engine running inside an application server is the primary user of the GCD to, for example, retrieve the list of object stores or the connection information for a specific object store. The installation program is also a user of the GCD, running outside of an application server, to create a new FileNet P8 domain or join an existing FileNet P8 domain. The GCD, which might contain sensitive information, is secured such that only a specified principal (typically an administrator) or group of principals has read and write access to the data contained within it. Client-side application developers have access to objects that represent objects in the GCD, such as ObjectStore, Marking, MarkingSet, and AddOn objects.

Note: If you are using distributed transactions, do not update GCD-based objects in a user-initiated transaction. Doing so is likely to cause a wait state in all threads, across all servers, until the transaction completes.

FileNet P8 Domain Structure

From the FileNet P8 domain, you can access its structure by calling methods on the Domain object. The domain's structure consists of the following entities:

Connecting to the FileNet P8 Domain

A domain connection is required to obtain a reference to any object stores within a FileNet P8 domain. A Connection object represents a logical connection to a FileNet P8 domain and contains information, such as configuration options, needed to run an operation on the Content Engine server that runs in the FileNet P8 domain.

A Connection object contains enough information to establish communication with the Content Engine server. This information is carried in a URI and includes the transport protocol (connection type), host name, and port number that are used for server communication. An incorrect configuration, such as an incompatibility between the environment and the information in the Connection object, is the most frequent cause of an exception that is related to a connection failure. For example, if the URI carried by the Connection object specifies the EJB transport protocol but an EJB JAR file is not in the class path, the API throws an exception.

You can create a Connection object by calling one of the static methods on the Factory.Connection class. See Getting a Connection for a code sample that illustrates connecting to a domain.

Multiple Domains

Your organization maintains the physical infrastructure and storage resources on which a domain depends. However, a FileNet P8 installation is not limited to a single domain; logically separate multiple domains can be set up that share physical infrastructure and resources. If your domain is a master domain, as opposed to a standard stand-alone domain, you can set up multiple domains, called tenant domains, that are managed by the master domain.

The type of a domain is indicated by its read-only DomainType property and can be one of three types: Stand-alone, master, and tenant:

For more information on multiple domain support, including important information on supported scenarios, see Multiple domain scenario.

Base Classes and Interfaces

Many of the methods available in the Content Engine APIs are exposed through inheritance. A set of base classes and interfaces provide the basic functionality that is inherited.

EngineObject class

An EngineObject object is any object that is known to the Content Engine, including objects that are outside of repositories. Examples of objects that exist outside of repositories are Domain, MarkingSet, ObjectStore, and User objects.

The EngineObject interface represents the top-level interface from which most of the other Content Engine API interfaces derive. You do not normally work directly with an EngineObject, but rather with an instance of one of its subclasses, which are further grouped into independent and dependent objects. This interface provides some base functionality, such as retrieving the Connection object that is used for communication to the Content Engine server and retrieving an object's class information and properties.

The following topics briefly describe some key subclasses of EngineObject.


An IndependentObject represents an EngineObject that has its own independent identity. Contrast this object with a DependentObject object, which is an EngineObject that can exist only within the scope of another object. An IndependentObject always has an ObjectReference, which provides identity information for the object.

An IndependentObject can be fetched from the server with a call to InstantiatingScope.fetchObject or Factory.<classname>.fetchInstance, whereas a dependent object can be fetched only by using a property of another object.


A DependentObject represents an EngineObject that can exist only within the scope of another object. Unlike an IndependentObject, which has its own independent identity, the identity and security of a dependent object are derived from that of its parent object. A dependent object can be fetched only from the server as a property of an IndependentObject and can be saved only to the server when attached as a child of an IndependentObject. An example of this dependency is ContentElement objects; a content element must be attached to a particular Document or Annotation object before it is persisted. Other examples are Permissions, PropertyDefinitions, and Choices. See the API reference help for a complete list of DependentObjects.

Each of these DependentObject types also has a corresponding list-type collection (for instance, a ContentElementList, PermissionList, and ChoiceList). A DependentObject is assigned to a DependentObjectList, and the DependentObjectList is then assigned to an IndependentObject (for instance, Document has a property, ContentElements, of type ContentElementList and ClassDescription has a property, PropertyDescriptions, of type PropertyDescriptionList).

DependentObject objects and DependentObjectList objects are not reusable. That is, a DependentObject or DependentObjectList object taken from a fetched object must not be reassigned to another object. After they are assigned to one parent object, they must not be assigned to a second parent object. For example, do not fetch the Permission objects for one object and then try to directly use those same Permission objects on another object. If you attempt such reuse, the results are unpredictable. In some cases, there might be no adverse effects. The operation might appear to succeed but give results other than what the caller expects, for example, errors when you try to save the object. In other cases, the attempted operation might fail with symptoms that are difficult to diagnose.

Any attempt to assign an already-assigned DependentObject object to another parent object causes a warning message to be written to the client trace log.


An IndependentlyPersistableObject represents a persistable IndependentObject that you can directly create, update, and delete. This interface provides some base functionality to its subinterfaces, such as modifying an object's pending actions list, updating the object's sequence number, and retrieving access right (permission) settings.


A RepositoryObject represents any object that is known to the Content Engine that resides within an object store repository. A Document object is an example of a RepositoryObject. In contrast, an EngineObject is any object that is known to the Content Engine, including objects outside of repositories (such as Domain and ObjectStore).

You do not normally work directly with a RepositoryObject, but rather with an instance of one of its subclasses.

Subscribable Object

A Subscribable object serves as the target of an event subscription, represented by an objects base on the Subscription class. Subscribable is a base interface of several derived interfaces that can be used as a subscription target. You set a Subscribable object as the target of a subscription through the SubscriptionTarget property of the Subscription object.

Containable Object

A Containable object represents the base class for all objects that can be contained. Except for the Folder object, all Containable subclasses are referentially contained. Folder objects and their subclasses can be directly contained in a Folder object, or referentially contained (see the ReferentialContainmentRelationship or DynamicReferentialContainmentRelationship classes).

Note: The use of referentially contained folders is discouraged because many applications do not expect them.

Versionable Object

A Versionable object represents the base class for classes whose instances are versionable objects. If versioning is enabled on a Versionable object (its IsVersioningEnabled property is true), it can have multiple associated versions in an object store. A versionable object can be checked out, optionally edited, and checked in as a major or a minor version. A major version is either the current released version (if it is the latest major version) or a previously released version that was superseded. A minor version is either the in-process version (if it is the latest minor version) or a previous in-process version that was superseded. When a versionable object is checked out, a reservation object is created, which you can modify. During the check-in operation, the reservation object becomes the current version of the versionable object. You can access all of a Versionable object's versions through its associated VersionSeries object or from the collection that is returned by its Versions property.

Core Objects

Core objects are objects that are related to the core business objects of the API, such as Document and Folder. The interfaces and classes that are associated with these objects are contained in the Java API core package and the .NET core namespace. Also included in the core functionality are factory classes for instantiating objects. Some of the most important of the core classes and interfaces are described in the following sections.


A Connection object holds the information that is required for an application to connect to the FileNet P8 domain and its resources. You can establish the connection by calling Factory.Connection.getConnection (Java) or Factory.Connection.GetConnection (.NET). (See Getting Started Procedures.)


An object store is an independent, domain-scoped object (that is, it is defined in the GCD). It provides access to resources: Content Engine objects such as documents, folders, custom objects, class descriptions, property descriptions, security policies, and their related metadata. It represents a location in which folders, documents, and custom objects are stored, accessed, and managed on the Content Engine server.

Using methods on the ObjectStore interface, you can create and store new objects in the object store, retrieve information about objects, and retrieve the object store's installed feature add-ons.


A folder provides access to filed objects by emulating familiar file system semantics. A Folder object is a container that can hold other containable objects, but cannot have content data of its own. Although Folder objects and their subclasses can be referentially contained, they are the only Containable subclass that can be directly contained (in a Folder). All other Containable subclasses are referentially contained by using the ReferentialContainmentRelationship or DynamicReferentialContainmentRelationship classes.

Other important folder behavior:

At the top of the container hierarchy is an automatically created root folder. A containing (parent) folder can contain multiple child folders, but a child folder can have only one parent folder. You create a directly contained folder when you call methods on a parent folder that create a subfolder.

Custom objects and documents are always referentially contained. For referentially contained objects, their containment models an N:M, or many-to-many, relationship. A folder can contain arbitrarily many containees, and a containable object can appear in arbitrarily many folders. An object can therefore appear in a folder more than once.


A Document object represents a single version of a document that is stored in a Content Engine object store. Fundamentally, a document can be thought of as two things:

A document can have zero or more associated content elements. If a document has content, the content is either stored in a Content Engine content store (referred to as a content transfer element) or stored externally (a content reference element). These elements are represented by ContentTransfer and ContentReference objects, respectively. For content-carrying documents, the Content Engine APIs support creating a document with one or more content transfer elements, one or more content reference elements, or a mix of content transfer and content reference elements.

A document can be versioned. The Content Engine supports three levels of versioning: no versioning enabled, single-level versioning, and two-level versioning. When you version a document (by checking it into a Content Engine object store), a VersionSeries object is associated with it that contains all versions of that document.


An Annotation object represents incidental information that can be attached to an object (its parent) for annotating or footnoting that object. An Annotation object allows you to link additional information to a containable object (custom object, document, or folder). You can modify and delete an annotation independently of its parent object. However, you cannot create versions of an annotation separately from its parent object. By design, an annotation is deleted whenever its parent object is deleted.

A document annotation is uniquely associated with a single document version; it is not versioned or carried forward when its associated document version is updated and a new version created.


A CustomObject object is a general object that has no inherent semantics, but is independently securable and can be persisted to an object store. Key aspects of a custom object are that it does not carry content, is not versionable, and does not support lifecycle functionality. It can be filed into a folder and can be annotated.


A workflow definition is an XML document, which is authored by using the Process Designer application, that electronically represents the sequence of steps that are required to accomplish a business process. It acts as a processing template that the Process Engine uses each time that the workflow runs. The steps represent each specific activity or task in the business process. Step specification includes: who processes the work for the step, which launch step processor application the participant uses, which attachments (documents) are required, what data is necessary, what responses the participant can choose, and other options. The routing logic specifies how work advances from one step to the next.

After the workflow definition is complete, the author typically transfers it to the Process Engine server and then saves it as a WorkflowDefinition object in a Content Engine object store. You can then link the workflow definition to a target object so the workflow can be started, either manually or by an event.

You work with a WorkflowDefinition object in the same ways you work with a Document object. Any actions that you can perform on a document can also be performed on a workflow definition: you can check it out, set its content, check it in, file it into a folder, and delete it. In addition, you can retrieve its associated WorkflowSubscription objects.


Content Engine collections are groups of related elements and can be one of two types: list or set. The name of a collection identifies its type. For example, a DocumentSet is a collection of Document objects and an IdList is a collection of Id objects. For more information, see Collections.


The Content Engine APIs provide classes that define groups of related, type-safe constant values. The class name identifies the purpose of the enumeration and the names of individual values identify their uses. For example, the CheckinType class contains MAJOR_VERSION and MINOR_VERSION constants that identify the check-in type as a major version or a minor version, respectively.


Authentication is the act of verifying a user's identity based on some credentials that they have presented. Establishing each user's identity is a critical first step in any client/server based system. FileNet P8 offers more options than just passing a username/password combination for authentication. These options are made possible by employing the Java Authentication and Authorization Service (JAAS) standard and the Web Services Security (WS-Security) standard. The JAAS standard forms the framework for security interoperability in the Java Platform, Enterprise Edition environment, whereas the WS-Security standard forms the framework for security interoperability in the heterogeneous world of clients and servers that communicate through Web services interfaces. By employing these standards, you can integrate a wide range of authentication options with FileNet P8.

Each potential Content Engine user is expected to be a security principal that is defined within an existing enterprise directory service. JAAS authenticates the user. JAAS defines an authenticated identity within a "Subject". In cases where the client of the Content Engine API is code that is already running within an application server, the client will already be authenticated and will already have an associated Subject. In cases where the client is outside of the application server, either the application, the Content Engine API, or the CEWS Listener performs a JAAS authentication with the client's credentials to generate the Subject.

After a user has been authenticated within the system, the user's identity (its JAAS Subject) must accompany each request that the user makes. (The API handles that transparently on behalf of the caller.) When the authenticated user interacts with the Content Engine server, an authorization mechanism determines the level of access (if any) that user must create, view, or manipulate objects within the system.

Obtaining a JAAS Subject

For information on how to obtain a JAAS Subject that is supported and trusted by the targeted application server, see Getting a Connection. Note that for the .NET API, the Microsoft.Web.Services3.Security.Tokens.SecurityToken class is similar to the JAAS Subject. A JAAS Subject represents a user who has been authenticated, while a Microsoft SecurityToken holds credentials that can be used to authenticate a user (by performing a JAAS login) when a CEWS request is processed on the Content Engine server.

Kerberos support

The Content Engine can use Kerberos authentication for single sign-on (SSO) in environments where JAAS is not available. For example, SSO allows an initial Windows logon to securely establish a user's identity such that subsequent logons do not require the user to provide credentials again. For more information about single sign-on and Kerberos support, see the available Kerberos documentation and the Security Guide in the Enterprise Administration help. For information on setting up Kerberos for the Content Engine environment, see Working with Security.

Custom login modules

The Content Engine server accepts incoming requests over two transport protocols: an EJB transport and a CEWS transport. Authentication over the EJB transport is extensible through JAAS. The Java Platform, Enterprise Edition application server authenticates callers before they can access the EJB layer.

The Content Engine web service provides out-of-the-box-support for the Web Service Security (WS-Security) Username Token profile, and the Kerberos profile. Support for other WS-Security-compliant approaches can be added through the Content Engine Web Service Extensible Authentication Framework (WS-EAF). WS-EAF is a pluggable authentication mechanism for the CEWS transport. It accepts credentials based on the WS-Security OASIS standard and implemented with the JAAS standard. Developers can create custom login modules that handle binary security tokens as defined in WS-Security standards.

For information on creating custom login modules, see the IBM FileNet Content Engine Web Service Extensible Authentication Framework Developer's Guide.


After authentication occurs, authorization to access persisted objects is verified. With few exceptions, every independently persisted object has its own security settings. For example, where multiple versions of a document exist, each document version has its own security settings. These security settings control a user's (or group's) access to that object. Assets that are managed in the Content Engine are protected and can be seen or modified only according to a user's access rights. For more information about authorization, see Authorization.

Instantiating Objects

Because the Content Engine Java and .NET APIs are defined in terms of interfaces, you generally cannot instantiate new objects by using the standard "new" construct. You must instead use a factory class method, which is defined on a Content Engine API Factory class, to instantiate type-appropriate objects. The following section describes the use of factory methods and includes information about how objects are scoped to other objects

Factory methods

The Content Engine APIs provide a Factory class along with static inner classes with names that parallel the standard Content Engine API types, such as Factory.Document. Factory methods are convenient and provide type safety. They avoid the inconvenience (and potential for error) of specifying the object type, you do not have to cast the Factory method results to a wanted type, and you can catch programming errors on the returned type at compile time instead of at run time.

To create or retrieve instances of known object types, use the static methods that are provided by the Factory class for the specific object type. (If you don't have knowledge ahead of time of the object type, see Scoping.) The Factory methods available are for instantiating objects are createInstance, fetchInstance, and getInstance (for "fetchless instantiation").

The createInstance methods are used to instantiate an object that references a new server object. When the object is instantiated, no round trip to the server is made, and the object will not yet exist in the repository. Instead, the instance has an associated "Create" pending action. The round trip to the server happens at a later commit (save) step.

The fetchInstance methods instantiate an object by first making a round-trip to the Content Engine server and retrieving ("fetching") property values. The instantiated object has within it a value for the UpdateSequenceNumber (USN) that is current as of the fetch. The USN protects the object against concurrent updates. Its value increases with each update to the object. When the object is updated, the USN from the retrieved object is checked against the currently persisted USN value. If the values are different, the operation fails. You can interrogate an object's UpdateSequenceNumber property to determine if the object has been modified since some earlier fetch of the same object. Clients can force updates to be persisted regardless of the USN value by calling setUpdateSequenceNumber(null). A null USN causes the server-side check to be skipped during updates. You might want to do this when you call delete() or checkout() on an object.

Fetchless Instantiation

The getInstance methods are used to instantiate an object that references a server object that is assumed to already exist. The existence of the object is not verified on the Content Engine server, and no round trip to the server is made until you perform a function on the object (for example, fetch a property value) that causes a round trip to the server. This is called "fetchless instantiation" and is useful for performance reasons if the object serves only passively, perhaps as the target value for an object-valued property.

An object that is instantiated with getInstance is unaware of the persisted UpdateSequenceNumber for this object. When you save a fetchlessly instantiated object, the UpdateSequenceNumber property value is set to null, therefore skipping the server-side check for updates and allowing the object to be saved regardless of any intervening updates that are made to the object on the server after the client instantiated its copy of the object.


The scope of an object is its "enclosing context". That is, it is the object from which another object originated. As examples, a Domain is the originating scope of a Site or ObjectStore, and an ObjectStore is the originating scope of a Document.

Classes are characterized by where the instance objects are located. Some objects are located within an ObjectStore; other objects are located "above" an ObjectStore, that is, at a higher level in the object model. A ClassDescription is scoped to a particular location and the object that is affiliated with that location is the scope object. Calling ClassDescription.getScope() returns one of the following, depending on what type of class the ClassDescription describes:

The following table lists scope objects and the objects scoped to them:

Scope Object Types of scoped objects
EntireNetwork EntireNetwork, Domain, Realm
Realm User, Group
Domain ObjectStore, MarkingSet, Site, VirtualServer, ServerInstance
ObjectStore independent RepositoryObject types, ClassDescription

EntireNetwork, being the root of the hierarchy, scopes itself, and is also the scope object for Domain and Realm. The scope object for a ClassDescription object is the same as the scope object for an instance that is described by that ClassDescription object. For example, if a CustomObject object is scoped by an ObjectStore instance "OS1", then the custom object's ClassDescription is also scoped by "OS1".

Most often, you create or retrieve instances of objects for which you have type-specific knowledge. However, occasionally you might not have this knowledge and for those times, you can instantiate objects by using InstantiatingScope, which is extended by both ObjectStore and Domain.

The InstantiatingScope interface provides a generic means for instantiating independent objects within a scope. From InstantiatingScope, you can instantiate only those objects within its scope. For example, a Document object is within the scope of an ObjectStore, but is not within the scope of a Domain. This interface provides methods for creating or retrieving objects when you do not have type-specific knowledge of the objects to be instantiated. You can create or retrieve objects by supplying just a class name and (for retrieval) an object identifier or path. You must cast the returned object to the wanted type.

Saving Objects

In the APIs, actions on an object are combined in one call to the server. The combined calls are run when the object is saved (or committed when you are using batch processing). The actions that accumulate on the object before the save operation are called pending actions.

Because of the way that pending actions are handled in the APIs, saving an object can sometimes lead to unexpected failures. A pending action represents an intended change that has not yet been saved (committed) to an object on the server. When you call a method that changes the underlying object, a subclass of PendingAction is created that corresponds to the action. For example, calling Document.checkout creates a Checkout subclass of PendingAction. The pending action is added to the underlying object’s ordered list of pending actions (an automatically generated PendingActions collection). For each subsequent action (such as locking and unlocking, changing the class, freezing, deleting, and so on) taken on the object, an item is added to the pending actions list. When you commit the object, for example, by calling the save method or, in the case of batch operations, by committing the batch, the underlying object (and its collection of pending actions) is sent to the server and changes are written to the repository in the order in which they occur in the object’s pending actions list. Any failure of the set of actions that are involved in the call cause the entire set of actions to fail. The save method always completes all of the work included in a request or none of the work (as an atomic transaction).

You can use any of the following approaches in your application program to prevent failures during a save:

Object Deletion

Calling delete on an object adds a delete action to the object's pending actions list. When you call save() on the object, the pending actions list for the object is processed and the object is deleted if no prior failures have occurred in the list that is being processed. For more information about how prior failures in a transaction can cause delete to fail, see the example in Saving Objects.)

Object Serialization

All Content Engine Java API objects implement the interface, and all Content Engine .NET API objects are annotated with the SerializableAttribute so that they can be serialized by the formatter. The items below point out some additional information about serialization of specific objects.

Client-Initiated Transactions

Transactions are supported over the EJB transport through Java API calls. (The CEWS transport and the .NET API do not support client-initiated transactions.) Transaction processing is implemented by using standard Java Platform, Enterprise Edition transaction mechanisms through the Java Transaction API (JTA). Your application can perform multiple operations within a transaction. If the transaction fails (for example, one of the operations fails), the JTA handles the rollback of the entire transaction. To set up transaction support for your Java client application, use the standard Java Platform, Enterprise Edition UserTransaction calls (on the javax.transaction.UserTransaction interface). You must also enable transactions on the Connection object you are using by setting the CONNECTION_PARTICIPATES_IN_TRANSACTION parameter to true. For more information, see the Connection.setParameter method and ConfigurationParameter.CONNECTION_PARTICIPATES_IN_TRANSACTION.

Last updated: October 2015

© Copyright IBM Corporation 2015.