# -----------------------------------------------------------------------
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
# -----------------------------------------------------------------------

# WARNING: DO NOT EDIT THIS FILE.
# All customizations must be created in a file "site.ducc.properties" that is in
# your ducc_runtime/resources.  DUCC's startup procedures will merge this file and
# your site.ducc.propeties into ducc.properties which is what DUCC will use.
# WARNING DO NOT EDIT THIS FILE.

# ====================================================================================
#   This configuration file contains most of the specifications for DUCC.
#
#   Two other important customizable files define the classes and nodes.
#
#   The class definition file is specified by the property 'ducc.rm.class.definitions'
#   and a sample called ducc.classes has been provided in DUCC_HOME/resources.
#
#   Node definitions are by default taken from ducc.nodes but this may be overridden
#   with the -n option on start_ducc.
#
#   The first two entries here are customized in site.ducc.properties by ducc_post_install.
#
# ====================================================================================

# The name of the node where DUCC runs.
ducc.head = <head-node>

# The full name of the Java command.
ducc.jvm  = <full-path-to-java-command>

# The name of the cluster as shown by the Web Server.
ducc.cluster.name=Apache UIMA-DUCC

# Specify location of private resources directory.  UIMA-3892
ducc.private.resources = ${DUCC_HOME}/resources.private

# Location of security home directory.  When non-empty the userid is appended and it replaces the
# default of <user.home> as the location of the keys used in request validation.
ducc.security.home =

# Name any site-local jars
#ducc.local.jars = 

# Declare which components to load into the jvm on process startup.
ducc.jms.provider=activemq

# ---------------------------------------------------
# ---------------------------------------------------
# Define the ActivemQ broker configuration. 
#    ducc.broker.protocol - Ddefine broker protocol. Should typically be 
#                           tcp. *** Dont specify : or // ***
# ducc.broker.hostname    - The name of the host where the broker is running.
# ducc.broker.port        - The broker's connection port
# ducc.broker.url.decoration - The broker *client* url decoration.
#        recoveryInterval=30000 - Specifies an interval between recovery attempts,
#                                 i.e when  a connection is being refreshed, 
#                                 in milliseconds
#        jms.useCompression=true - Compress message body
# ducc.broker.name        - the broker name - must match the actual broker name
#                           in the broker config.  THIS IS NOT THE BROKER HOSTNAME
#                           WHICH IS CONFIGURED IN ducc.broker.hostname.
# ducc.broker.jmx.port    - the Broker's jmx port
#
ducc.broker.protocol=tcp
ducc.broker.hostname=${ducc.head}
ducc.broker.port=61617

# Broker decorations: 
#    useCompression: true, compress JMS cargo 
ducc.broker.url.decoration=jms.useCompression=true

ducc.broker.name=localhost
ducc.broker.jmx.port=1100
#
# ActiveMQ credentials file used to authenticate DUCC daemons with the broker.
# 
ducc.broker.credentials.file=${ducc.private.resources}/ducc-broker-credentials.properties

# ActiveMQ Auto-management configuration
#    docc.broker.automanage    - if true, DUCC will start and stop the broker as needed.  
#                                Otherwise, the installation is responsible for
#                                managing ActiveMQ
#    ducc.broker.memor.options - If automanaged, the memory configuration passed to the JVM
#    ducc.broker.configuration - If automanaged, the location of the ActiveMQ broker configuration
#    ducc.broker.home          - If automanaged, the location of the ActiveMQ installation
#    ducc.broker.server.url.decoration - If automanaged, the broker URL decoration
#

ducc.broker.automanage = true
ducc.broker.memory.options = -Xmx1G

ducc.broker.configuration = conf/activemq-ducc.xml
ducc.broker.home = ${DUCC_HOME}/apache-uima/apache-activemq

# transport.soWriteTimeout=45000, 45sec timeout on write operations to the socket.
ducc.broker.server.url.decoration = transport.soWriteTimeout=45000

# To enable tracing of RM messages arriving in OR and NodeMetrics arriving in WS.
#ducc.transport.trace = orchestrator:RmStateDuccEvent webserver:NodeMetricsUpdateDuccEvent

