| # ----------------------------------------------------------------------- |
| # 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. |
| # |
| # ==================================================================================== |
| |
| # +==================================================================================================+ |
| # | General | |
| # +==================================================================================================+ |
| |
| # The name of the node where DUCC runs. |
| # This property declares the node where the DUCC administrative processes run (Orchestrator, |
| # Resource Manager, Process Manager, Service Manager). This property is required and MUST be |
| # configured in new installation. The installation script ducc_post_install initializes this |
| # property to the node the script is executed on. |
| # Reliable DUCC: if running reliably, then this value must resolve to the same ip address |
| # specified for the virtual_ipaddress in /etc/keepalived/keepalived.conf for master and |
| # backup nodes. To avoid nameserver glitches, consider specifying the ip address, not the |
| # host name. DUCC CLI and Agents employ this value to connect to the current reliable |
| # DUCC head node. |
| ducc.head = <head-node> |
| |
| # Reliable DUCC: if running reliably, then this value must comprise the blank delimited list |
| # of nodes that are eligible to become the DUCC head node. Admin commands start_ducc and |
| # stop_ducc are only allowed on the ducc.head node or any node in the ducc.head.reliable.list. |
| # An empty ducc.head.reliable.list indicates that DUCC is not running in reliably. |
| ducc.head.reliable.list = |
| |
| # The full name of the Java command. |
| # This specifies the full path to the JVM to be used by the DUCC processes. This MUST be |
| # configured. The installation script ducc_post_install initializes this property to |
| # full path to java in the installer's environment. (If the java command cannot be found, |
| # ducc_post_install exits with error.) |
| ducc.jvm = <full-path-to-java-command> |
| |
| # The name of the cluster as shown by the Web Server. |
| # This is a string used in the Web Server banner to identify the local cluster. It is used |
| # for informational purposes only and may be set to anything desired. |
| 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. |
| # This may be used to list site-specific jars that are required by local |
| # customizations, e.g. authentication. The value must be a blank-delimited list of jars |
| # relative to the DUCC_HOME/lib directory. |
| #ducc.local.jars = |
| |
| # Declare the type of middleware providing the JMS service used by DUCC. |
| ducc.jms.provider=activemq |
| |
| |
| # +==================================================================================================+ |
| # | Broker | |
| # +==================================================================================================+ |
| |
| #Declare the wire protocol used to communicate with ActiveMQ. |
| ducc.broker.protocol=tcp |
| |
| # This declares the port on which the ActiveMQ broker is listening for messages. |
| ducc.broker.port=61617 |
| |
| # The broker *client* url decoration (ie - DUCC daemons). |
| ducc.broker.url.decoration=jms.useCompression=true&jms.prefetchPolicy.all=0 |
| |
| # The Broker's name must match the actual broker name in the broker config. |
| # This is the internal name of the broker, used to locate Broker's MBean in |
| # JMX Registry. It is NOT related to any node name. When using the ActiveMQ |
| # distribution supplied with DUCC it should always be set to localhost. |
| ducc.broker.name=localhost |
| |
| # The Broker's jmx port. |
| # This is the port used to make JMX connections to the broker. This should only |
| # be changed by administrators familiar with ActiveMQ configuration. |
| ducc.broker.jmx.port=1100 |
| |
| # If set to true, DUCC will start and stop the ActiveMQ broker as part of its normal |
| # start/stop scripting. |
| ducc.broker.automanage = true |
| |
| # This is the ActiveMQ credentials file used to authenticate DUCC daemons with the |
| # broker. |
| ducc.broker.credentials.file=${ducc.private.resources}/ducc-broker-credentials.properties |
| |
| # This sets the heap size for the broker. |
| ducc.broker.memory.options = -Xmx1G |
| |
| # This is the ActiveMQ configuration file to use. The path |
| # must be specified relative to the ActiveMQ installation directory. |
| ducc.broker.configuration = conf/activemq-ducc.xml |
| |
| # This names the location where ActiveMQ is installed. |
| ducc.broker.home = ${DUCC_HOME}/apache-uima/apache-activemq |
| |
| # The broker "server" URL decoration, |
| # = 45 second timeout on write operations to the socket. |
| ducc.broker.server.url.decoration = transport.soWriteTimeout=45000 |
| |
| |
| # +==================================================================================================+ |
| # | Transport | |
| # +==================================================================================================+ |
| |
| # To enable tracing of RM messages arriving in OR and NodeMetrics arriving in WS. |
| #ducc.transport.trace = orchestrator:RmStateDuccEvent webserver:NodeMetricsUpdateDuccEvent |
| |
| |
| # +==================================================================================================+ |
| # | Authentication | |
| # +==================================================================================================+ |
| |
| # This specifies the class used for Web Server session authentication. |
| # If unconfigured, the Web Server enforces no authentication. |
| #ducc.authentication.implementer=org.apache.uima.ducc.ws.authentication.LinuxAuthenticationManager |
| #ducc.authentication.implementer=org.apache.uima.ducc.ws.authentication.SecureFileAuthenticator |
| #ducc.authentication.implementer=org.apache.uima.ducc.ws.authentication.GSAAuthenticator |
| |
| # Specify users allowed to log in to the web server. |
| #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 |
| |
| |
| # +==================================================================================================+ |
| # | Language | |
| # +==================================================================================================+ |
| |
| # Establish the language for national language support of messages. |
| # Currently only "en" is supported. |
| ducc.locale.language=en |
| # Establish the country for National Language Support of messages. |
| # Currently only "us" is supported. |
| ducc.locale.country=us |
| |
| |
| # +==================================================================================================+ |
| # | Daemon Administration | |
| # +==================================================================================================+ |
| |
| # This is the JMS endpoint name used for DUCC administration messages. |
| ducc.admin.endpoint=ducc.admin.channel |
| |
| # This is the JMS message type used for DUCC administration messages. |
| # Only "topic" is supported. |
| 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. |
| # Every process started by DUCC has JMX enabled by default. |
| # The DUCC WebSever's System.Daemons page is used to find the JMX URL that gets assigned to |
| # each of the DUCC management processes. The Web Server's Job.Details page for each job is |
| # used to find the JMX URL that is assigned to each JP. |
| 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 |
| |
| # use the following flag under IBM Java 8 to allow Chromium to visit |
| # w/o getting ERR_SSL_VERSION_OR_CIPHER_MISMATCH |
| # -Dcom.ibm.jsse2.overrideDefaultTLS=true |
| # see https://issues.apache.org/jira/browse/UIMA-5475 |
| |
| ducc.ws.jvm.args = -Xmx2G -Djava.util.Arrays.useLegacyMergeSort=true -Dcom.ibm.jsse2.overrideDefaultTLS=true |
| |
| # +==================================================================================================+ |
| # | Node Administration | |
| # +==================================================================================================+ |
| |
| # 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 bytes. |
| # Initially disabled by setting the threshold at 0. |
| ducc.node.min.swap.threshold=0 |
| |
| # +==================================================================================================+ |
| # | Job Administration | |
| # +==================================================================================================+ |
| |
| # Max number of work-item CASes for each job (default is "unlimited") |
| # Note: formerly known as ducc.threads.limit |
| # This enforces a maximum number of pipelines per job, over all its processes. No |
| # job will have more active work-items than this dispatched. |
| # The value is related to the size of the Job Driver heap and the real memory consumed by JD. |
| # If the JD is consuming too much memory, try reducing this value. |
| ducc.job.max.pipelines.count = 5000 |
| |
| # +==================================================================================================+ |
| # | CLI Administration | |
| # +==================================================================================================+ |
| |
| # 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 |
| #------------------------------------------------------------------------------ |
| # When set, the CLI signs each request so the Orchestrator can be sure the |
| # requestor is actually who he claims to be. |
| # off, // CLI submit and cancel signature enforcement disabled |
| # on, // CLI submit and cancel signature enforcement enabled (default) |
| ducc.signature.required=on |
| #------------------------------------------------------------------------------ |
| |
| # +==================================================================================================+ |
| # | Web Server | |
| # +==================================================================================================+ |
| |
| # The name of the pluggable java class used to implement the Web Server. |
| ducc.ws.configuration.class=org.apache.uima.ducc.ws.config.WebServerConfiguration |
| |
| # This endpoint is used for Web Server self test to determine viability of broker. |
| # After 3 missed messages to self via broker, Web Server considers broker to be down. |
| ducc.ws.state.update.endpoint=ducc.ws.state |
| |
| # This is the JMS endpoint type used for the state messages sent by the Web Server. |
| ducc.ws.state.update.endpoint.type=topic |
| |
| # The interval in milliseconds between Web Server publications of its state. |
| ducc.ws.state.publish.rate=5000 |
| |
| # The elapsed time in milliseconds between monitored head-node daemons' publications |
| # that if exceeded indicates "down". Default = 120000 (two minutes). |
| ducc.ws.monitored.daemon.down.millis.expiry=120000 |
| |
| # Optionally configure the Web Server to run on a non-head node |
| # This is the name of the node the web server is started on. If not specified, |
| # the web server is started on ${ducc.head}. |
| # ducc.ws.node = my.node.com |
| |
| # Optionally configure the Web Server IP address |
| # In multi-homed systems it may be necessary to specify to which of the multiple addresses |
| # the Web Server listens for requests. This property is an IP address that specifies to which |
| # address the Web Server listens. |
| # ducc.ws.ipaddress = <fill in an IP address> |
| |
| # Optionally configure the Web Server IP port for HTTP requests, default is 42133 |
| ducc.ws.port = 42133 |
| |
| # Optionally configure the Web Server IP port for HTTPS requests, default is 42155 |
| ducc.ws.port.ssl = 42155 |
| |
| # Optionally configure the Web Server welcome page, default is index.html (which forwards to jobs.html) |
| ducc.ws.welcome.page = index.html |
| |
| # Optionally configure the Web Server DUCC_HOME display value, default is absolute path of DUCC_HOME. |
| ducc.ws.display.home = |
| |
| # Optionally configure the Web Server 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 Web Server |
| # acting as the administrator ducc (which must be specified in the ducc.administrators file). |
| ducc.ws.automatic.cancel.minutes = 5 |
| |
| # Optionally configure the Web Server max cached (and thus available for display) |
| # history entries for each of Jobs/Reservations/Services |
| ducc.ws.max.history.entries = 4096 |
| |
| # 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 Web Server request log, default is 0 (meaning no request logging) |
| # Logs are written to DUCC_HOME/logs/webserver |
| ducc.ws.requestLog.RetainDays = 30 |
| |
| # Specify one of { unrestricted, encrypted, blocked } to control |
| # requests to the Web Server with responses containing user data. |
| # When "unrestricted" requests for user data via http or https are honored. |
| # When "encrypted" requests for user data only via https are honored. |
| # When "blocked" requests for user data are not honored. |
| ducc.ws.user.data.access = unrestricted |
| |
| # Note: to employ "encrypted" use the following settings: |
| # ducc.ws.port = 42133 |
| # ducc.ws.port.ssl = 42155 |
| # ducc.ws.login.enabled = true |
| # ducc.ws.user.data.access = encrypted |
| # See documentation for further information. |
| |
| # -------------------------------------------------------------- |
| # 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. |
| |
| # NOTE - Feature under devlopment |
| # When set exposes the Experiments page and enables the ducc_jed_submit script |
| ducc.experiments = false |
| |
| # +==================================================================================================+ |
| # | Job Driver | |
| # +==================================================================================================+ |
| |
| # The name of the pluggable java class used to implement the Job Driver (JD). |
| ducc.jd.configuration.class=org.apache.uima.ducc.transport.configuration.jd.JobDriverConfiguration |
| |
| # This is the JMS endpoint name by the Job Driver to send state to the Orchestrator. |
| ducc.jd.state.update.endpoint=ducc.jd.state |
| |
| # This is the JMS message type used to send state to the Orchestrator. |
| ducc.jd.state.update.endpoint.type=topic |
| |
| # The interval in milliseconds between JD state publications to the Orchestrator. |
| # A higher rate (smaller number) may slightly increase system response but will |
| # increase network load. A lower rate will somewhat decrease system response and |
| # lower network load. |
| 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) |
| # This property specifies the default value for the time, in minutes, that the JD should |
| # wait for a work-item to be processed. If processing has not completed in this time the |
| # process is terminated and the job's error handler decides whether to retry the |
| # work-item or not. |
| ducc.default.process.per.item.time.max = 1440 |
| |
| # If not specified, default max time in minutes allowed for AE initialization. |
| # This property specifies the default value for the time, in minutes, that the agent should |
| # wait for a JP to complete initialization. If initialization is not completed in this time |
| # the process is terminated and and InitializationTimeout status is sent to the JD |
| # which decides whether to retry the process or terminate the job. |
| 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) |
| # When CGroups are enabled, this is the RSS, in MB, that is reserved for each JD process, |
| # and enforced by the CGroup support. Larger JDs are permitted, but the CGroup support will |
| # force the excess RSS onto swap. This potentially slows the performance of that JD, but |
| # preserves the resources for other, better-behaved, JDs. |
| 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). |
| # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
| # If the value specified is 0 then no JD allocation will take place |
| # and all submitted jobs will be rejected. |
| # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
| 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 |
| # details: The error handler class is employed when work items fail or time-out in order |
| # to determine what to do next in three dimensions: |
| # job kill or continue, process kill or continue, work item kill or continue. |
| 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 |
| # details: The error handler args passed to the error handler class (see above). |
| # These values, if any, are combined with any specified by the user. |
| # Individual user specified --driver_exception_handler_arguments <args> |
| # prevail. |
| ducc.jd.error.handler.args = max_job_errors=15 max_timeout_retrys_per_workitem=0 |
| |
| |
| # +==================================================================================================+ |
| # | Service Manager | |
| # +==================================================================================================+ |
| |
| # This is the name of the pluggable java class used to implement the Service Manager. |
| ducc.sm.configuration.class=org.apache.uima.ducc.sm.config.ServiceManagerConfiguration |
| |
| # This is the JMS endpoint name used for API messages received by the Service Manager. |
| ducc.sm.api.endpoint=ducc.sm.api |
| |
| # This is the JMS message type used for API messages received by the Service Manager. |
| ducc.sm.api.endpoint.type=queue |
| |
| # This is the JMS endpoint name used for state messages sent by the Service Manager. |
| ducc.sm.state.update.endpoint=ducc.sm.state |
| |
| # This is the JMS message type used for state messages sent by the Service Manager. |
| ducc.sm.state.update.endpoint.type=topic |
| |
| # Default pinger |
| # This is the name of the default UIMA-AS ping/monitor class. The default class issues |
| # get-meta to a service and uses JMX to fetch queue statistics for presentation in |
| # the Web Server. |
| # This name is either: |
| # - The fully qualified name of the class to use as the default UIMA-AS pinger. It may |
| # be necessary to include the class or jar file in the classpath used to start the SM. |
| # (The recommended way to do this is add an entry to the ducc.local.jars property |
| # in ducc.properties. |
| # - The name of a pinger registration file. This is the recommended way to |
| # provide installation-customized pingers. In short, it resides in ducc.properties |
| # and contains the full set of ping-related properties needed to run a pinger. |
| ducc.sm.default.monitor.class = org.apache.uima.ducc.sm.UimaAsPing |
| |
| # This is the maximum number of consecutive failures of service instance initialization |
| # permitted before DUCC stops creating new instances. When this cap is hit the SM |
| # will disable autostart for the service. It may be overridden by the service |
| # registration's instance_failures_limit parameter. |
| ducc.sm.instance.failure.max 5 |
| |
| # backward compatibility |
| ducc.sm.instance.failure.limit ${ducc.sm.instance.failure.max} |
| |
| # This specifies a window of time in minutes over which some number of service instance |
| # failures are tolerated. If the maximum number of tolerated failures is |
| # exceeded within this time window the Service Manager ceases to restart |
| # instances automatically. The maximum tolerated failures is defined in |
| # ducc.sm.instance.failure.max. |
| # This may be overridden by individual service pingers using the registration |
| # property instance_failures_window. |
| ducc.sm.instance.failure.window 30 |
| |
| # max consecutive instance init failures before we stop trying to start things |
| ducc.sm.init.failure.limit 1 |
| |
| # This is the time, in milliseconds, between pings by the Service Manager |
| # to each known, running service. |
| ducc.sm.meta.ping.rate = 60000 |
| |
| # This is the number of consecutive pings that may be missed before a |
| # service is considered unavailable. |
| ducc.sm.meta.ping.stability = 10 |
| |
| # This is the time in milliseconds the SM waits for a response to a ping. If the service does |
| # not respond within this time the ping is accounted for as a "missed" ping. |
| ducc.sm.meta.ping.timeout = 15000 |
| |
| # This is the HTTP port used by the Service Manager to field requests from the CLI / API. |
| # ***** |
| # NOTE: for backward CLI / API compatibility (2.2.0 and before) this port is the same as |
| # ducc.orchestrator.http.port. This entry can otherwise be deleted post-2.2.0 as it is no |
| # longer used by the current CLI / API. |
| # ***** |
| ducc.sm.http.port=${ducc.orchestrator.http.port} |
| |
| # This is the node where the Service Manager runs. It MUST be ${ducc.head}. |
| ducc.sm.http.node=${ducc.head} |
| |
| # This is the length of time, in milliseconds, that the SM allows a service to remain alive after |
| # all jobs that reference it have exited. If no new job referencing it enters the system before this |
| # time has expired, the SM stops the service. |
| ducc.sm.default.linger=300000 |
| |
| # +==================================================================================================+ |
| # | Orchestrator | |
| # +==================================================================================================+ |
| |
| # This is the name of the pluggable java class used to implement the DUCC Orchestrator. |
| ducc.orchestrator.configuration.class=org.apache.uima.ducc.orchestrator.config.OrchestratorConfiguration |
| |
| # This indicates the level of recovery to be taken on restarting a |
| # system. There are three levels of startup: |
| # [cold] All reservations are canceled, all currently running |
| # jobs (if any) are terminated. All services are terminated. The |
| # system starts with no jobs, reservations, or services active. |
| # [warm] All active work is continued. |
| #------------------------------------------------------------------------------ |
| # cold, // Recover: All active are forced to Completed JD host: employ new |
| # warm, // Recover: All Jobs+Services+Reservations (default) JD host: employ current |
| ducc.orchestrator.start.type=warm |
| #------------------------------------------------------------------------------ |
| |
| # This is the name of the JMS endpoint through which the Orchestrator broadcasts its |
| # state messages. These messages include full job information and can be relatively |
| # large, though they are now compressed. |
| ducc.orchestrator.state.update.endpoint=ducc.orchestrator.state |
| |
| # This is the JMS endpoint type used for the state messages sent by the Orchestrator. |
| ducc.orchestrator.state.update.endpoint.type=topic |
| |
| # The interval in milliseconds between Orchestrator publications of its state. |
| 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 |
| |
| #------------------------------------------------------------------------------ |
| # This is the HTTP port used by the Orchestrator to field requests from the CLI / API. |
| ducc.orchestrator.http.port=19988 |
| |
| # Node where Orchestrator is running. It MUST be ${ducc.head}. |
| ducc.orchestrator.http.node=${ducc.head} |
| |
| #------------------------------------------------------------------------------ |
| # Specify if reserving an entire machine is allowed |
| # Allowing could be a bad idea when a cluster has very few, very large machines. |
| ducc.orchestrator.unmanaged.reservations.accepted=true |
| |
| #------------------------------------------------------------------------------ |
| # This is the name of the JMS endpoint through which the daemons broadcast state changes |
| ducc.daemons.state.change.endpoint=ducc.daemons.state.change |
| |
| # This is the JMS endpoint type used for the state change messages sent by the daemons. |
| ducc.daemons.state.change.endpoint.type=queue |
| |
| # +==================================================================================================+ |
| # | Resource Manager (aka Scheduler) | |
| # +==================================================================================================+ |
| |
| # This is the name of the pluggable java class used to implement the DUCC Resource |
| # Manager. |
| ducc.rm.configuration.class=org.apache.uima.ducc.rm.config.ResourceManagerConfiguration |
| |
| # This is the name of the JMS endpoint through which the Resource Manager broadcasts its |
| # state. |
| ducc.rm.state.update.endpoint=ducc.rm.state |
| |
| # This is the JMS endpoint type used for state messages sent by the Resource Manager. |
| ducc.rm.state.update.endpoint.type=topic |
| |
| # This specifies the frequency of RM schedules, relative to the number of Orchestrator publications. |
| # If the value is set to 1, RM runs and publishes a schedule immediately on receipt of OR state. |
| # If set to some number N, RM runs a schedule after receipt of every N Orchestrator publications. |
| ducc.rm.state.publish.ratio = 1 |
| |
| # This specifies the maximum non-preemptable shares any user may be awarded, in GB. If not configured, |
| # there is no maximum enforced. This can be overridden on a per-user basis in the user registry. |
| #ducc.rm.global_allotment = 360 |
| |
| # The share quantum is the smallest amount of RAM that is schedulable for jobs, in GB. |
| # Jobs are scheduled based entirely on their memory requirements. Memory is allocated in |
| # multiples of the share quantum. |
| ducc.rm.share.quantum = 1 |
| |
| # The component that implements the scheduling algorithm is pluggable. This specifies the |
| # name of that class. |
| 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. |
| # The registry is used only to override the global allotments. The registry entries may also |
| # be placed in the ducc.classes file if desired. |
| 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. |
| # During DUCC initialization the Resource Manager must wait some period of time for |
| # all the nodes in the cluster to check-in via their "heartbeats". If the RM were to start |
| # scheduling too soon there would be a period of significant "churn" as the perceived cluster |
| # configurations changes rapidly. As well, it would be impossible to recover work in a warm |
| # or hot start if the affected nodes had not yet checked in. |
| # The init.stability property indicates how many heartbeat intervals the RM must wait before |
| # it starts scheduling after initialization. |
| ducc.rm.init.stability = 2 |
| |
| # Number of missed node metrics updates to consider node down. |
| # The RM receives regular "heartbeats" from the DUCC agents in order to know what |
| # nodes are available for scheduling. The node.stability property configures the number of |
| # consecutive heartbeats that may be missed before the Resource Manager considers the |
| # node to be inoperative. |
| # If a node becomes inoperative, the Resource Manager deallocates all processes on that |
| # node and attempts to reallocate them on other nodes. The node is marked offline and is |
| # unusable until its heartbeats start up again. |
| # The default configuration declares the agent heartbeats to occur at 30 second intervals. |
| # (see ducc.agent.node.metrics.publish.rate) |
| # Therefore heartbeats must be missed for 3 minutes before the Resource Manager takes |
| # corrective action. |
| ducc.rm.node.stability = 6 |
| |
| # Which policy to use when shrinking/evicting shares - alternatively, SHRINK_BY_MACHINE. |
| # The eviction.policy is a heuristic to choose which processes of a job to preempt because of |
| # competition from other jobs. |
| # The SHRINK_BY_INVESTMENT (default) policy attempts to preempt processes such that the |
| # least amount of work is lost. It chooses candidates for eviction in order of: |
| # - Processes still initializing, with the smallest time spent in the initializing step. |
| # - Processes whose currently active work items have been executing for the shortest time. |
| # The SHRINK_BY_MACHINE policy attempts to preempt processes so as to minimize |
| # fragmentation on machines with large memories that can contain multiple job processes. |
| # No consideration of execution time or initialization time is made. |
| ducc.rm.eviction.policy = SHRINK_BY_INVESTMENT |
| |
| # Max nodes to initially allocate until init is complete. |
| # The type of jobs supported by DUCC generally have very long and often fragile |
| # initialization periods. Errors in the applications and other problems such is missing or |
| # errant services can cause processes to fail during this phase. |
| # To avoid preempting running jobs and allocating a large number of resources to jobs only |
| # to fail during initialization, the Resource Manager schedules a small number of processes |
| # until it is determined that the initialization phase will succeed. |
| # The initialization.cap determines the maximum number of processes allocated to a job |
| # until at least one process successfully initializes. Once any process initializes the Resource |
| # Manager will proceed to allocate the job its full fair share of processes. |
| # The initialization cap can be overridden on a class basis by configuration via ducc.classes. |
| 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. |
| # Expand.by.doubling can be overridden on a class basis by configuration via ducc.classes. |
| ducc.rm.expand.by.doubling = true |
| |
| # Predict when a job will end and avoid expanding if not needed. |
| # Because initialization time may be very long, it may be the case that a job that might be |
| # eligible for expansion will be able to complete in the currently assigned shares before any |
| # new processes are able to complete their initialization. In this case expansion results in |
| # waste of resources and potential eviction of processes that need not be evicted. |
| # The Resource Manager monitors the rate of task completion and attempts to predict the |
| # maximum number of processes that will be needed at a time in the future based on the |
| # known process initialization time. If it is determined that expansion is unnecessary then it |
| # is not done for the job. |
| # Prediction can be overridden on a class basis by configuration via ducc.classes. |
| ducc.rm.prediction = true |
| |
| # Add this fudge factor (milliseconds) to the expansion target when using prediction. |
| # When ducc.rm.prediction is enabled, the known initialization time of a job's processes plus |
| # some "fudge" factor is used to predict the number of future resources needed. The "fudge" |
| # is specified in milliseconds. |
| # The default "fudge" is very conservative. Experience and site policy should be used to set a |
| # more practical number. |
| # Prediction.fudge can be overridden on a class basis by configuration via ducc.classes. |
| 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. |
| # If enabled, limited defragmentation of resources is performed by the Resource Manager to |
| # create sufficient space to schedule work that has insufficient resources (new jobs, for |
| # example.). The term "insufficient" is defined as "needing more processes than the |
| # defragmentation # threshold, but currently having fewer processes than the defragmentation |
| # threshold." These are called "needy" jobs. Additionally, the Resource Manager |
| # will never evict processes from ``needy'' jobs for the purpose of defragmentation. |
| # This property allows installations to customize the value used to determine if a |
| # job is "needy". Jobs with fewer processes than this are potentially needed, and |
| # jobs with more processes are never needy. |
| ducc.rm.fragmentation.threshold = 8 |
| |
| # This JMS endpoint used for RM administrative requests. |
| ducc.rm.admin.endpoint = ducc.rm.admin.channel |
| |
| # This is the JMS endpoint type used for RM administrative requests. |
| ducc.rm.admin.endpoint.type = queue |
| |
| # This JMS endpoint used for RM administrative requests. |
| ducc.rm.via.or.admin.endpoint = ducc.rm.via.or.admin.channel |
| |
| # This is the JMS endpoint type used for RM administrative requests. |
| ducc.rm.via.or.admin.endpoint.type = queue |
| |
| # Unmanaged Reservations are usually assigned to machines whose size exactly matches the |
| # requested size, after rounding up to a multiple of the node pool's quantum. |
| # When this property is positive, machines up to this many GB larger than the rounded up |
| # size will be considered. |
| ducc.rm.reserve_overage = 0 |
| |
| # +==================================================================================================+ |
| # | Agents | |
| # +==================================================================================================+ |
| |
| # This is the name of the pluggable java class used to implement the DUCC Agents. |
| ducc.agent.configuration.class=org.apache.uima.ducc.agent.config.AgentConfiguration |
| |
| # This is the JMS endpoint through which agents receive state from the Process Manager. |
| ducc.agent.request.endpoint=ducc.agent |
| |
| # This is the JMS endpoint type used for state messages sent by the Process Manager. |
| ducc.agent.request.endpoint.type=topic |
| |
| # This is the JMS endpoint used to communicate |
| # from the managed process to the Agent (Job Process). |
| ducc.agent.managed.process.state.update.endpoint=ducc.managed.process.state.update |
| |
| # This is the JMS endpoint type used to communicate |
| # from the managed process (Job Process) to the Agent. |
| 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 |
| |
| # ***** Note: the Resource Manager uses the data in the node metrics for scheduling. |
| |
| # The interval in milliseconds between node metric publications. |
| # Every agent publishes its updates at this rate. On large clusters, a high rate (small |
| # interval) can be a burden on the network. |
| ducc.agent.node.metrics.publish.rate=30000 |
| |
| # This is the JMS endpoint used to send node metrics updates to listeners. Listeners |
| # are usually the Resource Manager and Web Server. These messages serve as node |
| # "heartbeats". As well, the node metrics heartbeats contain the amount of RAM on the node |
| # and the number of processors. |
| ducc.agent.node.metrics.endpoint=ducc.node.metrics |
| |
| # This is the JMS endpoint type used to send node metrics updates from the agents. |
| ducc.agent.node.metrics.endpoint.type=topic |
| |
| # The interval in milliseconds between node inventory publications. |
| # If the inventory has not changed since the last update the agent bypasses sending the |
| # update, up to a maximum of ducc.agent.node.inventory.publish.rate.skip times. |
| ducc.agent.node.inventory.publish.rate=10000 |
| |
| # This is the number of times the agent will bypass publishing its node inventory if the |
| # inventory has not changed. |
| ducc.agent.node.inventory.publish.rate.skip=3 |
| |
| # This is the JMS endpoint used to send node inventory messages to listeners. Listeners are |
| # usually the Orchestrator and Web Server. Information in these messages include a map of |
| # processes being managed on the node. |
| ducc.agent.node.inventory.endpoint=ducc.node.inventory |
| |
| # This is the JMS endpoint type used to send node inventory updates from the agents. |
| 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. |
| # This property specifies the full path to the ducc_ling utility. During installation ducc_ling |
| # is normally moved to local disk and given setuid-root privileges. Use this property to tell |
| # the DUCC agents the location of the installed ducc_ling. The default location is within |
| # an architecture dependent subdiretory of DUCC_HOME/admin. |
| # The arcitecture is derived from the JRE property os.arch. During DUCC installation |
| # the ducc_ling utility is compiled for the architecture of the host where DUCC is installed. |
| # In heterogeneous clusters, the system administrator should run the utility build_duccling |
| # once on a machine of each architecture to insure this utility gets correctly installed. |
| 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. |
| # This property specifies the time, in milliseconds, the agent should wait before forcibly |
| # terminating a job process (JP) after an attempted graceful shutdown. If the child process |
| # does not terminate in the specified time, it is forcibly terminated with kill -9. |
| # This type of stop can occur because of preemption or system shutdown. |
| 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 |
| # The DUCC Agents scan nodes for processes that should not be running; for example, |
| # a job may have left a 'rogue' process alive when it exits, or a user may log in to a node |
| # unexpectedly. These processes are reported to the administrators via the webserver for |
| # possible action. |
| # This configuration parameter enumerates userids which are ignored by the rogue-process scan. |
| # default = root,posstfix,ntp,nobody,daemon,100 |
| ducc.agent.rogue.process.user.exclusion.filter= |
| |
| # Max UID reserved by OS. This is used to detect rogue processes and to report |
| # available memory on a node. |
| # The ducc.agent.node.metrics.sys.uid.max property is droped in favor of |
| # ducc.agent.rogue.process.sys.user.max, which seems more descriptive |
| # |
| # ducc.agent.node.metrics.sys.uid.max=500 |
| ducc.agent.rogue.process.sys.uid.max=500 |
| |
| # Exclude the following processes while detecting rogue processes |
| # The DUCC Agents scan nodes for processes that should not be running; for example, |
| # a job may have left a 'rogue' process alive when it exits, or a user may log in to a node |
| # unexpectedly. These processes are reported to the administrators via the webserver for |
| # possible action. |
| # This configuration parameter enumerates processes by name which are ignored by the |
| # rogue process detector. |
| # default = sshd:,-bash,-sh,/bin/sh,/bin/bash,grep,ps |
| 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. |
| # The DUCC agent monitors the size of the resident memory of its spawned processes. If a |
| # process exceeds its declared memory size by any significant amount it is terminated and |
| # a ShareSizeExceeded message is sent. The Job Driver counts this towards the maximum |
| # errors for the job and will eventually terminate the job if excessive such errors occur. |
| # This property defines the percentage over the declared memory size that a process is |
| # allowed to grow to before being terminated. |
| # To disable this feature, set the value to -1. |
| ducc.agent.share.size.fudge.factor=5 |
| |
| # Enable/Disable CGroup support. |
| # If CGroups are not installed on a specific machine, this is ignored. |
| # With CGroups the RSS for a managed process (plus any children processes it may spawn) is |
| # limited to the allocated share size. Additional memory use goes to swap space. DUCC |
| # monitors and limits swap use to the same proportion of total swap space as allocated |
| # share size is to total RAM. If a process exceeds its allowed swap space it is terminated |
| # and a ShareSizeExceeded message is sent to the Job Driver. |
| # Nodes not using CGroups fall back to the ducc.agent.share.size.fudge.factor. |
| 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 |
| # Defines a delay factor in millis an agent will use to determine how long it |
| # should sleep between cgroup create retries. Each time cgcreate fails |
| # an agent will increment the delay by adding the delay factor to a previous |
| # delay. If the delay factor is 2000, on first cgcreate failure an agent will |
| # wait 2000 ms, on second failure the wait time will be 4000, on third 6000, and |
| # so on. |
| 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 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}/admin/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 | |
| # +==================================================================================================+ |
| |
| # This is the name of the pluggable java class used to implement the DUCC Process Manager. |
| ducc.pm.configuration.class=org.apache.uima.ducc.pm.config.ProcessManagerConfiguration |
| |
| # This is the endpoint through which process manager receive state from the Orchestrator. |
| ducc.pm.request.endpoint=ducc.pm |
| |
| # This is the JMS endpoint type used for state messages sent by the Orchestrator. |
| ducc.pm.request.endpoint.type=queue |
| |
| # This is the endpoint through which process manager sends its heartbeat. The main receiver |
| # is the Web Server for it's daemon status page. |
| ducc.pm.state.update.endpoint=ducc.pm.state |
| |
| # This is the JMS endpoint type used for process manager heartbeats. The primary receiver |
| # is the Web Server for its daemon status page. |
| ducc.pm.state.update.endpoint.type=topic |
| |
| # The interval in milliseconds between process manager heartbeat publications. |
| ducc.pm.state.publish.rate=15000 |
| |
| # +==================================================================================================+ |
| # | Job Process | |
| # +==================================================================================================+ |
| |
| # This is the name of the pluggable java class that implements |
| # the shell for Agent launched user processes. |
| 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 |
| |
| # This is the endpoint through which job processes (JPs) receive messages from the Agents. |
| ducc.uima-as.endpoint=ducc.job.managed.service |
| |
| # This is the JMS endpoint type used for messages sent to the JPs from the Agents. |
| 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 | |
| # +==================================================================================================+ |
| |
| # Name of the database host(s) - initially disabled until database is created. |
| # Overridden in site.ducc.properties by ducc_post_install or db_create. |
| # This is the name of the host(s) where the database is run. It usually defaults to the |
| # same host as the ducc.head. Those knowledgable of the database can install the |
| # database elsewhere. Use this parameter to specify that location(s). |
| # To disable use of the database, set this parameter to the string --disabled-- |
| ducc.database.host.list = --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 |
| |
| # If set to true, DUCC will start and stop the Cassandra database as part of its normal |
| # start/stop scripting. |
| ducc.database.automanage = true |
| |
| # Path to Cassandra database home |
| ducc.database.home = ${DUCC_HOME}/cassandra-server |
| |
| #----------------------------------- |
| # 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. |
| # This is the value used to set {\em Xmx and Xms} when the database starts. The |
| # Cassandra database makes an attempt to determine the best value of this. The |
| # default is one-half of real memory, up to a maximum of 8G. It is recommended that |
| # the default be used. However, small installations may reduce this to as little |
| # as 512M. Note that both Xmx and Xms are set. |
| #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 ------------------------------------------------------------------------------- |
| |
