# This file contains an entry for each property that you can include in # dfc.properties. Related entries appear in groups. # # Each entry begins with a block of comments (introduced by #) describing the # entry. A single line (not introduced by #) at the end of the block provides a # sample of the entry. You can copy and paste the sample into dfc.properties. # The sample consists of the property name followed by an equal sign (=). In # some cases, a value follows the equal sign. If so, this is the default value. # # # Do not insert spaces around the equal sign. # # You can place an actual value after the equal sign, or you can include an # expression that represents a Java system property or another property in the # properties file. The expression takes the form ${...} where the name of the # Java system property appears within the parentheses. For example, if you # specify # # dfc.checkout.dir=${dfc.user.dir}/checkout # # DFC substitutes the value of the dfc.user.dir property for ${dfc.user.dir} at # runtime. # # Any text you insert for the property value must comply with the ISO 8859-1 # encoding. Use a Unicode escape sequence of the form \uxxxx for characters that # you cannot represent directly in ISO 8859-1. # # For property values that are file paths, use either a slash (/) or an escaped # backslash (\) for the separator. All file paths must be absolute. This applies # both to file paths specified directly and to paths computed at runtime from an # expression containing ${...}. # # For entries that take boolean values, DFC ignores case and accepts any of the # following representations of the boolean values: T/F, On/Off or True/False. # # For more information, refer to the Sun Javadocs for the java.util.Properties # class. #

# ACS configuration# =================# Preferences prefixed dfc.acs are used by dfc for distributed content services # ACS.

# Defines how often dfc verifies acs projection,specified in seconds. # min value: 0, max value: 10000000# dfc.acs.avail.refresh_interval = 360

# Indicates whether to verify if ACS server projects. # dfc.acs.check_availability = true

# Defines how often dfc verifies that docbase related config objects are # modified, specified in seconds. # min value: 0, max value: 10000000# dfc.acs.config.refresh_interval = 120

# Defines how often dfc verifies that global registry related config objects are # modified, specified in seconds. # min value: 0, max value: 10000000# dfc.acs.gr.refresh_interval = 120

# URL Handler - class name, that constructs ACS/BOCS URL for corresponding # protocol. This class has to be available during runtime. # dfc.acs.protocol.handler.class_name =

# Name of the protocol that is to be handled by the corresponding URL handler. # dfc.acs.protocol.handler.protocol =

dfc.admin.ldif_file_charset = UTF-8

# Filename extension to use for mac resource files. # dfc.appledouble.resource_file_ext = adp

# The default application codes for new sessions that are created. The # application code identifies the application-controlled objects that the # session can modify. If there are no application codes present here then the # session cannot modify any application-controlled objects. # # Application codes can contain only alphanumeric characters and the underscore # character. They cannot contain spaces nor can they start with the characters # dm_. Codes beginning with dm_ are reserved for use by Documentum. # dfc.application_code =

# This controls BOTH the client to server and server to Database batching of # query data. It can be used to affect the performance based on the performance # of the network links. It is a hint in the sense that there is no guarantee # that the value will be honored; for example if the number is too large it will # be rounded down. # # For client to server traffic it controls the number of rows transported each # time a new batch of rows is needed in while processing a query collection. For # server to Database traffic this affects the number of rows returned each time # a database table is accessed.

# # The default value is usually adequate. Sometimes a larger value can improve # performance in a high latency environment. # min value: 1, max value: 1000# dfc.batch_hint_size = 50

# BOCS configuration# ==================# Preferences prefixed dfc.bocs are used by dfc for distributed content services # BOCS.

# HTTP method name that dfc uses to connect to unavailable BOCS. # dfc.bocs.check.http_method = GET

# Maximum number of attempts that DFC makes to connect to an unavailable BOCS # min value: 0, max value: 1000# dfc.bocs.check.keep_number = 6

# Business Object Framework# =========================# You can configure the way DFC interacts with the global registry. The entries # that have samples with nothing after the equal sign have no default values but # are mandatory for systems using a global registry. # # For the other entries, if you do not include them in dfc.properties, DFC # assumes the values that appear after the equal signs in the samples below. # # Refer to the BOF chapter of the DFC Development Guide for more information # about BOF and the global registry. # # Name of the repository containing the the global registry. The repository must # project to a connection broker that DFC has access to. #

# Controls whether to append jar names to the files in the BOF cache. # dfc.bof.cache.append_name = false

# Interval in days between housekeeping cleanup of unused resources in the BOF # cache. # dfc.bof.cache.cleanup_interval = 7

# Interval in seconds that DFC waits between checks for consistency of its # module cache. #

dfc.bof.cache.currency_check_interval = 60

# Load services from the global registry into the local cache on startup. DFC # uses cached information, even beyond the specified interval for consistency # checking, if the global registry becomes unavailable. Because global registry # information tends to be relatively static, this provides important protection # against network or Content Server outages. # dfc.bof.cache.enable_preload = true