# By default, use Linux OS authentication (via PAM)
#ducc.authentication.implementer=org.apache.uima.ducc.ws.authentication.LinuxAuthenticationManager
# Specify users allowed to login (default is all users can login)
#ducc.authentication.users.include = user1 user2
# Specify users not allowed to login (default is all users can login; if user is in both include and exclude lists, then exclude is enforced)
#ducc.authentication.users.exclude = user1 user3
# Specify groups allowed to login (default is all groups can login)
#ducc.authentication.groups.include = groupA groupB
# Specify groups not allowed to login (default is all groups can login; if group is in both include and exclude lists, then exclude is enforced)
#ducc.authentication.groups.exclude = groupA groupC

# Access UIMA message catalogs
ducc.locale.language=en
ducc.locale.country=us

# Specify a minimum amount of free swap space available on a node.
# If an agent detects free swap space dipping below the value defined
# below, it will find the fattest (in terms of memory) process in its
# inventory and kill it. The value of the parameter below is expressed
# in KB.
# Initially disabled by setting the threshold at 0.
#   Set this to 1GB equiv
ducc.node.min.swap.threshold=0

# administrative endpoint for all ducc components
ducc.admin.endpoint=ducc.admin.channel
# endpoint type choices[topic]
ducc.admin.endpoint.type=topic


# jmx port number for Ducc process. Each Ducc process will attempt
# to use this port for its JMX Connector. If the port is not available
# port+1 will be used until an available port is found.
ducc.jmx.port=2099

ducc.agent.jvm.args        = -Xmx500M
ducc.orchestrator.jvm.args = -Xmx1G
ducc.rm.jvm.args           = -Xmx1G
ducc.pm.jvm.args           = -Xmx1G
ducc.sm.jvm.args           = -Xmx1G
ducc.ws.jvm.args           = -Xmx2G -Djava.util.Arrays.useLegacyMergeSort=true

# ========== General Configuration block ==========

# Max number of work-item CASes for each job (default is "unlimited")
# Note: formerly known as ducc.threads.limit
ducc.job.max.pipelines.count = 5000

# ========== CLI Configuration block ==========
# These environment values are included on job/service/AP submissions
ducc.environment.propagated = USER HOME LANG DUCC_SERVICE_INSTANCE

# No timeout on CLI requests
ducc.cli.httpclient.sotimeout=0
#------------------------------------------------------------------------------
#	off,  // CLI submit and cancel signature enforcement disabled
#	on,   // CLI submit and cancel signature enforcement enabled (default)
ducc.signature.required=on
#------------------------------------------------------------------------------

# ========== Web Server Configuration block ==========
ducc.ws.configuration.class=org.apache.uima.ducc.ws.config.WebServerConfiguration

# This endpoint is used for webserver self test to determine viability of broker.
# After 3 missed messages to self via broker, webserver considers broker to be down.
ducc.ws.state.update.endpoint=ducc.ws.state
# endpoint type choices[topic]
ducc.ws.state.update.endpoint.type=topic
ducc.ws.state.publish.rate=5000

# Optionally configure the webserver to run on a non-head node
# ducc.ws.node = my.node.com
# Optionally configure the webserver IP address
# ducc.ws.ipaddress = <fill in an IP address>
# Optionally configure the webserver IP port for HTTP requests, default is 42133
ducc.ws.port = 42133
# Optionally configure the webserver IP port for HTTPS requests, default is 42155
ducc.ws.port.ssl = 42155
# Optionally configure the webserver ssl pw for  HTTPS requests, default is quackquack
# See private/ducc.private.properties
# Optionally configure the webserver login session timeout, in minutes, default is 60
ducc.ws.session.minutes = 60
# Optionally configure the webserver job automatic cancel timeout, default is 10. To disable feature specify 0.
#   Employed when user specifies --wait_for_completion flag on job submission, in which case the job monitor
#   program must visit http://<host>:<port>/ducc-servlet/proxy-job-status?id=<job-id> within this expiry time
#   else the job will be automatically canceled (unless feature disabled) by the webserver acting as the 
#   administrator ducc (which must be specified in the ducc.administrators file).
ducc.ws.automatic.cancel.minutes = 5
# Optionally configure the webserver max history entries for each of Jobs/Reservations/Services
ducc.ws.max.history.entries = 4096
# Specify the ducc webserver jsp compilation directory 
# Note: This directory is removed then recreated on each webserver restart
ducc.ws.jsp.compilation.directory = /tmp/ducc/jsp
# Specify login enabled (default is true)
ducc.ws.login.enabled = false
# For node visualization - if true,strip domain names from labels for cleaner visuals
ducc.ws.visualization.strip.domain = true
# Optionally configure the webserver request log, default is 0 (meaning no request logging)
# Logs are written to DUCC_HOME/logs/webserver
ducc.ws.requestLog.RetainDays = 30

