| % |
| % 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. |
| % |
| |
| \section{Properties} |
| |
| Public properties are in a primary configuration file is called ducc.properties |
| and always resides in the directory |
| ducc\_runtime/resources. |
| |
| Private properties are in a secondary configuration file call ducc.private.properties |
| and always resides in the directory |
| ducc\_runtime/resources/private. |
| |
| \section{Properties merging} |
| \label{sec:admin.properties-merge} |
| |
| With DUCC 2.0.0 the shipped DUCC properties file is designed to be read-only. Installations |
| create a local properties file which is automatically merged with the default properties file |
| as part of system startup. |
| |
| The shipped DUCC properties file is called {\em default.ducc.properties}. This file should |
| never be edited or modified. |
| |
| The local site override properties file is called {\em site.ducc.properties}. This is a |
| normal Java properties file containing override and additional properties. An initial |
| {\em site.ducc.properties} is created on installation of DUCC 2.0.0 by {\em ducc\_post\_install}. |
| |
| On startup |
| (\hyperref[subsec:admin.start-ducc]{\em start\_ducc}), |
| verification |
| (\hyperref[subsec:admin.check-ducc]{\em check\_ducc}), |
| and RM reconfiguration |
| (\hyperref[subsec:admin.rm-reconfigure]{\em rm\_reconfigure}), |
| the two properties files are |
| merged, with {\em site.ducc.properties} taking preference, to create the operational file, |
| {\em ducc.properties}, which is used by all DUCC components. This file should not be |
| edited as it will be over-written whenever {\em start\_ducc} or {\em check\_ducc} is run. |
| |
| \section{ducc.properties} |
| \label{sec:ducc.properties} |
| |
| Some of the properties in ducc.properties are intended as the "glue" that brings the various |
| DUCC components together and lets then run as a coherent whole. These types of properties should |
| be modified only by developers of DUCC itself. In the description below these properties are |
| classified as "Private". |
| |
| Some of the properties are tuning parameters: timeouts, heartbeat intervals, and so on. These |
| may be modified by DUCC administrators, but only after experience is gained with DUCC, and only |
| to solve specific performance problems. The default tuning parameters have been chosen by the |
| DUCC system developers to provide "best" operation under most reasonable situations. In the |
| description below these properties are classified as "Tuning". |
| |
| Some of the properties describe the local cluster configuration: the location of the ActiveMQ |
| broker, the location of the Java JRE, port numbers, etc. These should be modified by the DUCC |
| administrators to configure DUCC to each individual installation. In the description below these |
| properties are classified as "Local". |
| |
| See also |
| |
| \subsection{General DUCC Properties} |
| \begin{description} |
| |
| \item[ducc.authentication.implementer] \hfill \\ |
| This specifies the class used for WebServer session authentication. If unconfigured, |
| the Web Server enforces no authentication. |
| \begin{description} |
| \item[Default] org.apache.uima.ducc.common.authentication.LinuxAuthenticationManager |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.authentication.users.include] \hfill \\ |
| Specify users allowed to log in to the web server. This is used only |
| if {\em ducc.authentication.implementor} is the LinuxAuthenticationManager. |
| \begin{description} |
| \item[Default] All users may log in. |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.authentication.users.exclude] \hfill \\ |
| Specify users not allowed to log in to the webserver. This is used only |
| if {\em ducc.authentication.implementor} is the LinuxAuthenticationManager. |
| \begin{description} |
| \item[Default] No users are excluded. |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.authentication.groups.include] \hfill \\ |
| Specify groups allowed to log in. Groups are defined by Unix authentication. Only |
| users in the groups specified here may log in to the web server. This is used only |
| if {\em ducc.authentication.implementor} is the LinuxAuthenticationManager. |
| \begin{description} |
| \item[Default] Users in all groups may log in. |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.authentication.groups.exclude] \hfill \\ |
| Specify groups not allowed to log in. Groups are defined by Unix authentication. |
| Users in the groups specified here may not log in to the web server. This is used only |
| if {\em ducc.authentication.implementor} is the LinuxAuthenticationManager. |
| \begin{description} |
| \item[Default] No users are excluded due to group membership. |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.admin.endpoint] \hfill \\ |
| This is the JMS endpoint name used for DUCC administration messages. |
| \begin{description} |
| \item[Default] ducc.admin.channel |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.admin.endpoint.type] \hfill \\ |
| This is the JMS message type used for DUCC administration requests. If changed DUCC |
| admin may not work. |
| \begin{description} |
| \item[Default] topic |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.broker.automanage] \hfill \\ |
| If set to ``true'', DUCC will start and stop the ActiveMQ broker as part of its normal start/stop |
| scripting. |
| \begin{description} |
| \item[Default] true |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.broker.configuration] \hfill \\ |
| This is the ActiveMQ configuration file to use, for auto-managed brokers only. The path |
| must be specified relative to the ActiveMQ installation directory. |
| \begin{description} |
| \item[Default] conf/activemq-ducc.xml |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.broker.credentials] \hfill \\ |
| This is the ActiveMQ credentials file used to authenticate DUCC daemons with the broker, for |
| auto-managed brokers only. |
| \begin{description} |
| \item[Default] \${ducc.private.resources}/ducc-broker-credentials.properties |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.broker.home] \hfill \\ |
| For DUCC auto-managed brokers only, this names the location where ActiveMQ is installed |
| installed. |
| |
| Note that the DUCC installation includes a default ActiveMQ. |
| \begin{description} |
| \item[Default] \duccruntime/activemq |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.broker.memory.options] \hfill \\ |
| For DUCC auto-managed brokers only, this names the ActiveMQ configuration file. The configuration |
| file is assumed to reside in the directory specified by {\em ducc.broker.home}, so the path must be relative |
| to that location. |
| \begin{description} |
| \item[Default] conf/activemq-ducc.xml |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.broker.url.decoration] \hfill \\ |
| The property is used by the DUCC Job Driver processes to modify the ActiveMQ broker URL |
| when connecting to the Job Processes. |
| |
| The supplied default is used to disable broker connection timeouts. From the ActiveMQ |
| documentation: "The maximum inactivity duration (before which the socket is considered |
| dead) in milliseconds. On some platforms it can take a long time for a socket to appear to |
| die, so we allow the broker to kill connections if they are inactive for a period of |
| time. Use by some transports to enable a keep alive heart beat feature. Set to a value |
| less-than-or-equal0 to disable inactivity monitoring. Declare the wire protocol used to |
| communicate with ActiveMQ." |
| |
| This decoration is used to keep the broker connection alive while a JVM is in a |
| long garbage collection. The applications that DUCC is designed to support can |
| spend significant time in garbage collection, which can cause spurious timeouts. By |
| default the DUCC configuration disables the timeout by setting it to 0. |
| |
| \begin{description} |
| \item[Default] wireFormat.maxInactivityDuration=0 |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.broker.hostname] \hfill \\ |
| This declares the node where the ActiveMQ broker resides. It MUST be updated to |
| the actual node where the broker is running as part of DUCC installation. The default value |
| will not work. |
| \begin{description} |
| \item[Default] \$\{ducc.head\}. The default is defined in the ducc property, {\em ducc.head}. |
| If you want to run the ActiveMQ broker on the ``ducc head'', this parameter need not |
| be changed. |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.broker.jmx.port] \hfill \\ |
| This is the port used to make JMX connections to the broker. This should only |
| be changed by administrators familiar with ActiveMQ configuration. |
| \begin{description} |
| \item[Default] 1100 |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.broker.memory.options] \hfill \\ |
| For DUCC auto-managed brokers only, this sets the {\tt -Xmx} heap size for the broker. |
| \begin{description} |
| \item[Default] -Xmx2G |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.broker.name] \hfill \\ |
| 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''. The default should be changed only by |
| administrators familiar with ActiveMQ configuration. |
| \begin{description} |
| \item[Default] localhost |
| \item[Type] Local |
| \end{description} |
| |
| |
| \item[ducc.broker.port] \hfill \\ |
| This declares the port on which the ActiveMQ broker is listening for |
| messages. It MAY be updated as part of DUCC installation. ActiveMQ ships with port |
| 61616 as the default port, and DUCC uses that default. |
| \begin{description} |
| \item[Default] 61617 |
| \item[Type] Local |
| \end{description} |
| |
| |
| \item[ducc.broker.protocol] \hfill \\ |
| Declare the wire protocol used to communicate with ActiveMQ. |
| \begin{description} |
| \item[Default] tcp |
| \item[Type] Private |
| \end{description} |
| |
| |
| \item[ducc.broker.server.url.decoration] \hfill \\ |
| For DUCC auto-managed brokers only, this configures ActiveMQ Server url decoration. |
| |
| \begin{description} |
| \item[Default] transport.soWriteTimeout=45000 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.cli.httpclient.sotimeout] \hfill \\ |
| This is the timeout used by the CLI to communicate with DUCC, in milliseconds. If no |
| response is heard within this time, the request times out and is aborted. When set to 0 (the |
| default), the request never times out. |
| \begin{description} |
| \item[Default] 0 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.cluster.name] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default] Apache UIMA-DUCC |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.head] \hfill \\ |
| This property declares the node where the DUCC adminstrative processes run (Orchestrator, |
| Resource Manager, Process Manager, Service Manager). This property is required and MUST be |
| configured in new installation. The installation script |
| \hyperref[subsec:admin.ducc-post-install]{ducc\_post\_install} initializes this property to the |
| node the script is executed on. |
| \begin{description} |
| \item[Default] There is no default, this must be configured during system installation. |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.jms.provider] \hfill \\ |
| Declare the type of middleware providing the JMS service used by DUCC. |
| \begin{description} |
| \item[Default] activemq |
| \item[Type]Private |
| \end{description} |
| |
| \item[ducc.jmx.port] \hfill \\ |
| Every process started by DUCC has JMX enabled by default. When more than one process |
| runs on the same machine this can cause port conflicts. The property "ducc.jmx.port" is |
| used as the base port for JMX. If the port is busy, it is incremented internally until a free |
| port is found. |
| |
| The web server's \hyperref[sec:system-details.daemons]{"System $->$ Daemons"} tab is used |
| to find the JMX URL that gets assigned to each of the DUCC management processes. The web |
| server's \hyperref[sec:ws-job-details]{Job details} page for each job is used to find the |
| JMX URL that is assigned to each JP. |
| |
| \begin{description} |
| \item[Default] 2099 |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.jvm] \hfill \\ |
| This specifies the full path to the JVM to be used by the DUCC processes. This MUST be |
| configured. The installation script |
| \hyperref[subsec:admin.ducc-post-install]{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.) |
| \begin{description} |
| \item[Default] None. Must be configured during installation. |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.local.jars] \hfill \\ |
| 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 {\em DUCC\_HOME/lib} directory. |
| \begin{description} |
| \item[Default] (unconfigured) |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.node.min.swap.threshold] \hfill \\ |
| 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. |
| |
| If set to 0, the threshold is disabled. |
| \begin{description} |
| \item[Default] 0 |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.agent.jvm.args] \hfill \\ |
| This specifies the list of arguments passed to the JVM when spawning the Agent. |
| \begin{description} |
| \item[Default] -Xmx100M |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.driver.jvm.args] \hfill \\ |
| If enabled, the arguments here are automatically added to the JVM arguments specified for |
| the Job Driver process. |
| |
| Note: if the user-supplied JVM arguments contain a -Xmx entry then |
| any -Xmx value specified here will be ignored. |
| \begin{description} |
| \item[Default] (unconfigured) |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.driver.jetty.max.threads] \hfill \\ |
| Max number of threads in Jetty thread pool servicing incoming HTTP requests. |
| \begin{description} |
| \item[Default] 100 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.driver.jetty.thread.idletime] \hfill \\ |
| Max idle time for jetty threads (in milliseconds). When a thread exceeds |
| its idle time it will be terminated. |
| \begin{description} |
| \item[Default] 60000 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.orchestrator.jvm.args] \hfill \\ |
| This specifies the list of arguments passed to the JVM when spawning the Orchestrator. |
| \begin{description} |
| \item[Default] -Xmx1G |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.pm.jvm.args] \hfill \\ |
| This specifies the list of arguments passed to the JVM when spawning the Process Manager. |
| \begin{description} |
| \item[Default] -Xmx1G |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.process.jvm.args] \hfill \\ |
| If enabled, the arguments here are added by DUCC to the JVM arguments in the user's job |
| processes. |
| \begin{description} |
| \item[Default] (unconfigured) |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.rm.jvm.args] \hfill \\ |
| This specifies the list of arguments passed to the JVM when spawning the Resource |
| Manager. |
| \begin{description} |
| \item[Default] -Xmx1G |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.security.home] \hfill \\ |
| This directory holds the encryption keys used for request validation. |
| By default DUCC employs {\em \$\{user.home\}} as the user's security directory. |
| When ducc.security.home is specified, DUCC will instead employ {\em \$\{ducc.security.home\}/\$\{user.name\}} |
| \begin{description} |
| \item[Default] (unconfigured) |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.sm.jvm.args] \hfill \\ |
| This specifies the list of arguments passed to the JVM when spawning the Service Manager. |
| \begin{description} |
| \item[Default] -Xmx1G |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.ws.jvm.args] \hfill \\ |
| specifies the list of arguments passed to the JVM when spawning the |
| Webserver. |
| \begin{description} |
| \item[Default] -Xmx8G |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.locale.language] \hfill \\ |
| Establish the language for national language support of messages. Currently only "en" is |
| supported. |
| \begin{description} |
| \item[Default] en |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.locale.country] \hfill \\ |
| Establish the country for National Language Support of messages. Currently only "us" is |
| supported. |
| \begin{description} |
| \item[Default] us |
| \item[Type] Private |
| \end{description} |
| |
| |
| \item[ducc.runmode] \hfill \\ |
| When set to "Test" this property bypasses userid and authentication checks. It is intended |
| for use ONLY by DUCC developers. It allows developers of DUCC to simulate a multiuser |
| environment without the need for root privileges. |
| |
| Note: WARNING! Enabling this feature in a production DUCC system is a serious |
| security breach. It should only be set by DUCC developers running with an un-privileged |
| ducc\_ling. |
| \begin{description} |
| \item[Default] Unconfigured. When unconfigured, test mode is DISABLED. |
| \item[Type] Local |
| \end{description} |
| |
| |
| \item[ducc.ssh] \hfill \\ |
| When set to "False" this property bypasses use of ssh. |
| |
| It is intended for use ONLY by DUCC developers. It allows developers of DUCC |
| to simulate a multinode environment without the need for ssh to "remote" nodes |
| for a single host deployment. |
| |
| Note: WARNING! Enabling this feature in a production DUCC system is a serious |
| distributed computing usability hinderance. It should only be set by DUCC developers |
| for testing or demo purposes. |
| |
| \begin{description} |
| \item[Default] True |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.signature.required] \hfill \\ |
| When set, the CLI signs each request so the Orchestrator can be sure the requestor is |
| actually who he claims to be. |
| \begin{description} |
| \item[Default] on |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.job.max.pipelines.count] \hfill \\ |
| 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. |
| |
| Note: formerly ducc.threads.limit |
| |
| \begin{description} |
| \item[Default] 5000 |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.environment.propagated] \hfill \\ |
| This specifies the environmental variables whose values will be merged with the |
| user-specified environment option on job, process and service submissions. |
| |
| \begin{description} |
| \item[Default] USER HOME LANG DUCC\_SERVICE\_INSTANCE |
| \item[Type] Local |
| \end{description} |
| |
| \end{description} |
| |
| |
| \subsection{Web Server Properties} |
| |
| \begin{description} |
| \item[ducc.ws.configuration.class] \hfill \\ |
| The name of the pluggable java class used to implement the Web Server. |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.ws.config.WebServerConfiguration |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.ws.node] \hfill \\ |
| This is the name of the node the web server is started on. If not specified, the web server is |
| started on {\tt \$\{ducc\.head\}}. |
| \begin{description} |
| \item[Default Value] (unconfigured) |
| \item[Type] Local |
| \end{description} |
| |
| |
| \item[ducc.ws.ipaddress] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] (unconfigured) |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.ws.port] \hfill \\ |
| This is the port on which the DUCC Web Server listens for requests. |
| \begin{description} |
| \item[Default Value] 42133 |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.ws.port.ssl] \hfill \\ |
| This is the port that the Web Server uses for SSL requests (such as authentication). |
| \begin{description} |
| \item[Default Value] 42155 |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.ws.banner.message] \hfill \\ |
| A message to be displayed under the banner of each main page. |
| Changes are effective immediately. |
| Can be used, for example, to post a notice that the cluster will |
| be down for maintenenace. |
| \begin{description} |
| \item[Default Value] None |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.ws.session.minutes] \hfill \\ |
| Once authenticated, this property determines the lifetime of the authenticated session to the |
| Web Server. |
| \begin{description} |
| \item[Default Value] 60 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.ws.max.history.entries] \hfill \\ |
| DUCC maintains a history of all jobs. The state of jobs, both old and current are shown |
| in the Webserver's Jobs Page. To avoid overloading this page and the Web Server, the maximum |
| number of entries that can be shown is regulated by this parameter. |
| \begin{description} |
| \item[Default Value] 4096 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.ws.login.enabled] \hfill \\ |
| If true, users are allowed to login to Webserver. If false, users are |
| not allowed to login to Webserver. Shipped value set to false. |
| However, default value if property not specified is true. |
| \begin{description} |
| \item[Default Value] true |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.ws.precalculate.machines] \hfill \\ |
| This is a choice between updating the sorted internal representation of the |
| Machines page as each Agent publication arrives (true, somewhat CPU intensive |
| in a large cluster but fast browser response time) and updating only upon viewer |
| demand (false, CPU intensive for each browser request with slower response time). |
| \begin{description} |
| \item[Default Value] true |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.ws.automatic.cancel.minutes] \hfill \ Optionally configure the webserver job |
| automatic cancel timeout. To disable this feature specify 0. This is employed when a user |
| specifies {\em$--$wait\_for\_completion} flag on job submission, in which case the job |
| monitor program must visit |
| \begin{verbatim} |
| http://<host>:<port>/ducc-servlet/proxy-job-status?id=<job-id> |
| \end{verbatim} |
| within this expiry time. Otherwise the job will be automatically canceled. |
| |
| This provides a safeguard against runaway jobs or managed reservations, if the |
| submitter gets disconnected from DUCC in some way. |
| |
| If the feature is disabled by specifing ``0'', no work is canceled even if the |
| monitor itself disappears. |
| |
| \begin{description} |
| \item[Default Value] 10 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.ws.jsp.compilation.directory] \hfill \\ |
| This specifies the temporary used by the Web Server's JSP engine to compile its JSPs. |
| The directory contents are removed each time the Web Server is restarted. |
| \begin{description} |
| \item[Default Value] /tmp/ducc/jsp |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.ws.requestLog.RetainDays] \hfill \\ |
| Optionally configure the webserver request log, default, if not configured, is 0 (meaning no request logging). |
| Logs are written to DUCC\_HOME/logs/webserver. |
| \begin{description} |
| \item[Default Value] 30 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.ws.visualization.strip.domain] \hfill \\ |
| If set, the visualization will strip domain names from nodes to present a cleaner visualization. |
| \begin{description} |
| \item[Default Value] true |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.ws.state.update.endpoint] \hfill \\ |
| This is the name of the JMS endpoint through which the Webserver broadcasts its state messages. |
| These messages are broadcast to self to determine viability of the broker. |
| \begin{description} |
| \item[Default Value] ducc.ws.request |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.ws.state.update.endpoint.type] \hfill \\ |
| This is the JMS endpoint type used for the state messages sent by the Webserver. |
| \begin{description} |
| \item[Default Value] topic |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.ws.state.publish.rate] \hfill \\ |
| \phantomsection\label{itm:props-ws.state.publish.rate} |
| |
| The interval in milliseconds between Webserver publications of its state. |
| \begin{description} |
| \item[Default Value] 5000 |
| \item[Type] Private |
| \end{description} |
| |
| \end{description} |
| |
| |
| \subsection{Job Driver Properties} |
| \begin{description} |
| \item[ducc.jd.configuration.class] \hfill \\ |
| The name of the pluggable java class used to implement the Job Driver (JD). |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.jd.config.JobDriverConfiguration |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.jd.state.update.endpoint] \hfill \\ |
| This is the JMS endpoint name by the Job Driver to send state to the Orchestrator. |
| \begin{description} |
| \item[Default Value] ducc.jd.state |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.jd.startup.initialization.error.limit] \hfill \\ |
| For a newly started Job, the number of Job Process (JP) initialization failures |
| allowed until at least one JP succeeds - otherwise, the Job self-destructs. |
| \begin{description} |
| \item[Default Value] 1 |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.jd.state.update.endpoint.type] \hfill \\ |
| This is the JMS message type used to send state to the Orchestrator. |
| \begin{description} |
| \item[Default Value] topic |
| \item[Type] Private |
| \end{description} |
| |
| |
| \item[ducc.jd.state.publish.rate] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] 15000 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.jd.share.quantum] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] 400 |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.jd.workitem.name.maximum.length] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] (unconfigured) |
| \item[Type] Local |
| \end{description} |
| |
| |
| \item[ducc.jd.error.handler.class] \hfill \\ |
| The error handler class 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. |
| User specified $--$driver\_exception\_handler <class> prevails. |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.ErrorHandler |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.jd.error.handler.args] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] max\_job\_errors=15 max\_timeout\_retrys\_per\_workitem=0 |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.default.process.per.item.time.max] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] 1440 |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.default.process.init.time.max] \hfill \\ |
| 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. |
| |
| \begin{description} |
| \item[Default Value] 120 |
| \item[Type] Local |
| \end{description} |
| |
| |
| \end{description} |
| |
| |
| |
| |
| |
| \subsection{Service Manager Properties} |
| \begin{description} |
| |
| \item[ducc.sm.configuration.class] \hfill \\ |
| This is the name of the pluggable java class used to implement the Service Manager. |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.sm.config.JobDriverConfiguration |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.sm.default.monitor.class] \hfill \\ |
| This is the name of the default UIMA-AS ping/monitor class. The default class issues |
| {\em get-meta} to a service and uses JMX to fetch queue statistics for presentation in |
| the web server. |
| |
| This name is either |
| \begin{enumerate} |
| \item 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 reccomended way to do this is add an entry to the {\em ducc.local.jars} property |
| in {\em ducc.properties.} |
| |
| \item The name of a pinger registration file. This is the reccomended way to |
| provide installation-customized pingers. See the \hyperref[chap:sm]{Service Management} |
| chapter for details of setting up this file. In short, it resides in {\em ducc.properties} |
| and contains the full set of ping-related properties needed to run a pinger. |
| \end{enumerate} |
| |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.cli.UimaAsPing |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.sm.state.update.endpoint] \hfill \\ |
| This is the JMS endpoint name used for state messages sent by the Service Manager. |
| \begin{description} |
| \item[Default Value] ducc.sm.state |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.sm.state.update.endpoint.type] \hfill \\ |
| This is the JMS message type used for state messages sent by the Service Manager. |
| \begin{description} |
| \item[Default Value] topic |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.sm.meta.ping.rate] \hfill \\ |
| This is the time, in milliseconds, between pings by the Service Manager |
| to each known, running service. |
| \begin{description} |
| \item[Default Value] 60000 |
| \item[Typ] Tuning |
| \end{description} |
| |
| \item[ducc.sm.meta.ping.stability] \hfill \\ |
| This is the number of consecutive pings that may be missed before a |
| service is considered unavailable. |
| \begin{description} |
| \item[Default Value] 10 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.sm.meta.ping.timeout] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] 15000 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.sm.http.port] \hfill \\ |
| This is the HTTP port used by the Service Manager to field requests from the CLI / API. |
| \begin{description} |
| \item[Default Value] 19989 |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.sm.http.node] \hfill \\ |
| This is the node where the Service Manager runs. It MUST be configured as part of DUCC |
| setup. The {\em ducc\_post\_install} procedures initialize this to {\em \$\{ducc.head\}}. |
| \begin{description} |
| \item[Default Value] \$\{ducc.head\} |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.sm.default.linger] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] 300000 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.sm.init.failure.limit] \hfill \\ |
| 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 {\em instance\_failures\_limit} parameter. |
| |
| NOTE: This was {\em ducc.sm.instance.failure.max} which is now deprecated. |
| \begin{description} |
| \item[Default Value] 2 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.sm.instance.failure.limit] \hfill \\ |
| This is the maximum number of instance failures allowed within some period of |
| time before the Service Manger disables {\em autostart} and ceases to restart |
| instances automatically. The time window for failures is defined with the |
| property {\em ducc.sm.instance.failure.window}. |
| |
| This may be overridden by individual service pingers using the registration |
| property {\em instance\_failures\_limit}. See the |
| \hyperref[subsec:cli.ducc-services.register]{service registration options} |
| for details. |
| |
| \begin{description} |
| \item[Default Value] 5 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.sm.instance.failure.window] \hfill \\ |
| 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 |
| {\em ducc.sm.instance.failure.limit}. |
| |
| This may be overridden by individual service pingers using the registration |
| property {\em instance\_failures\_window}. See the |
| \hyperref[subsec:cli.ducc-services.register]{service registration options} |
| for details. |
| |
| \begin{description} |
| \item[Default Value] 30 (minutes) |
| \item[Type] Tuning |
| \end{description} |
| |
| \end{description} |
| |
| |
| \subsection{Orchestrator Properties} |
| \begin{description} |
| \item[ducc.orchestrator. configuration.class] \hfill \\ |
| This is the name of the pluggable java class used to implement the DUCC Orchestrator. |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.orchestrator.config.OrchestratorConfiguration |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.orchestrator.start.type] \hfill \\ |
| This indicates the level of recovery to be taken on restarting a |
| system. There are two levels of startup: |
| \begin{description} |
| \item[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. |
| |
| \item[warm] All unmanaged reservations are restored. All currently |
| running jobs (if any) are terminated. All services are started or |
| restarted as indicated by their state when the system went down. |
| The system starts with no jobs active, but unmanaged reservations |
| and services are preserved. |
| |
| \item[Default Value] warm |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.orchestrator.state.endpoint] \hfill \\ |
| This is the name of the JMS endpoint through which the Orchestrator broadcasts its full |
| state messages. These messages include full job information and can be large. This state is |
| used by the Process Manager and the Webserver. |
| \begin{description} |
| \item[Default Value] ducc.orchestrator.request |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.orchestrator.state.update.endpoint.type] \hfill \\ |
| This is the JMS endpoint type used for the "full" state messages sent by the Orchestrator. |
| \begin{description} |
| \item[Default Value] topic |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.orchestrator.state.publish.rate] \hfill \\ |
| \phantomsection\label{itm:props-or.state.publish.rate} |
| |
| The interval in milliseconds between Orchestrator publications of its non-abbreviated |
| state. |
| \begin{description} |
| \item[Default Value] 10000 |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.orchestrator.maintenance.rate] \hfill \\ |
| This is the interval in milliseconds between Orchestrator maintenance cycles, which check |
| and update history and state. |
| \begin{description} |
| \item[Default Value] 60000 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.orchestrator.http.port] \hfill \\ |
| This is the HTTP port used by the Orchestrator to field requests from the CLI / API. |
| \begin{description} |
| \item[Default Value] 19988 |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.orchestrator.http.node] \hfill \\ |
| This is the node where the Orchestrator runs. It MUST be configured as part of DUCC |
| setup. The {\em ducc\_post\_install} procedures initialize this to {\em \$\{ducc.head\}}. |
| \begin{description} |
| \item[Default Value] \$\{ducc.head\} |
| \item[Type] Local |
| \end{description} |
| |
| \item[ducc.orchestrator.unmanaged.reservations.accepted] \hfill \\ |
| This flag controls whether the Orchestrator will accept requests for |
| unmanaged reservations (true) or deny request for unmanaged reservations |
| (false). |
| \begin{description} |
| \item[Default Value] true |
| \item[Type] Local |
| \end{description} |
| \end{description} |
| |
| \subsection{Resource Manager Properties} |
| |
| \begin{description} |
| \item[ducc.rm.configuration.class] \hfill \\ |
| This is the name of the pluggable java class used to implement the DUCC Resource |
| Manager. |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.rm.config.ResourceManagerConfiguration |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.rm.state.update.endpoint] \hfill \\ |
| This is the name of the JMS endpoint through which the Resource Manager broadcasts its |
| abbreviated state. |
| \begin{description} |
| \item[Default Value] ducc.rm.state |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.rm.state.update.endpoint.type] \hfill \\ |
| This is the JMS endpoint type used for state messages sent by the Resource Manager. |
| \begin{description} |
| \item[Default Value] topic |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.rm.state.publish.ratio] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] 1 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.rm.share.quantum] \hfill \\ |
| 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. |
| |
| See the \hyperref[chap:rm]{Resource Management} section for more information on the share quantum. |
| \begin{description} |
| \item[Default Value] 1 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.rm.global.allotment] \hfill \\ |
| 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. |
| See the \hyperref[chap:rm]{Resource Management} section for more information on the share quantum. |
| \begin{description} |
| \item[Default Value] (not set, no limit imposed) |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.rm.scheduler] \hfill \\ |
| The component that implements the scheduling algorithm is pluggable. This specifies the |
| name of that class. |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.rm.scheduler.NodepoolScheduler |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.rm.user.registry] \hfill \\ |
| This names the file with the user registr, within the DUCC\_HOME/resources directoryy. |
| As of this version of DUCC, the registry is used |
| only to override the global allotments. The registry entries may also be placed in the |
| \hyperref[sec:ducc.classes]{\em ducc.classes} file if desired. |
| \begin{description} |
| \item[Default Value] ducc.users |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.rm.class.definitions] \hfill \\ |
| This specifies the name of the file that contains the site's class definitions. This file is |
| described in detail in the \hyperref[sec:ducc.classes]{\em ducc.classes} section. |
| \begin{description} |
| \item[Default Value] ducc.classes |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.rm.node.stability] \hfill \\ |
| 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 1 minute intervals. |
| Therefore heartbeats must be missed for five minutes before the Resource Manager takes |
| corrective action. |
| \begin{description} |
| \item[Default Value] 5 |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.rm.init.stability] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] 2 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.rm.eviction.policy] \hfill \\ |
| The alternative value is 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 policy attempts to preempt processes such that the |
| least amount of work is lost. It chooses candidates for eviction in order of: |
| \begin{enumerate} |
| \item Processes still initializing, with the smallest time spent in the initializing step. |
| \item Processes whose currently active work items have been executing for the shortest |
| time. |
| \end{enumerate} |
| 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. |
| \begin{description} |
| \item[Default Value] SHRINK\_BY\_INVESTMENT |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.rm.initialization.cap] \hfill \\ |
| 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 |
| \hyperref[sec:ducc.classes]{ducc.classes}. |
| |
| \begin{description} |
| \item[Default Value] 1 |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.rm.expand.by.doubling] \hfill \\ |
| When a job expands because its fair share has increased, or it has completed initialization, |
| it may be desired to govern the rate of expansion. If expand.by.doubling is set to "true", |
| rather than allocate the full fair share of processes, the number of processes is doubled |
| each scheduling cycle, up to the maximum allowed. |
| |
| Expand.by.doubling can be overridden on a class basis by configuration via |
| \hyperref[sec:ducc.classes]{ducc.classes}. |
| |
| \begin{description} |
| \item[Default Value] true |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.rm.prediction] \hfill \\ |
| 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 |
| \hyperref[sec:ducc.classes]{ducc.classes}. |
| \begin{description} |
| \item[Default Value] true |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.rm.prediction.fudge] \hfill \\ |
| \phantomsection\label{itm:props-rm.prediction.fudge} |
| |
| 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 |
| \hyperref[sec:ducc.classes]{ducc.classes}. |
| |
| \begin{description} |
| \item[Default Value] 120000 |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.rm.defragmentation.threshold] \hfill \\ |
| \phantomsection\label{itm:props-rm.defragmentation.threshold} |
| |
| If {\em ducc.rm.defragmentation} is enable, 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 |
| {\em 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. |
| |
| \begin{description} |
| \item[Default Value] 8 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.rm.admin.endpoint] \hfill \\ |
| This JMS endpoint used for RM administrative requests. |
| \begin{description} |
| \item[Default Value] ducc.rm.admin.channe. |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.rm.admin.type] \hfill \\ |
| This is the JMS endpoint type used for RM administrative requests. |
| \begin{description} |
| \item[Default Value] ducc.rm.admin.channe. |
| \item[Type] Private |
| \end{description} |
| |
| |
| \end{description} |
| |
| |
| |
| \subsection{Agent Properties} |
| |
| \begin{description} |
| |
| \item[ducc.agent.configuration.class] \hfill \\ |
| This is the name of the pluggable java class used to implement the DUCC Agents. |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.nodeagent.config.AgentConfiguration |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.agent.request.endpoint] \hfill \\ |
| This is the JMS endpoint through which agents receive state from the Process Manager. |
| \begin{description} |
| \item[Default Value] ducc.agent |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.agent.request.endpoint.type] \hfill \\ |
| This is the JMS endpoint type used for state messages sent by the Process Manager. |
| \begin{description} |
| \item[Default Value] topic |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.agent.managed.process.state.update.endpoint] \hfill \\ |
| This is the JMS endpoint used to communicate from the managed process to the Agent |
| (Job Process). |
| \begin{description} |
| \item[Default Value] ducc.managed.process. state.update |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.agent.managed.process.state.update.endpoint.type] \hfill \\ |
| This is the JMS endpoint type used to communicate from the managed process (Job |
| Process) to the Agent. |
| \begin{description} |
| \item[Default Value] socket |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.agent.managed.process. state.update.endpoint.params] \hfill \\ |
| These are configuration parameters for the Agent-to-JP communication socket. These |
| should only be modified by DUCC developers. |
| \begin{description} |
| \item[Default Value] transferExchange=true\&sync=false |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.agent.node.metrics.endpoint] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] ducc.node.metrics |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.agent.node.metrics.endpoint.type] \hfill \\ |
| This is the JMS endpoint type used to send node metrics updates from the agents. |
| \begin{description} |
| \item[Default Value] topic |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.agent.node.metrics.publish.rate] \hfill \\ |
| 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. |
| |
| Note: the Resource Manager uses the data in the node metrics for scheduling. |
| \begin{description} |
| \item[Default Value] 60000 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.agent.node.inventory.endpoint] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] ducc.node.inventory |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.agent.node.inventory.endpoint.type] \hfill \\ |
| This is the JMS endpoint type used to send node inventory updates from the agents. |
| \begin{description} |
| \item[Default Value] topic |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.agent.node.inventory.publish.rate] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] 10000 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.agent.node.inventory.publish.rate.skip] \hfill \\ |
| This is the number of times the agent will bypass publishing its node inventory if the |
| inventory has not changed. |
| \begin{description} |
| \item[Default Value] 30 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.agent.launcher.thread.pool.size] \hfill \\ |
| This is establishes the size of the agent's threadpool used to manage spawned processes. |
| \begin{description} |
| \item[Default Value] 10 |
| \item[Type] Tuning |
| \end{description} |
| Deprecated. |
| |
| \item[ducc.agent.launcher.ducc\_spawn\_path] \hfill \\ |
| 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 {\em os.arch}. During DUCC installation the {\em 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 {\em build\_duccling} once on |
| a machine of each architecture to insure this utility gets correctly installed. |
| \begin{description} |
| \item[Default Value] \ducchome/admin/\${os.arch}/ducc\_ling |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.agent.launcher.process.stop.timeout] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] 60000 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.agent.launcher.process.init.timeout] \hfill \\ |
| This property specifies the time, in milliseconds, that the agent should wait for a job |
| process (JP) to complete initialization. If initialization is not completed in this time the |
| process is terminated and and InitializationTimout status is send to the job driver (JD) |
| which decides whether to retry the process or terminate the job. |
| |
| \begin{description} |
| \item[Default Value] 7200000 |
| \item[Type] Tuning |
| \end{description} |
| Deprecated. Replaced by ducc.default.process.init.time.max (in minutes) |
| |
| |
| \item[ducc.agent.share.size.fudge.factor] \hfill \\ |
| |
| 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. |
| \begin{description} |
| \item[Default Value] 5 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.agent.rogue.process.user.exclusion.filter] \hfill \\ |
| \phantomsection\label{itm:props-rogue.user} |
| |
| 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. |
| \begin{description} |
| \item[Default Value] root,posstfix,ntp,nobody,daemon,100 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.agent.rogue.process.exclusion.filter] \hfill \\ |
| \phantomsection\label{itm:props-rogue.process} |
| 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. |
| |
| \begin{description} |
| \item[Default Value] sshd:,-bash,-sh,/bin/sh,/bin/bash,grep,ps |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \phantomsection\label{itm:props-agent.cgroups.enable} |
| \item[ducc.agent.launcher.cgroups.enable] \hfill \\ |
| Enable or disable CGroups 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. |
| |
| \begin{description} |
| \item[Default Value] true |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.agent.launcher.cgroups.utils.dir] \hfill \\ |
| \phantomsection\label{itm:ducc.agent.launcher.cgroups.utils.dir} |
| Location of CGroups programs, like cgexec. If CGroups are not |
| installed on a specific machine, this is ignored. |
| |
| Depending on the OS, CGroups programs may be installed in different places. |
| Provide a comma separated list of directories the agent should search to find the programs. |
| |
| \begin{description} |
| \item[Default Value] /usr/bin |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.agent.launcher.cgroups.basedir] \hfill \\ |
| \phantomsection\label{itm:ducc.agent.launcher.cgroups.basedir} |
| Location where ducc related CGroups will be created. |
| |
| \begin{description} |
| \item[Default Value] /cgroup/ducc |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.agent.launcher.cgroups.max.retry.count] \hfill \\ |
| \phantomsection\label{ducc.agent.launcher.cgroups.max.retry.count} |
| Defines how many times an agent attempts to create a cgroup after |
| a failure. |
| |
| \begin{description} |
| \item[Default Value] 10 |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \item[ducc.agent.launcher.cgroups.retry.delay.factor] \hfill \\ |
| \phantomsection\label{ducc.agent.launcher.cgroups.retry.delay.factor} |
| 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. |
| |
| \begin{description} |
| \item[Default Value] 2000 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.agent.launcher.cgroups.swappiness] \hfill \\ |
| \phantomsection\label{ducc.agent.launcher.cgroups.swappiness} |
| Defines cgroup swappiness. |
| |
| \begin{description} |
| \item[Default Value] 10 |
| \item[Type] Tuning |
| \end{description} |
| |
| \phantomsection\label{itm:props-agent.cgroups.exclusion} |
| \item[ducc.agent.exclusion.file] \hfill \\ |
| This specifies the exclusion file to enable node based exclusion for various |
| features. Currently only CGroup exclusion is supported. |
| |
| The exclusion file has one line per agent of the form: |
| \begin{verbatim} |
| <node>=cgroups |
| \end{verbatim} |
| If the keyword ``cgrouops'' is found, the node is excluded from CGroup |
| support. |
| |
| \begin{description} |
| \item[Default Value] Not configured. |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \end{description} |
| |
| |
| \subsection{Process Manager Properties} |
| |
| \begin{description} |
| |
| \item[ducc.pm.configuration.class] \hfill \\ |
| This is the name of the pluggable java class used to implement the DUCC Process |
| Manager. |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.pm.config.ProcessManagerConfiguration |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.pm.request.endpoint] \hfill \\ |
| This is the endpoint through which process manager receive state from the Orchestrator. |
| \begin{description} |
| \item[Default Value] ducc.pm |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.pm.request.endpoint.type] \hfill \\ |
| This is the JMS endpoint type used for state messages sent by the Orchestrator. |
| \begin{description} |
| \item[Default Value] queue |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.pm.state.update.endpoint] \hfill \\ |
| This is the endpoint through which process manager sends its heartbeat. The main receiver |
| is the Web Server for it's daemon status page. |
| \begin{description} |
| \item[Default Value] ducc.pm.state |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.pm.state.update.endpoint.type] \hfill \\ |
| This is the JMS endpoint type used for process manager heartbeats. The primary receiver |
| is the Web Server for its daemon status page. |
| \begin{description} |
| \item[Default Value] topic |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.pm.state.publish.rate] \hfill \\ |
| The interval in milliseconds between process manager heartbeat publications. |
| \begin{description} |
| \item[Default Value] 25000 |
| \item[Type] Private |
| \end{description} |
| |
| |
| \end{description} |
| |
| |
| \subsection{Job Process Properties} |
| |
| \begin{description} |
| |
| \item[ducc.uima-as.configuration.class] \hfill \\ |
| This is the name of the pluggable java class that implements the the UIMA-AS service |
| shell for job processes (JPs). |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.transport.configuration.jp.JobProcessConfiguration |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.uima-as.endpoint] \hfill \\ |
| This is the endpoint through which job processes (JPs) receive messages from the Agents. |
| \begin{description} |
| \item[Default Value] ducc.job.managed.service |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.uima-as.endpoint.type] \hfill \\ |
| This is the JMS endpoint type used for messages sent to the JPs from the Agents. |
| \begin{description} |
| \item[Default Value] socket |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.uima-as.endpoint.params] \hfill \\ |
| This configures the JP-to-Agent communication socket. It should be changed only by |
| DUCC developers. |
| \begin{description} |
| \item[Default Value] transferExchange=true\&sync=false |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.uima-as.saxon.jar.path] \hfill \\ |
| This configures the path the required Saxon jar. |
| \begin{description} |
| \item[Default Value] file:\ducchome/apache-uima/saxon/saxon8.jar |
| \item[Type] Private |
| \end{description} |
| |
| |
| \item[ducc.uima-as.dd2spring.xsl.path] \hfill \\ |
| This configures the path the required dd2spring xsl definitions. |
| \begin{description} |
| \item[Default Value] \ducchome/apache-uima/bin/dd2spring.xsl |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.uima-as.flow-controller.specifier] \hfill \\ |
| This configures the pluggable class that implements the default flow controller used in the |
| DUCC job processes (JPs). |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.FlowController |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.process.request.timeout] \hfill \\ |
| This is the maximum amount of time to wait for a response from a JD, in milliseconds. This value |
| is used by a JP when sending requests to the JD. |
| \begin{description} |
| \item[Default Value] 30000 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.process.uima.as.container.class] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.user.jp.UimaASProcessContainer |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.process.uima.container.class] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] org.apache.uima.ducc.user.jp.UimaProcessContainer |
| \item[Type] Private |
| \end{description} |
| |
| \item[ducc.process.thread.sleep.time] \hfill \\ |
| Define the sleep time in milliseconds 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 |
| \begin{description} |
| \item[Default Value] 3000 |
| \item[Type] Tuning |
| \end{description} |
| |
| |
| \end{description} |
| |
| |
| \subsection{Database Configuration Properties} |
| \label{subsec:ducc.database.properties} |
| |
| \begin{description} |
| |
| \item[ducc.database.host] \hfill \\ |
| This is the name of the host 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. |
| |
| To disable use of the database, set this parameter to the string {\em --disabled--}. |
| \begin{description} |
| \item[Default Value] The same as your ducc.head. |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.database.jmx.host] \hfill \\ |
| This is the name of the database host for JMX access. If it is ``localhost'' then only local |
| JMX access is supported. If it is set to the real name of the database host then remote JMX |
| access is possible. |
| \begin{description} |
| \item[Default Value] localhost |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.database.jmx.port] \hfill \\ |
| This is the JMX port used by the database. Normally it need not be changed. |
| It is set via the cassandra-env.sh script so must not be in the range of values used by the |
| other daemons, i.e. values just above {\em ducc.jmx.port}. |
| \begin{description} |
| \item[Default Value] 7199 |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.database.mem.heap] \hfill \\ |
| 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. |
| \begin{description} |
| \item[Default Value] Determined by Cassandra, up to 8G max. |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.database.mem.new] \hfill \\ |
| This is the default for the ``young'' generation when the JVM needs more memory. |
| In general, the default is correct. If you're not familiar with Java's memory |
| management it is safest to not modify this. |
| \begin{description} |
| \item[Default Value] Determined by Cassandra. |
| \item[Type] Tuning |
| \end{description} |
| |
| \item[ducc.service.persistence.impl] \hfill \\ |
| This specifies the class used to implement persistence for the Service Manager's registry. |
| The installation procedures for the database automatically update your {\em site.ducc.properties} |
| to use the correct default. |
| |
| There |
| are two supported values: |
| \begin{verbatim} |
| org.apache.uima.ducc.common.persistence.services.StateServices |
| org.apache.uima.ducc.database.StateServicesDb |
| \end{verbatim} |
| |
| The first value implements the service registry in the file system in the directory |
| {\tt DUCC\_HOME/state/services}. |
| |
| When the database is installed, the service registry is implemented over the database. |
| |
| \begin{description} |
| \item[Default Value] When the database is enabled: |
| \begin{verbatim} |
| org.apache.uima.ducc.database.StateServicesDb |
| \end{verbatim} |
| |
| When the database is not enabled: |
| \begin{verbatim} |
| org.apache.uima.ducc.common.persistence.services.StateServices |
| \end{verbatim} |
| \item[Type] Private |
| \end{description} |
| |
| |
| \item[ducc.job.history.impl] \hfill \\ |
| This specifies the class used to implement persistence for job history and the |
| Orchestrator checkpoint. |
| The installation procedures for the database automatically update your {\em site.ducc.properties} |
| to use the correct default. |
| |
| The two supported values are: |
| \begin{verbatim} |
| org.apache.uima.ducc.transport.event.common.history.HistoryPersistenceManager |
| org.apache.uima.ducc.database.HistoryManagerDb |
| \end{verbatim} |
| |
| The first value causes job history to be stored in {\tt DUCC\_HOME/history} |
| and the Orchestrator checkpoint to be stored in {\tt DUCC\_HOME/orchestrator.ckpt}. |
| |
| The second causes both history and checkpoint to be saved in the database. |
| |
| \begin{description} |
| \item[Default Value] If the database is enabled: |
| \begin{verbatim} |
| org.apache.uima.ducc.database.HistoryManagerDb |
| \end{verbatim} |
| If the database is not enabled: |
| \begin{verbatim} |
| org.apache.uima.ducc.transport.event.common.history.HistoryPersistenceManager |
| \end{verbatim} |
| \item[Type] Private |
| \end{description} |
| |
| |
| \item[ducc.rm.persistence.impl] \hfill \\ |
| This specifies the class used to implement persistence for the Resource Manager's |
| dynamic state. |
| The installation procedures for the database automatically update your {\em site.ducc.properties} |
| to use the correct default. |
| |
| The two supported values are: |
| \begin{verbatim} |
| org.apache.uima.ducc.database.RmStatePersistence |
| org.apache.uima.ducc.common.persistence.rm.NullRmStatePersistence |
| \end{verbatim} |
| |
| The first value implements RM's use of the database to store its dynamic state. The second |
| disables RM state persistence. There is no implementation that persists RM state |
| in the filesystem. |
| |
| \begin{description} |
| \item[Default Value] If the |
| database is enabled: |
| \begin{verbatim} |
| org.apache.uima.ducc.database.RmStatePersistence |
| \end{verbatim} |
| If the database is not enabled: |
| \begin{verbatim} |
| org.apache.uima.ducc.common.persistence.rm.NullRmStatePersistence |
| \end{verbatim} |
| \item[Type] Private |
| \end{description} |
| \end{description} |
| |
| \section{ducc.private.properties} |
| \label{sec:ducc.private.properties} |
| |
| \subsection{Web Server Properties} |
| |
| \begin{description} |
| |
| \item[ducc.ws.port.ssl.pw] \hfill \\ |
| This is the password used to generate the Web Server's keystore used for HTTPS requests. Usually |
| this keystore is created at initial installation time using \hyperref[subsec:admin.ducc-post-installl]{ducc\_post\_install.} |
| \begin{description} |
| \item[Default Value] Randomly generated at install time. |
| \item[Type] Local |
| \end{description} |
| \end{description} |
| |
| |
| \subsection{Database Properties} |
| |
| \begin{description} |
| |
| \item[db\_password] \hfill \\ |
| This is the database superuser password. It is set during {\em ducc\_post\_install} or {\em db\_create}. Both |
| these procedures randomly generate the password. |
| |
| NOTE: The database superuser ID is always ``ducc'', and is set during database installation. |
| \begin{description} |
| \item[Default Value] Randomly generated at install time. |
| \item[Type] Local |
| \end{description} |
| \end{description} |
| |