# Controls the size of the Data Dictionary in memory cache. The entry consists # of docbase name, type name, attribute name, business policy id, state and # locale. # min value: 1, max value: 10000# dfc.cache.ddinfo.size = 500

# The root directory for the area where DFC stores its persistent caches. # dfc.cache.dir = ${dfc.data.dir}/cache

# Enables or disables client persistent caching. # dfc.cache.enable_persistence = true

# min value: 0, max value: 86400#dfc.cache.format.currency_check_interval = 300

# min value: 1, max value: 100000#dfc.cache.object.size = 1000

# min value: 1, max value: 10000#dfc.cache.query.size = 500

# min value: 0, max value: 86400#dfc.cache.store.currency_check_interval = 300

# min value: 0, max value: 86400#dfc.cache.type.currency_check_interval = 300

# min value: 1, max value: 10000

#dfc.cache.type.size = 500

# Controls how often client persistent caches are written to disk. # dfc.cache.write_interval = 3600

# client_codepage specifies the character set used by native applications that # are accessing DFC through the DMCL emulation. Only the following character # sets are officially supported: UTF-8, ISO_8859-1, Shift_JIS, EUC-JP,EUC-KR. # # NOTE: normally, this value is taken from the the client host's OS environment. # There is normally no need to specify this value. # dfc.codepage =

# Used to control whether a session can be disconnected through a weak session # handle. By default such a thing is not allowed because it is dangerous and # often a source of application bugs. It is much safer to always disconnect # through the strong handle that was obtained at "connect" time. # # For compatibility with certain older applications you can use this option to # enable disconnect through a weak session handle. It is recommended that you # avoid using this option. The application should be fixed instead. Enabling # this option can allow application logic bugs to cause all sorts of nasty and # hard to detect session management problems. # dfc.compatibility.allow_weak_disconnect = false

# Controls whether informational messages returned by the server at session # establishment time are preserved. # # These messages are usually ignored by applications and sometimes the messages # actually get in the way if the application is not careful. It is typically # more convenient to simply discard these unnecessary messages to avoid any # problems. If,however, your legacy application relies upon the informational # messages then you can ask that they be preserved. # dfc.compatibility.preserve_session_info_messages = true

# Controls the behavior when a program asks for a value at index 0 from a # repeating attribute that has no values. When set to true, DFC will return null # when no values exists. This is the backward compatible behavior but means that # a failed request for index 0 behaves differently than a failedrequest for # index 1. When set to false DFC will throw an exception when no repeating # values exist. Throwing an exception is a newer behavior that is more # consistent with other repeating attribute accesses. It means a request for a # non-existent entry at index 0 will return the same exception as a non-existent # entry at index 1 # dfc.compatibility.return_null_when_no_values = true

# Controls the behavior when a value is too large to fit into the target # attribute. When set to true DFC will silently discard any extra data that will # not fit in the target field. This is backward compatible behavior with older # DFC and DMCL versions but is dangerous because it can result in data loss or # corruption. When set to false DFC will throw an exception when the value # cannot fitin the target attribute. # dfc.compatibility.truncate_long_values = false

# The interval in seconds that DFC waits between checks for updates to # configuration files. Some of the files that use this preference include # dfc.properties, dbor.properties, and log4j.properties. # min value: 1, max value: 360# dfc.config.check_interval = 30

# The directory from which the configuration file was read. # # This is a read-only property that is initialized at system startup time. # dfc.config.dir =

# The URL for the configuration file currently in use. # # This is a read-only property that is initialized at system startup time. # dfc.config.file =

# The maximum number of times DFC will retry transferring content to a CA store. # min value: 1, max value: 15# dfc.content.castore.max_write_attempts = 3

# The number of seconds DFC will wait after an error transferring content to CA # store before attempting the first retry. After each subsequent error DFC waits # longer. # min value: 0, max value: 86400# dfc.content.castore.write_sleep_interval = 3

# Setting this value to true indicates that content in ALL the external stores # accessed by this DFC is immutable. Generally DFC avoids caching content in an # external store becuause the content is considered to be outside the contol and # may be changed causing cached cached to become out of date. Setting this value # to true can improve performance by avoiding reads of content in an external # store. However if the content in the external store does change setting this # value to true can lead to DFC returning out of date content. Because setting # this value to true applies to ALL external stores it is recomended to set

# 'a_content_static' on individual stores as appropriate instead. # dfc.content.extern_store_content_static = false

# When set to T this causes content tunnelling to use data compression. This is # recommended when network latency is high. Thus for phone connections # compression is recommended. For standard, local area, network connections # compression is not recommended. # dfc.content.use_compression = false