# --------------------------------------------------------------
#    name: ducc.ws.banner.message
# purpose: display banner message on all main pages
# choices: default=none
#  change: effective immediately
#ducc.ws.banner.message = Do not adjust your set.  This is a message from your DUCC administrator.

# ========== Web Server Configuration block ==========

# ========== Job Driver Configuration block ==========
ducc.jd.configuration.class=org.apache.uima.ducc.transport.configuration.jd.JobDriverConfiguration
ducc.jd.state.update.endpoint=ducc.jd.state
# endpoint type choices[topic]
ducc.jd.state.update.endpoint.type=topic
ducc.jd.state.publish.rate=15000
# This is a human-readable string used to form queue names for the JMS queues used to pass 
# CASs from the Job Driver to the Job Processes. The completed queue named comprises the prefix 
# concatenated with the DUCC assigned Job number.
ducc.jd.queue.prefix=ducc.jd.queue.
# After dispatching a work item to UIMA-AS client for processing, the number of minutes that the Job Driver will
# wait for two callbacks (queued and assigned) before considering the work item lost. The elapsed time for the 
# callbacks is normally sub-second. Intermittent network problems may cause unusual spikes.
# If not specified, default value is 5 minutes.
ducc.jd.queue.timeout.minutes=5
# If not specified, default value is 24 hrs (24*60 minutes)
ducc.default.process.per.item.time.max = 1440
# If not specified, default max time in minutes allowed for AE initialization.
ducc.default.process.init.time.max = 120
#   The following 5 values comprise the specification used by the DUCC Orchestrator daemon to request an 
#   allocation from the DUCC Resource Manager for Job Driver use. The values given below are the defaults.
ducc.jd.host.class=JobDriver
ducc.jd.host.description=Job Driver
ducc.jd.host.memory.size=2GB
ducc.jd.host.number.of.machines=1
ducc.jd.host.user=System
#	For a newly started Job, the number of JP UIMA initialization failures
#	allowed until at least one JP succeeds - otherwise, the Job self-destructs.
#	Default is 1.
ducc.jd.startup.initialization.error.limit=1
#   The next 4 values are related - each JD is assigned a piece of the Job Driver host memory which,
#   along with the size of the CR's type system, limits the number of active work-item CASes in a job.
#   To avoid swapping the max heap size should also be restricted.
# Memory size in MB allocated for each JD (default 300)
ducc.jd.share.quantum = 400
#   The number of "slices" of size "jd.share.quantum" kept in reserve.
#   The Orchestrator makes Reservation requests to RM to get Reservations
#   (Job Driver hosts) each of which is then subdivided into "slices", one 
#   per JD.  This number specifies the number of unused "slices" that should 
#   be kept on-hand in anticipation of newly submitted jobs (default 2)
ducc.jd.share.quantum.reserve.count = 3
# The maximum length of a work-item name returned by CAS.getDocumentText().
# Truncation is enforced beyond this limit.
# If not specified, there is no limit.
ducc.jd.workitem.name.maximum.length = 64

# Extra JVM args to be appended to any user-supplied "driver_jvm_args"
# Dynamic: changes to this property immediately affect new submitted work
# Flag: -DUimaAsCasTracking will add to logs: 
#        UIMA-AS client & service trigger internal tracing including RefId,
#        UIMA-AS client onBeforeMessageSendHandler callbacks including RefId, and
#        UIMA-AS client onBeforeProcessCAS callbacks including RefId
# Flag: -DUimaAsClientTracking will add to jd.out.log: 
#        core pool size changes, 
#        UIMA-AS client sendAndReceive invocations, 
#        UIMA-AS client onBeforeMessageSendHandler callbacks, and
#        UIMA-AS client onBeforeProcessCAS callbacks
# Note: should contain an Xmx a little below the "ducc.jd.share.quantum" value
#       the Xmx entry is ignored if the user has specified one
ducc.driver.jvm.args  = -Xmx300M

