# 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