# The value affects which Content Server DFC uses to read and write content # directly. This value does not apply to content DFC accesses through ACS. If # the value is explicitly set to false, uses the repository data server for # reading both properties and content. By default, DFC will accesses a separate # content server if one exists unless the application connects to a specific # server. If the value is explicitly set to true DFC will accesses a separate # content server if one exists, even if the application connected using an # explicit server. # dfc.content.use_content_server = true

# Client Machine Directory Locations# ==================================# DFC uses directories on the client machine. You can specify values for these # directories by setting any of the following properties. If you do not specify # these properties, DFC assumes the values that appear after the equal signs in # the samples below. The installer sets these values based on information you # provide, so there is usually no need to modify them. # # Refer to the DFC Installation Guide for more information about client machine # directory locations. #

# The directory in which DFC stores content files corresponding to checked out # objects. This is primary used for legacy single-user applications. When UCF is # used in an application server environment this directory is not significant. # dfc.data.checkout_dir = ${dfc.data.user_dir}/checkout

# The root directory of a tree of directories containing data used by DFC. If # 'user.dir' system property is not set, then the location defaulted to the # 'current working directory'/documentum # dfc.data.dir = ${user.dir}/documentum

# The directory in which DFC stores content files corresponding to objects # transferred to the client machine but not checked outchecked out objects. This # is primary used for legacy single-user applications. When UCF is used in an # application server environment this directory is not significant.

# dfc.data.export_dir = ${dfc.data.user_dir}/export

# Indicates whether DFC purges the client local area whenever DFC is started. # dfc.data.local_clean_on_init = true

# The location of the client local area in which temporary document content # files are copied for viewing when getfile requests are made which do not give # a specific filename in which to place the content. # # When set, the value should give the name of an existing directory in which the # client application has permission to create subdirectories and files. # dfc.data.local_dir = ${dfc.data.user_dir}/local

dfc.data.local_diskfull_check_interval = 1

# Specifies how much disk space (in megabytes) is available to the localcontent # area. A value of 0, the default, means there is no limit on the size of # thelocal content area. An error is reported on a getfile request once the # limit is reached. # dfc.data.local_diskfull_limit = 0

# When a getfile request will result in disk space usage in the local content # area that exceeds dfc.data.local_diskfull_limit, this preference controls # whether existing local content for the current session will be purged to free # up space. The getfile request will succeed if enough disk space is reclaimed # by the purge. # dfc.data.local_purge_on_diskfull = true

# The default UNIX permissions that are used when directories and filesare # creted by DFC. # min value: 0, max value: 511# dfc.data.umask = 0

# The root directory for user-specific data used by DFC. This is normally the # same as the dfc.data.dir. In certain single-user applications this may # sometimes be set differently but that is not common, especially in application # server environments. # dfc.data.user_dir = ${dfc.data.dir}

# The default date format used for interpretting date values specified by the # application. It is generally best practice for the application to provide the

# date format explicitlywhen working with date values. If, however, the # application does not specify the date format then this default is used. # # The date format can be specied using the syntax of the Java SimpleDateFormat # class. # dfc.date_format =

# Diagnostic Options# ==================# You can use the following properties to modify DFC behavior to help you # diagnose problems or potential problems. The values specified after the equal # signs in the following samples are the values DFC assumes if you do not set # the corresponding property explicitly. # # Refer to the DFC Javadocs for DfLogger for basic information about the DFC # logging and tracing mechanism. #

# Controls whether the exception stack is included as part of the message text # for exceptions. Normally in Java the exception stack is readily available # through standard Java mechanisms and is not part of the message text. # Sometimes, however, when going through Docbasic or the COM bridge or other # third party layers the stack is not readily available for display. Using this # preference you can force the exception stack to be included as part of the # message text so it is available in some of the special cases where it is # otherwise not. # # This is a special diagnostic option that would not normally be turned on for a # production system. # dfc.diagnostics.exception.include_stack = false

# Controls whether warnings from the repository are converted into exceptions. # Normally warnings from the repository are simply placed in the message buffer # by default and are only noticed it the application explicitly asks for them. # When this property is set to true then warnings are converted into exceptions. # This helps your program to notice unusual conditions that might have otherwise # gone unnoticed. # dfc.diagnostics.exception.throw_warnings = false

# Controls whether a warning is generated when a deprecated preference is # accessed. # dfc.diagnostics.preference.warn_about_deprecation = false

# Controls whether a warning is generated when an old name is used for a renamed # preference. # dfc.diagnostics.preference.warn_about_rename = false

# Enables or disables diagnostics which detect failures by the application to # properly release resources such as sessions and collections. When enabled a # log message will be generated when certain resources are garbage collected # without first being closed or released by the application. # # Note that there is some performance overhead for this diagnostic so you may # not want to use it on a production system unless you are diagnosing a # particular problem. # dfc.diagnostics.resources.enable = false