# Max number of threads in Jetty thread pool servicing incoming
# HTTP requests 
# ducc.driver.jetty.max.threads = 100
# Max idle time for jetty threads (in millis). When a thread exceeds
# its idle time it will be terminated.
# ducc.driver.jetty.thread.idletime = 60000
# Extra JVM args to be appended to any user-supplied "process_jvm_args"
# Dynamic: changes to this property immediately affect new submitted work
# ducc.process.jvm.args=-XX:+HeapDumpOnOutOfMemoryError

# --------------------------------------------------------------
#    name: ducc.jd.communications.scheme
# purpose: specify communications scheme between JD and JPs
# choices: [http,https] default=https
#  change: effective immediately for new jobs
ducc.jd.communications.scheme=https

# --------------------------------------------------------------
#    name: ducc.jd.error.handler.class
# purpose: specify error handler
# default: org.apache.uima.ducc.ErrorHandler
#  change: effective immediately for new jobs
ducc.jd.error.handler.class = org.apache.uima.ducc.ErrorHandler

# --------------------------------------------------------------
#    name: ducc.jd.error.handler.args
# purpose: configure error handler
# choices: max_job_errors=<e> max_timeout_retrys_per_workitem=<r>
#  change: effective immediately for new jobs
ducc.jd.error.handler.args = max_job_errors=15 max_timeout_retrys_per_workitem=0

# ========== Job Driver Configuration block ==========

# ========== Service Manager Configuration block ========== 
# Class used to implement the SM - internals only, don't change.
ducc.sm.configuration.class=org.apache.uima.ducc.sm.config.ServiceManagerConfiguration
# Name of the AMQ topic used to communicate with SM - internals, don't change
ducc.sm.state.update.endpoint=ducc.sm.state
# AMQ protocol to use - internals, don't change
ducc.sm.state.update.endpoint.type=topic
# Default pinger
ducc.sm.default.monitor.class = org.apache.uima.ducc.cli.UimaAsPing
# max consecutive init failures or ping failures for ping-only services before we stop starting things
ducc.sm.instance.failure.max 5
# backward compatibility
ducc.sm.instance.failure.limit ${ducc.sm.instance.failure.max}
# failure window size in MINUTES. 
ducc.sm.instance.failure.window 30
# max consecutive instance init failures before we stop trying to start things
ducc.sm.init.failure.limit  1
# How often services are monitored to insure they're responding, in milliseconds
ducc.sm.meta.ping.rate = 60000
# How many consecutive missed pings are required to mark a service unresponsive
ducc.sm.meta.ping.stability =  10
# How long to wait for a ping to respond, in milliseconds
ducc.sm.meta.ping.timeout =  15000
# Port the CLI uses to contact SM
ducc.sm.http.port=19989
# Node where SM resides 
ducc.sm.http.node=${ducc.head}
# How long to keep a reference-started service alive after the last referencing job exits
ducc.sm.default.linger=300000
# === END == Service Manager Configuration block ========== 

# ========== Orchestrator Configuration block ==========
ducc.orchestrator.configuration.class=org.apache.uima.ducc.orchestrator.config.OrchestratorConfiguration
#------------------------------------------------------------------------------
#	cold, // Recover: All is lost			         		    JD host: employ new
#	warm, // Recover: Unmanaged Reservations only (default) 	JD host: employ new
ducc.orchestrator.start.type=warm
#------------------------------------------------------------------------------
ducc.orchestrator.state.update.endpoint=ducc.orchestrator.state
# endpoint type choices[topic]
ducc.orchestrator.state.update.endpoint.type=topic
ducc.orchestrator.state.publish.rate=10000
#------------------------------------------------------------------------------
# How long between between maintenance cycles (in milliseconds)
# Each maintenance cycle the orchestrator removes obsolete JD queues (MqReaper)
# and performs health related activities (HealthMonitor) including: capping JPs
# for a Jobs that have too many initialization failures and terminating Jobs whose 
# JDs have failed.
ducc.orchestrator.maintenance.rate=60000
#------------------------------------------------------------------------------
# orchestrator's jetty http port
ducc.orchestrator.http.port=19988
# Node where OR is running. This is needed by CLI  to compose a URL to access OR jetty server
ducc.orchestrator.http.node=${ducc.head}
#------------------------------------------------------------------------------
# Specify if reserving an entire machine is allowed
# This could be a bad idea when a cluster has very few, very large machines.
ducc.orchestrator.unmanaged.reservations.accepted=true
# ========== Orchestrator Configuration block ==========