# Controls whether a warning is generated when a deprecated DMCL call is made. # dfc.diagnostics.warn_about_dmcl_call = false

# Controls whether a connection request should be forwarded to secondary # connection brokers. # dfc.docbroker.auto_request_forward = true

# The ID for the repository when operating in connection broker bypass mode. # This is a rarely used diagnostic option that allows connection to a repository # without a connection broker. # dfc.docbroker.debug.docbase_id = 0

# The host name for the repository when operating in connection broker bypass # mode. This is a rarely used diagnostic option that allows connection to a # repository without a connection broker. # dfc.docbroker.debug.host =

# The port number for the repository when operating in connection broker bypass # mode. This is a rarely used diagnostic option that allows connection to a # repository without a connection broker. # min value: 0, max value: 65535# dfc.docbroker.debug.port = 0

# The service for the repository when operating in connection broker bypass # mode. This is a rarely used diagnostic option that allows connection to a # repository without a connection broker. # dfc.docbroker.debug.service =

# The host machine name for each configured connection broker. # prototype value: localhost

# dfc.docbroker.host =

# The port number for each configured connection broker. # prototype value: 1489# min value: 0, max value: 65535# dfc.docbroker.port = 0

# The protocol for each configured connection broker. There is currently only # one legal value for this property so you should never need to specify or # change it. # valid values: rpc_static# prototype value: rpc_static# dfc.docbroker.protocol =

# Determines whether the connection request is sent first to the primary # connection broker or to a randomly selected connection broker (that has been # configured). # valid values: sequential,random# dfc.docbroker.search_order = sequential

# The service name for each configured connection broker. There is currently # only one legal value for this property so you should never need to specify or # change it. # valid values: dmdocbroker# prototype value: dmdocbroker# dfc.docbroker.service =

# The amount of time in seconds to wait for a response from a connection broker. # If set to 0 then DFC will not impose a time limit of its own and will rely # upon the standard TCP/IP timeout. # prototype value: 0# min value: 0, max value: 60# dfc.docbroker.timeout = 0

# Specifies whether extra embelishments should be added to the exception # message. Some of the extra embelishments historcally added by DFC include an # abbreviated exception class name, the thread name, a (deprecated) error code, # and a "next" exception. By default these embelishments are included for # backward compatibility. The extra information, however, generally does not add # value and makes the message harder to read. You may choose to omit the extra # information to simply the messages. # dfc.exception.include_decoration = true

# Controls whether the message identifier is included in the exception message. # Including the message identifier is typically useful when trying to identify # exceptions during discussions with technical support. Omitting the message # identifier generates a simpler message that more closely follows typical Java # style. # dfc.exception.include_id = true

# The interval in seconds that DFC waits between attempts to log in to the # global registry. A high value can resist attempts to obtain unauthorized # access to the global registry. # dfc.globalregistry.connect_attempt_interval = 60

# The password that is used to access the global registry. You can provide the # password in plain text or encrypted. DFC recognizes the output of our # encryption tool (see below) and decrypts encrypted passwords before using # them. To create an encrypted password, execute the following at a command # prompt: # # java com.documentum.fc.tools.RegistryPasswordUtils <password> # # The utility sends the encrypted password to the standard output. # dfc.globalregistry.password = password

# The name of the repository containing the the global registry. The repository # must project to a connection broker that DFC has access to. # dfc.globalregistry.repository =

# The username that is used to access the global registry. # dfc.globalregistry.username = dm_bof_registry

dfc.ldap.bof.validate_password = true

# Specifies the default locale for all repository sessions. The session locale # is used, for example, to control which NLS-specific Data Dictionary strings # the server will serve to the session. # # At present, only the following specific simple locale strings are fully # supported: en,de,es,fr,it,ja,ko. # # In general, the format of the value string is based on Java locale strings. # The form of a Java locale string is <languagecode>[_<countrycode>]. For # example, this is the Java locale string for British English: en_GB. # # Normally this value is taken from the the client JVM environment and there is

# no need to specify avalue # dfc.locale =

# Controls whether a stack trace is include with log messages that would not # otherwise include a stack trace. This is a diagnostic option that is used when # debugging certain kinds of problems and would not typically be used during # normal operations of a production system. # valid values: ALL,DEBUG,INFO,WARN,ERROR,FATAL,OFF,TRACE# dfc.logging.level_to_force_stack = OFF

# Controls the amount of information that is included in certain types of log # messages. When set to true additional log messages may be generated and other # messages may include extra information. # dfc.logging.verbose = false

# The unique machine identifier that is used to support application tokens. If # needed, this should typically be set to the MAC address of the network adapter # on your system. # dfc.machine.id =

# A name for the DFC instance. The name is used when addressing the instance # within JMX and is also used as the alias of the PKI identity credentials # (private key and certificate) in the keystore. If you have multiple instances # of DFC running on the same physical system then you should assign each a # unique name. # dfc.name = dfc