# Resource Manager Configuration block
ducc.rm.configuration.class=org.apache.uima.ducc.rm.config.ResourceManagerConfiguration
# Queue name for broadcast RM state
ducc.rm.state.update.endpoint=ducc.rm.state
# If enabled, RM tries to start as soon as it recovers state from an OR publication,
# instead of waiting for init.stability for nodes to check in. 
ducc.rm.state.update.endpoint.type=topic
# the frequency, relative to or publications, at which RM runs a schedule
ducc.rm.state.publish.ratio = 1

# maximum allotment in GB for Non-preemptable shares - default is unlimited
#ducc.rm.global_allotment = 360

# Base size of dram quantum in Gb
ducc.rm.share.quantum = 1
# Implementation class for actual scheduling algorithm
ducc.rm.scheduler = org.apache.uima.ducc.rm.scheduler.NodepoolScheduler
# File defining the scheduler classes - found in DUCC_HOME/resources
ducc.rm.class.definitions = ducc.classes
# File defining the user registry.  Optional, need not exist.  Found in DUCC_HOME/resources.
ducc.rm.user.registry  = ducc.users
# default memory, in GB, if not specified 
ducc.rm.default.memory = 4
# number of node metrics heartbeats to wait for before rm starts up
ducc.rm.init.stability = 2
# number of missed node metrics updates to consider node down
ducc.rm.node.stability = 5
# which policy to use when shrinking/evicting shares - alternatively, SHRINK_BY_MACHINE
ducc.rm.eviction.policy = SHRINK_BY_INVESTMENT
# max nodes to initially allocate until init is complete
ducc.rm.initialization.cap = 1
# When true, jobs expand not all at once after init, but a bit slower, doubling each epoch
# until max fair-share is set.  If false, jobs increase immediately to their fair share,
# at the cost of mass evictions.
ducc.rm.expand.by.doubling = true
# Predict when a job will end and avoid expanding if not needed
ducc.rm.prediction = true
# Add this fudge factor (milliseconds) to the expansion target when using prediction
ducc.rm.prediction.fudge = 120000
# What is minimum number of processes for a job before we do defrag? If a job has less than this amount
# RM may attempt defragmentation to bring the processes up to this value.
ducc.rm.fragmentation.threshold = 8
# Endpoint for RM admin CLI
ducc.rm.admin.endpoint = ducc.rm.admin.channel
ducc.rm.admin.endpoint.type = queue

# Agent Configuration block
ducc.agent.configuration.class=org.apache.uima.ducc.agent.config.AgentConfiguration
ducc.agent.request.endpoint=ducc.agent
# endpoint type choices[topic]
ducc.agent.request.endpoint.type=topic

# Endpoint where uima as service wrapper reports status
ducc.agent.managed.process.state.update.endpoint=ducc.managed.process.state.update
# endpoint type choices[socket]
ducc.agent.managed.process.state.update.endpoint.type=socket
# endpoint parameters which are transport specific. For socket
# transport params are:
#  - transferExchange=true - include Camel Exchange wrapper in a message 
#  - synch=false - use socket transport for one-way messaging (no replies neeeded)
ducc.agent.managed.process.state.update.endpoint.params=transferExchange=true&sync=false

# max UID reserved by OS. This is used to detect rogue processes and to report
# available memory on a node.
ducc.agent.node.metrics.sys.gid.max=500