# The number of object IDs that are allocated in a batch each time a new object # id is needed and there are no more available IDs from the previous batch. # min value: 1, max value: 10000# dfc.object.id_batch_size = 10

# Flag to toggle the ability of DFC to exercise privilege escalation. It # controls, among the rest, if dfc attempts to publish its identity to the # global registry when such identity is created. (If false, dfc will not attempt # to publish its itentity.) # dfc.privilege.enable = true

# Defines which document version to fetch when accessing a remote document. If # this attribute is defined, its value overrides the binding specified in the # dm_reference object when a mirror object is dereferenced using # IDfSysObject.dereferenceMirror.

# dfc.reference.binding_label =

# Registry Emulation# ==================# On Windows clients, DFC uses the system registry to keep track of files # checked out or exported to the client machine. On Unix systems, DFC keeps this # information in a file on the file system. DFC sets this mode automatically, # but you can use the following properties to specify using the file method on # Windows systems or to specify the file location on any system. DO NOT use file # mode with Documentum Desktop.

# Absolute path to the registry file (if the registry mode is "file"). # dfc.registry.file = ${dfc.data.user_dir}/documentum.ini

# The type of registry implementation to use. If the value is "windows" then the # Windowsregistry is used to store registry data. If the value is "file" then a # file is used to store registry data. # valid values: windows,file# dfc.registry.mode = file

# Interval in minutes before relationship schema expires, forcing # reinitialization # min value: 1, max value: 2147483647# dfc.relationship.schema_expiration_interval = 30

# Searching Options# =================# DFC enables you to use Enterprise Content Integration Services (ECIS) to # search for information in Documentum and other repositories. Refer to the ECIS # documentation for information about the following properties. Values after the # equal signs are default values. # # The following properties control the way ECIS uses brokers, which are threads # in the DFC process space that pull queries from a common queue and execute # them. #

# Number of broker threads supporting execution of the Documentum repository # part of a query. One broker supports execution of the query for each # repository selected for this query. # min value: 0, max value: 1000# dfc.search.docbase.broker_count = 20

# Subdomain containing the source available to DFC. By default, DFC uses the

# default domain of the standalone ECI WEB client # dfc.search.ecis.adapter.domain = JSP

# RMI registry host to connect to the backup ECI Server. The ECIS Development # Guide chapter on the application SDK explains the RMI registry. # dfc.search.ecis.backup.host = localhost

# RMI registry port to connect to the backup ECI Server. The ECIS Development # Guide chapter on the application SDK explains the RMI registry. # min value: 0, max value: 65535# dfc.search.ecis.backup.port = 3005

# Number of broker threads supporting execution of the ECIS part of a query. One # broker supports the execution of the query for all external sources selected # for this query. # min value: 0, max value: 1000# dfc.search.ecis.broker_count = 30

# Use ECIS. Setting this to True tells DFC to use ECIS in addition to Content # Server's basic search facilities. # dfc.search.ecis.enable = false

# RMI registry host to connect to ECI Server. The ECIS Development Guide chapter # on the application SDK explains the RMI registry. # dfc.search.ecis.host = localhost

# Default credentials to connect to ECI server as guest. # dfc.search.ecis.password = askonce

# RMI registry port to connect to ECI Server. The ECIS Development Guide chapter # on the application SDK explains the RMI registry. # min value: 0, max value: 65535# dfc.search.ecis.port = 3005

# Time in milliseconds to wait for answer from ECIS server. # min value: 0, max value: 10000000# dfc.search.ecis.request_timeout = 180000

# Time in milliseconds before retrying to connect to the main ECIS server (after # having switch to the backup ECIS server). # min value: 0, max value: 2147483647# dfc.search.ecis.retry.period = 300000

# RMI Registry symbolic name associated with ECIS API. # dfc.search.ecis.rmi_name = xtrim.RmiApi

# Enable encryption of results and content sent from the ECI server to the DFC # client. # dfc.search.ecis.ssl.enable = false

# Define a keystore where to find DFC client certificate and keys and ECI Server # trusted certificate.This keystore is a file available locally on the machine # where the DFC resides. # dfc.search.ecis.ssl.keystore =

# Define the password for the keystore file used for communication with the ECIS # server. # dfc.search.ecis.ssl.keystore_password =

# Default credentials to connect to ECI server as guest. # dfc.search.ecis.username = guest

# Time in milliseconds between refreshes of the cache of docbase formats. # min value: 0, max value: 10000000# dfc.search.formatcache.refresh_interval = 1200000

# Use the Content Server full-text engine (for example, FAST). If you set this # to False, DFC replaces DQL full-text clauses by LIKE clauses on the following # attributes: object_name, title, subject. # dfc.search.fulltext.enable = true

# Maximum number of results to retrieve by a query search. # min value: 1, max value: 10000000# dfc.search.max_results = 1000

# Maximum number of results to retrieve per source by a query search.

# min value: 1, max value: 10000000# dfc.search.max_results_per_source = 350

# Time in milliseconds between refreshes of the search source map cache. # min value: 0, max value: 10000000# dfc.search.sourcecache.refresh_interval = 1200000

# Time in milliseconds between refreshes of the cache of type information. # min value: 0, max value: 10000000# dfc.search.typecache.refresh_interval = 1200000

# Fully qualified file name of the keystore file holding the PKI credentials for # DFC. # # Defaults to dfc.keystore in the same directory where the property file # (dfc.properies) is found. # dfc.security.keystore.file = ${dfc.config.dir}/dfc.keystore

# Password to gain access to the keystore holding the PKI credentials for DFC. # # see also dfc.security.keystore.file # dfc.security.keystore.password = dfc

# Password to gain access to the private key of the PKI credentials for DFC. # # see also dfc.security.keystore.file and dfc.security.keystore.password # dfc.security.keystore.privatekey.password = !!dfc!!

# Used to control the Content Server policy of allowing client programs running # on the Content Server machine itself to establish sessions without providing # new credentials (provided the programs are running in the user account for # which the session is being established). Setting this to false is recommended # in instances where Web Applications (or others that expose direct user login) # are deployed on the Content Server machine. Trusted login should not be # disabled in the DFC instance which hosts the Content Server internal processes # as several functions (java method server, server jobs) rely on it. # dfc.session.allow_trusted_login = true

# The interval in seconds between connection retry attempts to the server. # # Early on during session establishment certain kinds of errors can occur that # are often recoverable. These errors are typically caused by high server load.

# DFC automatically retries session establishment in these cases. This # preference defines the amount of time to delay between successive retry # attempts # dfc.session.connect_retry_interval = 0

# The amount of time in seconds to wait for a response from a repository server. # If set to 0 then DFC will not impose a time limit of its own and will rely # upon the standard TCP/IP timeout. # dfc.session.connect_timeout = 0

# The interval of time in seconds which a dynamic handle holds on to a session # which it dynamically created on demand. # min value: 0, max value: 300# dfc.session.dynamic_delay = 30

# The maximum number of collections that a session is allowed to have open. # min value: 1, max value: 100000# dfc.session.max_collection_count = 1000

# The maximum number of times to retry session establishment. # # Early on during session establishment certain kinds of errors can occur that # are often recoverable. These errors are typically caused by high server load. # This is the number of times to retry before giving up. # min value: 0, max value: 10# dfc.session.max_connect_retries = 3

# The maximum number of sessions that this DFC instance can have open. # min value: 1, max value: 100000# dfc.session.max_count = 1000

# The maximum number of times to automatically retry certain kinds of RPCs that # are victoms of a database deadlock. After the number of retries has been # exhausted a error is returned to the application. # min value: 0, max value: 20# dfc.session.max_deadlock_retries = 5

# The maximum number of times to automatically retry certain kinds of RPCs that # are victoms of an I/O error. After the number of retries has been exhausted a # error is returned to the application. # min value: 0, max value: 5#

dfc.session.max_error_retries = 1

# Controls whether session pooling is enabled. # dfc.session.pool.enable = true

# The interval of time in seconds that sessions are kept in the level 1 pool of # the associated session manager. # min value: 1, max value: 300# dfc.session.pool.expiration_interval = 5

# Defines the amount of pooling that is done when session pooling is enabled. # # Level 1 pooling means that sessions are only pooled in the session manager to # which they belong. Sessions in the level 1 pool can only be reused by the same # session manager. The sessions live in the level 1 pool for a relatively short # period of time after which they are disconnected. # # Level 2 pooling means that in addition to the session manager pooling, # sessions are pooled globally. After a sessions expires from the level 1 # session manager pool it is placed in the level 2 global pool. Sessions in the # level 2 global pool are then available to be reused by other session managers. # valid values: level1,level2# dfc.session.pool.mode = level2

# Specifies the maximum number of times a particular session can be reused out # of the level2 session pool. Once the limit is reached the session is # disconnected and a new one obtained. The limit prevents the repository server # process from becoming too big because memory use gradually grows on the server # each time the session is reused. # dfc.session.reuse_limit = 100

# Determines type of TCP/IP socket that is used to establish a repository # session. # valid values: native,try_native_first,secure,try_secure_first# dfc.session.secure_connect_default = try_native_first

# The interval of time in seconds between checks for surrogate login tickets # that are about to expire. # # Surrogate login tickets are tickets generated internally by the session # manager to support the use of tickets and other kinds of external credentials # with session managers. # min value: 1, max value: 3600# dfc.session.surrogate.check_interval = 120