ducc.agent.node.metrics.publish.rate=30000
ducc.agent.node.metrics.endpoint=ducc.node.metrics
# endpoint type choices[topic]
ducc.agent.node.metrics.endpoint.type=topic
# Rate at which an agent publishes its process inventory
# The agent will only publish at this rate if there are
# changes since the last publish.
ducc.agent.node.inventory.publish.rate=10000
# If no changes in inventory, publish every 3 intervals defined by ducc.agent.node.inventory.publish.rate
ducc.agent.node.inventory.publish.rate.skip=3
ducc.agent.node.inventory.endpoint=ducc.node.inventory
# endpoint type choices[topic]
ducc.agent.node.inventory.endpoint.type=topic
# ducc.agent.launcher.thread.pool.size - Deprecated
#ducc.agent.launcher.thread.pool.size=10
# enable/disable use of ducc_ling
# ducc.agent.launcher.use.ducc_spawn: true, use ducc_ling. Default: false
ducc.agent.launcher.use.ducc_spawn=true
# specify location of ducc_ling in the filesystem
ducc.agent.launcher.ducc_spawn_path=${DUCC_HOME}/admin/${os.arch}/ducc_ling
# Max amount of time (in millis) agent allows the process to stop before issuing kill -9
ducc.agent.launcher.process.stop.timeout=60000
# Max time in millis allowed for AE initialization. Default 2 hours 7200000. - Deprecated
#ducc.agent.launcher.process.init.timeout=7200000
# exclude the following user ids while detecting rogue processes
ducc.agent.rogue.process.user.exclusion.filter=
#exclude the following processes while detecting rogue processes
ducc.agent.rogue.process.exclusion.filter=sshd:,-bash,-sh,/bin/sh,/bin/bash,grep,ps
# Fudge Factor (in terms of percantage) that agent uses to multiply a share size when 
# determining if a JP exceeds its alloted memory, which is calculated as follows
# (fudge factor/100)*share size + share size. If this number exceeds JPs RSS, the agent
# kills the process.  
ducc.agent.share.size.fudge.factor=5
# Enable/Disable CGroup support. 
ducc.agent.launcher.cgroups.enable=true

# Define location of cgroups utils like cgexec. For mixed clusters with different 
# flavors of unix, the utilities may be in different places. In such case, add a
# a comma separated list of paths like this:
# ducc.agent.launcher.cgroups.utils.dir=/usr/bin,<OS 1 path>,<OS 2 path>
ducc.agent.launcher.cgroups.utils.dir=/usr/bin,/bin
# Set cgroup memory.swappiness
ducc.agent.launcher.cgroups.swappiness=10
# number of retries to use when cgcreate fails
ducc.agent.launcher.cgroups.max.retry.count=1
# amount by which to increase delay (in msecs) between each retry
ducc.agent.launcher.cgroups.retry.delay.factor=2000
# exclusion file to enable node based exclusion for cgroups and aps
# syntax:  <node>=cgroups,ap
# the above will exclude node from using cgroups and/or prevent deployment of APs
ducc.agent.exclusion.file=${DUCC_HOME}/resources/exclusion.nodes
# Define cgroup control subsystems used to enforce fair share on a node
ducc.agent.launcher.cgroups.subsystems=memory,cpu
# Define script which will collect total swap used by a given process. This
# script is launched by an agent via duccling and running as the owner
# of the process.  
ducc.agent.swap.usage.script=${DUCC_HOME}/bin/ducc_get_process_swap_usage.sh

#
# Uncomment the following line to support auto reaping of rogue processes by Ducc's Agent
# ducc.agent.rogue.process.reaper.script=${DUCC_HOME}/admin/ducc_reap_rogues.sh
#
# Process Manager Configuration block
ducc.pm.configuration.class=org.apache.uima.ducc.pm.config.ProcessManagerConfiguration
ducc.pm.request.endpoint=ducc.pm
# endpoint type choices[queue]
ducc.pm.request.endpoint.type=queue
#------------------------------------------------------------------------------
ducc.pm.state.update.endpoint=ducc.pm.state
# endpoint type choices[topic]
ducc.pm.state.update.endpoint.type=topic
ducc.pm.state.publish.rate=15000

# New Configuration classes supporting the DUCC 2.0 isolation from user code. 
ducc.uima-as.configuration.class=org.apache.uima.ducc.transport.configuration.jp.JobProcessConfiguration
ducc.job-process.configuration.class=org.apache.uima.ducc.transport.configuration.jp.JobProcessConfiguration
ducc.service.configuration.class=org.apache.uima.ducc.transport.configuration.service.ServiceConfiguration

ducc.uima-as.endpoint=ducc.job.managed.service
# endpoint type choices[socket]
ducc.uima-as.endpoint.type=socket
# endpoint parameters which are transport specific. For socket
# transport params are:
#  - transferExchange=true - include Camel Exchange wrapper in a message 
#  - synch=false - use socket transport for one-way messaging (no replies neeeded)
ducc.uima-as.endpoint.params=transferExchange=true&sync=false

# saxon8.jar - Saxon is an XSLT and XQuery processor. It is used by UIMA-AS
#              when deploying a service.
ducc.uima-as.saxon.jar.path=file:${DUCC_HOME}/apache-uima/saxon/saxon8.jar

# dd2spring.xsl - contains a set of rules used when transforming 
#                 UIMA-AS deployment descriptor into SpringFramework's 
#                 context file used to deploy UIMA-AS based service.
ducc.uima-as.dd2spring.xsl.path=${DUCC_HOME}/apache-uima/bin/dd2spring.xsl

# maximum amount of time to wait for a response from the JD. This value
# is used by the JP when sending requests to the JD. 
ducc.process.request.timeout=30000

# Define process container class for DD jobs to instantiate and invoke via reflection. 
# The container provides classpath  isolation for user defined analytics.
# The container is instantiated with classes from a System classloader.
ducc.process.uima.as.container.class = org.apache.uima.ducc.user.jp.UimaASProcessContainer

# Define process container class for non-DD jobs to instantiate and invoke via reflection. 
# The container provides classpath  isolation for user defined analytics.
# The container is instantiated with classes from a System classloader.
ducc.process.uima.container.class = org.apache.uima.ducc.user.jp.UimaProcessContainer

# define the sleep time (millis) for JP to use when JD sends empty CAS. In this case the
# JD's CR has processed its collection. The JP threads need to slow down sending
# requests
ducc.process.thread.sleep.time=60000

# Custom Flow Controller to use for Ducc Job Processes that don't provide a process_DD descriptor
ducc.flow-controller.specifier=org.apache.uima.ducc.FlowController


# DATABASE PROPERTIES

# Name of the database host - initially disabled until database is created.
# Overridden in site.ducc.properties by ducc_post_install or db_create.
ducc.database.host            = --disabled--

# Database JMX host. Default is to allow only local JMX access.  Specify the real name for remote access.
ducc.database.jmx.host = localhost
# Database JMX port.
ducc.database.jmx.port = 7199

#-----------------------------------
# DATABASE MEMORY TUNING
#    WARNING: if you're not sure what these do you should probably not change them as incorrect
#             values can adversly affect the database, the database node, or both.
#    Given that.  If you're running on a mostly small system, e.g. 8GB or less, probably you
#    should set ducc.database.mem.heap to 1 or 2 GB and ducc.database.mem.new to 100M
#
#    By default we allow cassandra to calculate these for us.
#
# IMPORTANT: if you set one of these you MUST set both, or cassandra will refuse to start.
#-----------------------------------
# Database xmx.  If not set, cassandra will calculate it for you.
#ducc.database.mem.heap = 4G
# Database setting for 'young' generation.  If not set, cassandra will calculate it for you
#ducc.database.mem.new = 100M
#-----------------------------------
k# END OF DATABASE MEMORY TUNING
#-----------------------------------


# This class implementes the persistence interface for the services registry
#ducc.service.persistence.impl = org.apache.uima.ducc.database.StateServicesDb
ducc.service.persistence.impl  = org.apache.uima.ducc.common.persistence.services.StateServices

# This class implements the persistence interface for Job, Reservation, Service, and AP instances, plus
# the Orchestrator checkpoint.
#ducc.job.history.impl         = org.apache.uima.ducc.database.HistoryManagerDb
ducc.job.history.impl          = org.apache.uima.ducc.transport.event.common.history.HistoryPersistenceManager

#ducc.rm.persistence.impl     = org.apache.uima.ducc.database.RmStatePersistence
ducc.rm.persistence.impl      = org.apache.uima.ducc.common.persistence.rm.NullRmStatePersistence

# end database things -------------------------------------------------------------------------------