# Determines whether the session managers should use surrogate login tickets. By # default surrogate login tickets will only used if needed. You can set this # preference, however, to always use surrogate tickets or to never use surrogate # tickets. # # Surrogate login tickets are tickets generated internally by the session # manager to support the use of tickets and other kinds of external credentials # with session managers. # valid values: never,always# dfc.session.surrogate.mode =

# Storage Policy Options# ======================# The following properties tell DFC how to apply storage policy rules. These # properties do not change storage policies. They provide diagnostic support and # performance tradeoffs. Values after the equal signs are default values. # # Refer to the Content Server Fundamentals manual for more information. #

# Use storage policies to determine the storage locations for new content. # Setting this to False disables the use of storage policies.Do this only for # diagnostic purposes. # dfc.storagepolicy.enable = true

# Do not raise fatal errors if wrong attribute names appear in storage policy # rules. Such errors result in exceptions that would cause the save/checkin to # fail. Instead, log the errors to the log file. # dfc.storagepolicy.ignore_rule_errors = false

# Maximum time interval in seconds during which the storage policy engine can # use cached information. A value of zero means never use cached information. # dfc.storagepolicy.validation_interval = 30

# The timezone of this DFC instance. # # This value is initialized from the Java Virtual Machine at startup time and # normally doesn't need to be specified. Legal values are the timezone IDs # supported by the Java Virtual Machine. # dfc.time_zone =

dfc.tokenstorage.dir = ${dfc.data.dir}/apptoken

# token_storage_enabled determines whether a connection request should attempt # to locate a docbase specific application access control token in the token # storage area and include that token implicitly as part of the connect request. # dfc.tokenstorage.enable = false

# Tracing Options# ===============# DFC supports a set of tracing confguration options that allow you to obtain # desired trace information about DFC API. # # Refer to the DFC Tracing Guide for detailed information about the DFC logging # and tracing mechanism. #

# If an alternative date format is configured, you should also provide a value # for this option, so tracing will know how wide to make the date column. # dfc.tracing.date_column_width = -1

# If the timing style is set to 'date', this parameter allows you to specify an # alternate date format. The format string must conform to the syntax supported # by the Java class java.text.SimpleDateFormat. # dfc.tracing.date_format =

# Identifies the directory in which trace files should be placed. # dfc.tracing.dir = ${dfc.data.dir}/logs

# Turns tracing on and off. # dfc.tracing.enable = false

# Determines the trace file creation policy for tracing. By default, all tracing # information is logged to a single file. Using this property, tracing can be # configured so it creates a separate log file for each user, or for each thread # valid values: standard,thread,user# dfc.tracing.file_creation_mode = standard

# Sets a specific file path to use for tracing output. Normally DFC # automatically generates a trace file path based on the other settings # (directory, prefix, mode, time, etc). When this preference has a non-null # value then it is used as the explicit trace file path. # dfc.tracing.file_override =

# Specifies the prefix string to place in from of trace file names when in # standard filecreation mode. In standard file creation mode, the tracing # infrastructure names log files <file_prefix>.<timestamp>.log. # dfc.tracing.file_prefix = dfctrace

# When this property is set to true, each entry in the trace log will record the # current RPC count for that connection. The RPC count is ascertainable only # after a method is called on an object which has an associated session. Hence, # many entries in the trace log will have the value N/A for the RPC count. # dfc.tracing.include_rpc_count = false

# Controls whether RPC information is included in the trace. # dfc.tracing.include_rpcs = false

# Controls whether session ID information is included in the trace. By default, # all entries in the trace log will record the associated user (if that # information is available from the call context). When this property is set to # true, the external session ID (e.g.: s1, s2) and the identity hash code of the # associated session manager is printed along with the user. # dfc.tracing.include_session_id = true

# For each additional logging category defined in dfc.tracing.log.category this # specifies thelog4j additivity setting. Normally you do not need to set this # preference. The default is normally the correct setting. # prototype value: false# dfc.tracing.log.additivity = false

# Defines additional logging categories to be included in the trace output. # default values: com.documentum.fc.client.impl.session,com.documentum.fc.client.impl.connection# dfc.tracing.log.category = {"com.documentum.fc.client.impl.session", "com.documentum.fc.client.impl.connection"}

# For each additional logging category defined in dfc.tracing.log.category this # specifies thelogging level to set for that category. # valid values: ALL,DEBUG,INFO,WARN,ERROR,FATAL,OFF,TRACE# prototype value: DEBUG# dfc.tracing.log.level =

# The number of backups that DFC will keep. Whenever the trace file rolls over, # DFC will backup the old one. The oldest backup files get deleted first when # the configured number of backups has been exceeded.

# dfc.tracing.max_backup_index = 1

# Specifies the maximum size that the trace file can reach before it rolls over. # dfc.tracing.max_file_size = 100MB

# Number of method call nesting levels to display in the trace. # min value: -1, max value: 2147483647# dfc.tracing.max_stack_depth = 1

# This is a repeating attribute that specifies those methods to trace. Unlike # the user and thread filters, the method name filter uses a simplified syntax # for performance reasons. When a thread enters a method which matches one of # the filters, tracing will be turned on for that thread. All DFC calls made # within the context of that method will be traced. Tracing continues for that # thread until the method that was matched is exited. # dfc.tracing.method_name_filter =

# Determines whether the tracing output records method entry and exit on # separate lines as they occur or whether everything (the method arguments and # return value) is recorded a single line. In compact (single-line) mode, the # trace entries will appear in the order of method entrance. # valid values: standard,compact# dfc.tracing.mode = compact

# Determines whether tracing should print the exception stack when a method call # results in an exception. Normally, the tracing will only log the name and # message of the exception. If this set to true, underneath the line recording # the method exit, the entire stack trace for the exception will be logged # (prefixed with an indent and exclamation marks). # dfc.tracing.print_exception_stack = false

# This is bit of an odd-ball property that was added in response to a request # from the performance team and I am not sure that we should document it. When # one or more method name filters are configured and this property is set to # true, the tracing infrastructure will print a stack trace to the DFC log file. # The purpose is to provide a way to log all the different code paths that # result in a call to a particular method or methods. # dfc.tracing.print_stack_on_method_match = false

# Filters the trace output to only those threads whose name matches the filter. # The filter is a regular expression (see the Javadoc for the class # java.util.regex.Pattern for syntax). An example filter might be

# 'Thread-[4-6]'. This would match the threads named 'Thread-4', 'Thread-5' or # 'Thread-6'. The filter is case sensitive. # dfc.tracing.thread_name_filter =

# The first column of a tracing log entry records the time of the call entrance # or exit for enter_and_exit mode. It records the time of the method entrance in # compact mode. In compact mode, the second column displays the duration of that # call (the difference between the time of method entrance and method exit). # This setting will affect the units displayed in these columns. # valid values: no_timing,nanoseconds,milliseconds,milliseconds_from_start,date,seconds# dfc.tracing.timing_style = seconds

# Filters the trace output to only those calls where the session's user login # name matches the filter expression. # dfc.tracing.user_name_filter =

# Determines whether extra detailed information is included in the trace output. # dfc.tracing.verbose = false

# Controls how often the validation expression needs to checked for consistency # with the server. See IDfQuery.setCurrencyCheckValue for more info. # min value: 0, max value: 100000# dfc.validation.expr.currency_check_interval = 120

# Controls whether to log all the validation expression activities. Logging must # be set to DEBUG level. # dfc.validation.expr.debug.all = false

# Controls whether to log validation expression bytecode generation activities. # It also prints the stack size and the number of locals. Logging must be set to # DEBUG level. # dfc.validation.expr.debug.code = false

# Controls whether to log validation expression evaluation activities. You will # only see a log statement if the expression was evaluated in Docbasic. Logging # must be set to DEBUG level. # dfc.validation.expr.debug.eval = false

# Controls whether to log validation expression parsing activities. Logging must # be set to DEBUG level.

# dfc.validation.expr.debug.tree = false

# Controls whether to disable validation expression evaluation using java. # dfc.validation.expr.disable_java = false

# Controls whether to allow validation expression evaluation using native # expression library. # dfc.validation.expr.load_native_library = false

# Controls how often the validation overrides needs to be reinstantiated. # min value: 0, max value: 100000# dfc.validation.overrides.currency_check_interval = 300

# Controls whether validation java overrides is enabled. # dfc.validation.overrides.enable = false

# min value: -1, max value: 100000#dfc.vdm.max_child_flush_count = -1

# Controls if DFC shall check at each startup after the first whether its # identity is published in the global registry. If this flag is true and the # identity is not found in the GR, then it will also be published. This flag # does not affect first startup behavior, which is as if this flag value is # true, regardless of its actual value. (Note that dfc.privilege.enable must # also be true for the identity to be published.). First means every time a new # identity has been created, as for instance the first startup of a new # installation, or the first startup after the PKI credentials are created anew # after having been destroyed for whatever reason. # dfc.verify_registration = false

# The version of DFC. # # This is a read-only preference that is initialized at system startup. # dfc.version =

# XML Processing Options# ======================# DFC's XML processing is largely controlled by configuration files that define # XML applications. The following properties provide additional options. #

# Refer to the XML Applications Development Guide for background information # about DFC's XML processing. #

dfc.xml.encode_special_chars_in_attrs = true

# Record inline descendants in the registry. # dfc.xml.record_inline_descendants = false

# Conform strictly to the URI syntax within XML files during outbound operations # such as export and checkout. # dfc.xml.use_strict_uri = true