all

#
# 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.
#

mode: deploy
lean: false
prompt_user: true
openwhisk_home: "{{ lookup('env', 'OPENWHISK_HOME') | default(playbook_dir ~ '/..', true) }}"
openwhisk_cli_home: "{{ lookup('env', 'OPENWHISK_CLI') | default(openwhisk_home ~ '/../openwhisk-cli', true) }}"
exclude_logs_from: []

# This whisk_api_localhost_name_default is used to configure nginx to permit vanity URLs for web actions
# for local deployment. For a public deployment, the specific environment group vars should define
# whisk_api_host_name; this is available to actions and hence must resolve from inside an action container
# specific to the deployment (i.e., it may be an IP address rather than a hostname in some cases).
# For a local deployment, use whisk_api_localhost_name. For a deployment which requires
# different name resolution between the whisk_api_host_name and the whisk_api_local_host_name, both should
# be defined so that the nginx configuration for the server name reflects the public facing naming (of the
# edge router) even if it is different from the API host available to the actions. The precedence order for
# configuring nginx and the SSL certificate generation is:
#   whisk_api_localhost_name (first)
#   whisk_api_host_name (second)
#   whisk_api_localhost_name_default (last)
whisk_api_localhost_name_default: "localhost"

# Type of your environment.
# If you want to deploy everything on your local machine use 'local'.
# If you use a docker-machine on a mac use 'docker-machine'
# If you want to deploy Openwhisk to other machines use 'distributed'
environmentInformation:
  type: "{{ environment_type | default('local') }}"

hosts_dir: "{{ inventory_dir | default(env_hosts_dir) }}"

whisk:
  version:
    date: "{{ansible_date_time.iso8601}}"
  feature_flags:
    require_api_key_annotation: "{{ require_api_key_annotation | default(true) | lower }}"
    require_response_payload: "{{ require_response_payload | default(true) | lower }}"
  cluster_name: "{{ whisk_cluster_name | default('whisk') }}"
  containerProxy:
    timeouts:
      idleContainer: "{{ containerProxy_timeouts_idleContainer | default('10 minutes') }}"
      pauseGrace: "{{ containerProxy_timeouts_pauseGrace | default('10 seconds') }}"
      keepingDuration: "{{ containerProxy_timeouts_keepingDuration | default('10 minutes') }}"

##
# configuration parameters related to support runtimes (see org.apache.openwhisk.core.entity.ExecManifest for schema of the manifest).
# briefly the parameters are:
#
#   runtimes_registry: optional registry (with trailing slash) where to pull docker images from for default runtimes (in manifest)
#   user_images_registry: optional registry (with trailing slash) where to pull docker images from for blackbox images
#
#   skip_pull_runtimes: this will skip pulling the images to the invoker (images must exist there somehow)
#
#   runtimes_manifest: set of language runtime families grouped by language (e.g., nodejs, python) and blackbox images to pre-pull
#
#   runtimes_bypass_pull_for_local_images: optional, if true, allow images with a prefix that matches
#       {{ runtimes_local_image_prefix }} to skip docker pull in invoker even if the image is not part of the blackbox set
#

manifestfile: "{{ manifest_file | default('/ansible/files/runtimes.json') }}"
runtimesManifest: "{{ runtimes_manifest | default(lookup('file', openwhisk_home ~ '{{ manifestfile }}') | from_json) }}"

limits:
  invocationsPerMinute: "{{ limit_invocations_per_minute | default(60) }}"
  concurrentInvocations: "{{ limit_invocations_concurrent | default(30) }}"
  firesPerMinute: "{{ limit_fires_per_minute | default(60) }}"
  sequenceMaxLength: "{{ limit_sequence_max_length | default(50) }}"

# Moved here to avoid recursions. Please do not use outside of controller-dict.
__controller_ssl_keyPrefix: "controller-"
__controller_blackbox_fraction: 0.10

# port means outer port
controller:
  dir:
    become: "{{ controller_dir_become | default(false) }}"
  confdir: "{{ config_root_dir }}/controller"
  basePort: 10001
  heap: "{{ controller_heap | default('2g') }}"
  arguments: "{{ controller_arguments | default('') }}"
  managedFraction: "{{ controller_managed_fraction | default(1.0 - (controller_blackbox_fraction | default(__controller_blackbox_fraction))) }}"
  blackboxFraction: "{{ controller_blackbox_fraction | default(__controller_blackbox_fraction) }}"
  timeoutFactor: "{{ controller_timeout_factor | default(2) }}"
  timeoutAddon: "{{ controller_timeout_addon | default('1 m') }}"
  instances: "{{ groups['controllers'] | length }}"
  akka:
    provider: cluster
    cluster:
      basePort: 8000
      host: "{{ groups['controllers'] | map('extract', hostvars, 'ansible_host') | list }}"
      bindPort: 2551
      # at this moment all controllers are seed nodes
      seedNodes: "{{ groups['controllers'] | map('extract', hostvars, 'ansible_host') | list }}"
  loadbalancer:
    spi: "{{ controller_loadbalancer_spi | default('') }}"
  authentication:
    spi: "{{ controller_authentication_spi | default('') }}"
  loglevel: "{{ controller_loglevel | default(whisk_loglevel) | default('INFO') }}"
  username: "{{ controller_username | default('controller.user') }}"
  password: "{{ controller_password | default('controller.pass') }}"
  entitlement:
    spi: "{{ controller_entitlement_spi | default('') }}"
  protocol: "{{ controller_protocol | default('https') }}"
  ssl:
    cn: openwhisk-controllers
    keyPrefix: "{{ __controller_ssl_keyPrefix }}"
    storeFlavor: PKCS12
    clientAuth: "{{ controller_client_auth | default('true') }}"
    cert: "{{ __controller_ssl_keyPrefix }}openwhisk-server-cert.pem"
    key: "{{ __controller_ssl_keyPrefix }}openwhisk-server-key.pem"
    keystore:
      password: "openwhisk"
      name: "{{ __controller_ssl_keyPrefix }}openwhisk-keystore.p12"
  extraEnv: "{{ controller_extraEnv | default({}) }}"
  deployment:
    ignore_error: "{{ controller_deployment_ignore_error | default('False') }}"
    retries: "{{ controller_deployment_retries | default(180) }}"
    delay: "{{ controller_deployment_delay | default(5) }}"

jmx:
  basePortController: 15000
  rmiBasePortController: 16000
  basePortInvoker: 17000
  rmiBasePortInvoker: 18000
  basePortScheduler: 21000
  rmiBasePortScheduler: 22000
  user: "{{ jmxuser | default('jmxuser') }}"
  pass: "{{ jmxuser | default('jmxpass') }}"
  jvmCommonArgs: "-Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.local.only=false -Dcom.sun.management.jmxremote.authenticate=true -Dcom.sun.management.jmxremote.password.file=/home/owuser/jmxremote.password -Dcom.sun.management.jmxremote.access.file=/home/owuser/jmxremote.access"
  enabled: "{{ jmxremote_enabled | default('true') }}"

transactions:
  header: "{{ transactions_header | default('X-Request-ID') }}"

registry:
  confdir: "{{ config_root_dir }}/registry"

kafka:
  topicsPrefix: "{{ kafka_topics_prefix | default('') }}"
  topicsUserEventPrefix: "{{ kafka_topics_userEvent_prefix | default(kafka_topics_prefix) | default('') }}"
  ssl:
    client_authentication: required
    keystore:
      name: kafka-keystore.jks
      password: openwhisk
    cipher_suites:
    - TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
    - TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
    - TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
    protocols:
    - TLSv1.2
  protocol: "{{ kafka_protocol_for_setup }}"
  version: "{{ kafka_version | default('2.13-2.7.0') }}"
  port: 9072
  advertisedPort: 9093
  ras:
    port: 8093
  heap: "{{ kafka_heap | default('1g') }}"
  replicationFactor: "{{ kafka_replicationFactor | default((groups['kafkas']|length)|int) }}"
  offsetsTopicReplicationFactor: "{{ kafka_offsetsTopicReplicationFactor | default(kafka_replicationFactor) | default((groups['kafkas']|length)|int) }}"
  # adapt this param for production deployments depending on the number of kafka consumers
  networkThreads: "{{ kafka_network_threads | default(3) }}"

kafka_connect_string: "{% set ret = [] %}\
                       {% for host in groups['kafkas'] %}\
                         {{ ret.append( hostvars[host].ansible_host + ':' + ((kafka.advertisedPort+loop.index-1)|string) ) }}\
                       {% endfor %}\
                       {{ ret | join(',') }}"

kafka_protocol_for_setup: "{{ kafka_protocol | default('PLAINTEXT') }}"

zookeeper:
  image:
    amd64: zookeeper:3.4
    arm64: arm64v8/zookeeper:3.4
  port: 2181

zookeeper_connect_string: "{% set ret = [] %}\
                           {% for host in groups['zookeepers'] %}\
                             {{ ret.append( hostvars[host].ansible_host + ':' + ((zookeeper.port+loop.index-1)|string) ) }}\
                           {% endfor %}\
                           {{ ret | join(',') }}"

invokerHostnameFromMap: "{{ groups['invokers'] | map('extract', hostvars, 'ansible_host') | list | first }}"
invokerHostname: "{{ invokerHostnameFromMap | default(inventory_hostname) }}"

# Moved here to avoid recursions. Please do not use outside of invoker-dict.
__invoker_ssl_keyPrefix: "invoker-"

invoker:
  dir:
    become: "{{ invoker_dir_become | default(false) }}"
  confdir: "{{ config_root_dir }}/invoker"
  port: 12001
  heap: "{{ invoker_heap | default('2g') }}"
  arguments: "{{ invoker_arguments | default('') }}"
  userMemory: "{{ invoker_user_memory | default('2048m') }}"
  userCpus: "{{ invoker_user_cpus | default() }}"
  # Specify if it is allowed to deploy more than 1 invoker on a single machine.
  allowMultipleInstances: "{{ invoker_allow_multiple_instances | default(false) }}"
  # Specify if it should use runc or docker to pause/unpause containers
  useRunc: "{{ invoker_use_runc | default(true) }}"
  docker:
    become: "{{ invoker_docker_become | default(false) }}"
    runcdir: "{{ invoker_runcdir | default('/run/docker/runtime-runc/moby') }}"
    volumes: "{{ invoker_docker_volumes | default([]) }}"
  loglevel: "{{ invoker_loglevel | default(whisk_loglevel) | default('INFO') }}"
  jmxremote:
    jvmArgs: "{% if inventory_hostname in groups['invokers'] %}
    {{ jmx.jvmCommonArgs }} -Djava.rmi.server.hostname={{ invokerHostname }} -Dcom.sun.management.jmxremote.rmi.port={{ jmx.rmiBasePortInvoker + groups['invokers'].index(inventory_hostname) }} -Dcom.sun.management.jmxremote.port={{ jmx.basePortInvoker + groups['invokers'].index(inventory_hostname) }}
    {% endif %}"
  extraEnv: "{{ invoker_extraEnv | default({}) }}"
  protocol: "{{ invoker_protocol | default('https') }}"
  username: "{{ invoker_username | default('invoker.user') }}"
  password: "{{ invoker_password | default('invoker.pass') }}"
  ssl:
    cn: "openwhisk-invokers"
    keyPrefix: "{{ __invoker_ssl_keyPrefix }}"
    storeFlavor: "PKCS12"
    clientAuth: "{{ invoker_client_auth | default('true') }}"
    cert: "{{ __invoker_ssl_keyPrefix }}openwhisk-server-cert.pem"
    key: "{{ __invoker_ssl_keyPrefix }}openwhisk-server-key.pem"
    keystore:
      password: "{{ invoker_keystore_password | default('openwhisk') }}"
      name: "{{ __invoker_ssl_keyPrefix }}openwhisk-keystore.p12"
  container:
    creationMaxPeek: "{{ container_creation_max_peek | default(500) }}"
  reactiveSpi: "{{ invokerReactive_spi | default('') }}"
  serverSpi: "{{ invokerServer_spi | default('') }}"
  deployment:
    ignore_error: "{{ invoker_deployment_ignore_error | default('False') }}"
    retries: "{{ invoker_deployment_retries | default(180) }}"
    delay: "{{ invoker_deployment_delay | default(5) }}"

userLogs:
  spi: "{{ userLogs_spi | default('org.apache.openwhisk.core.containerpool.logging.DockerToActivationLogStoreProvider') }}"

nginx:
  confdir: "{{ config_root_dir }}/nginx"
  htmldir: "{{ ui_path | default(false) }}"
  dir:
    become: "{{ nginx_dir_become | default(false) }}"
  version: "{{ nginx_version | default('1.21.1') }}"
  port:
    http: 80
    https: 443
  ssl:
    path: "{{ nginx_ssl_path | default(playbook_dir +'/roles/nginx/files') }}"
    cert: "{{ nginx_ssl_server_cert | default('openwhisk-server-cert.pem') }}"
    key: "{{ nginx_ssl_server_key | default('openwhisk-server-key.pem') }}"
    client_ca_cert: "{{ nginx_ssl_client_ca_cert | default('openwhisk-client-ca-cert.pem') }}"
    verify_client: "{{ nginx_ssl_verify_client | default('off') }}"
    password_file: "{{ nginx_ssl_password_file | default(false) }}"
  wpn:
    router: "{{ nginx_wpn_router | default('1') }}"
  special_users: "{{ nginx_special_users | default('[]') }}"

# These are the variables to define all database relevant settings.
# The authKeys are the users, that are initially created to use OpenWhisk.
# The keys are stored in ansible/files and will be inserted into the authentication database.
# The key db.whisk.actions is the name of the database where all artifacts of the user are stored. These artifacts are actions, triggers, rules and packages.
# The key db.whisk.activation is the name of the database where all activations are stored.
# The key db.whisk.auth is the name of the authentication database where all keys of all users are stored.
# The db_prefix is defined for each environment on its own. The CouchDb credentials are also defined for each environment on its own.
db:
  provider: "{{ db_provider | default(lookup('ini', 'db_provider section=db_creds file={{ playbook_dir }}/db_local.ini')) }}"
  protocol: "{{ db_protocol | default(lookup('ini', 'db_protocol section=db_creds file={{ playbook_dir }}/db_local.ini')) }}"
  port: "{{ db_port | default(lookup('ini', 'db_port section=db_creds file={{ playbook_dir }}/db_local.ini')) }}"
  host: "{{ db_host | default(lookup('ini', 'db_host section=db_creds file={{ playbook_dir }}/db_local.ini')) }}"
  persist_path: "{{ db_persist_path | default(false) }}"
  instances: "{{ groups['db'] | length }}"
  authkeys:
  - guest
  - whisk.system
  whisk:
    actions: "{{ db_prefix }}whisks"
    activations: "{{ db_prefix }}activations"
    auth: "{{ db_prefix }}subjects"
  credentials:
    admin:
      user: "{{ db_username | default(lookup('ini', 'db_username section=db_creds file={{ playbook_dir }}/db_local.ini')) }}"
      pass: "{{ db_password | default(lookup('ini', 'db_password section=db_creds file={{ playbook_dir }}/db_local.ini')) }}"
    controller:
      user: "{{ db_controller_user | default(lookup('ini', 'db_username section=controller file={{ playbook_dir }}/db_local.ini')) }}"
      pass: "{{ db_controller_pass | default(lookup('ini', 'db_password section=controller file={{ playbook_dir }}/db_local.ini')) }}"
    invoker:
      user: "{{ db_invoker_user | default(lookup('ini', 'db_username section=invoker file={{ playbook_dir }}/db_local.ini')) }}"
      pass: "{{ db_invoker_pass | default(lookup('ini', 'db_password section=invoker file={{ playbook_dir }}/db_local.ini')) }}"
    scheduler:
      user: "{{ db_scheduler_user | default(lookup('ini', 'db_username section=scheduler file={{ playbook_dir }}/db_local.ini')) }}"
      pass: "{{ db_scheduler_pass | default(lookup('ini', 'db_password section=scheduler file={{ playbook_dir }}/db_local.ini')) }}"
  artifact_store:
    backend: "{{ db_artifact_backend | default('CouchDB') }}"
  activation_store:
    backend: "{{ db_activation_backend | default('CouchDB') }}"
  elasticsearch:
    protocol: "{{ elastic_protocol | default('http') }}"
    port: "{{ elastic_port | default(9200) }}"
    index_pattern: "{{ elastic_index_pattern | default('openwhisk-%s') }}"
    base_transport_port: "{{ elastic_transport_port_base | default(9300) }}"
    confdir: "{{ config_root_dir }}/elasticsearch"
    dir:
      become: "{{ elastic_dir_become | default(false) }}"
    base_volume: "{{ elastic_base_volume | default('esdata') }}"
    cluster_name: "{{ elastic_cluster_name | default('openwhisk') }}"
    java_opts: "{{ elastic_java_opts | default('-Xms1g -Xmx1g') }}"
    loglevel: "{{ elastic_loglevel | default('INFO') }}"
    # the user id of elasticsearch process, default is 1000, if you have enabled user namespace
    # for docker daemon, this need to be changed correspondingly
    uid: "{{ elastic_uid | default(1000) }}"
    auth:
      admin:
        username: "{{ elastic_username | default('admin') }}"
        password: "{{ elastic_password | default('admin') }}"
  mongodb:
    connect_string: "{{ mongodb_connect_string | default('mongodb://172.17.0.1:27017') }}"
    database: "{{ mongodb_database | default('whisks') }}"
    data_volume: "{{ mongodb_data_volume | default('mongo-data') }}"

apigateway:
  port:
    api: 9000
    mgmt: 9001
  # Default to 'nightly', which tracks the head revision of the master branch of apigateway's gitrepo
  version: nightly

redis:
  version: 4.0
  port: 6379
  password: openwhisk

linux:
  version: 4.4.0-31

couchdb:
  version: 2.3

elasticsearch:
  version: 6.7.2

elasticsearch_connect_string: "{% set ret = [] %}\
                               {% for host in groups['elasticsearch'] %}\
                               {{ ret.append( hostvars[host].ansible_host + ':' + ((db.elasticsearch.port|int+loop.index-1)|string) ) }}\
                               {% endfor %}\
                               {{ ret | join(',') }}"
mongodb:
  version: 4.4.0

docker:
  # The user to install docker for. Defaults to the ansible user if not set. This will be the user who is able to run
  # docker commands on a machine setup with prereq_build.yml
  #user:
  image:
    prefix: "{{ docker_image_prefix | default('whisk') }}"
    tag: "{{ docker_image_tag | default('latest') }}"
  version: 1.12.0-0~trusty
  storagedriver: overlay
  port: 4243
  restart:
    policy: always
  pull:
    retries: 10
    delay: 10
  timezone: "{{ docker_timezone | default('UTC') }}"

cli:
  path: "{{ openwhisk_home }}/bin/wsk"

# The default name space is /whisk.system. The catalog namespace must begin with a slash "/".
catalog_namespace: "/whisk.system"

# The catalog_auth_key is used to determine the secret key to authenticate the openwhisk service.
# The value for this variable can be set to either the secret key itself or the file, which
# saves the secret key.
# By default, we take the key from ansible/files/auth.whisk.system.
catalog_auth_key: "{{ playbook_dir }}/files/auth.whisk.system"

# The catalog_repos is used to specify all the catalog names and repository URLs,
# so that openwhisk knows where to download the catalog and install them. The key
# specifies the catalog name and the url saves the URL of the repository. The location
# specifies the location to save the code of the catalog. The version specifies the hash
# of the commit to be cloned. If it is omit or set to HEAD, the latest commit will be
# selected. The repo_update specifies whether to retrieve new revisions from the origin
# repository and the default value is yes, meaning that it will retrieve the new
# revisions. The keys url and location are mandatory and the keys version and repo_update
# are optional. To add a new repository, please follow the template by adding:
#
# catalog_repos:
#   ...
#   <catalog-name>:
#     url: <URL of repository>, mandatory.
#     location: <local location to save the catalog>, mandatory.
#     version: <hash of the commit>, optional, default to HEAD.
#     repo_update: <whether to retrieve new revisions from the origin repository>,
#                  optional, default to no. Yes means to retrieve the new revisions, and
#                  no means not to retrieve the new revisions.
#
catalog_repos:
  openwhisk-catalog:
    url: https://github.com/apache/openwhisk-catalog.git
    # Set the local location as the same level as openwhisk home, but it can be changed.
    location: "{{ openwhisk_home }}/../openwhisk-catalog"
    version: "HEAD"
    repo_update: "no"

# The openwhisk_cli is used to determine how to install the OpenWhisk CLI. The
# installation_mode can be specified into two modes: remote and local.
# The mode remote means to download the available binaries from the releases page
# of the official openwhisk cli repository. The mode local means to build the binaries
# locally in a directory and get them from the local directory. The default value
# for openwhisk is local.
#
# The name specifies the package name of the binaries in remote mode.
#
# The dest_name specifies the package name of the binaries in Nginx in remote mode.
#
# The location specifies the official website where Openwhisk CLI is hosted in
# remote mode or location to save the binaries of the OpenWhisk CLI in local mode.

openwhisk_cli_tag: "{{ cli_tag | default(lookup('ini', 'git_tag section=openwhisk-cli file=' ~ openwhisk_home ~ '/ansible/files/package-versions.ini')) }}"
openwhisk_cli:
  installation_mode: "{{ cli_installation_mode | default(lookup('env', 'OPENWHISK_CLI_MODE')) | default('remote', true) }}"
  archive_name: OpenWhisk_CLI
  nginxdir:
    name: "{{ nginx.confdir }}/cli/go/download"
    become: "{{ cli_dir_become | default(false) }}"
  local:
    location: "{{ openwhisk_cli_home }}/build"
  remote:
    location: "https://github.com/apache/openwhisk-cli/releases/download/{{ openwhisk_cli_tag }}"

# Controls access to log directories
logs:
  dir:
    become: "{{ logs_dir_become | default(false) }}"

# Metrics Configuration
metrics:
  log:
    enabled: "{{ metrics_log | default(true) }}"
  kamon:
    enabled: "{{ metrics_kamon | default(false) }}"
    tags: "{{ metrics_kamon_tags | default(false) }}"
    host: "{{ metrics_kamon_statsd_host | default('') }}"
    port: "{{ metrics_kamon_statsd_port | default('8125') }}"

user_events: "{{ user_events_enabled | default(false) | lower }}"

zeroDowntimeDeployment:
  enabled: "{{ zerodowntime_deployment_switch | default(false) }}"

etcd:
  version: "{{ etcd_version | default('3.5') }}"
  client:
    port: 2379
  server:
    port: 2480
  cluster:
    token: "{{ etcd_cluster_token | default('openwhisk-etcd-token') }}"
  dir:
    data: "{{ etcd_data_dir | default('') }}"
  lease:
    timeout: "{{ etcd_lease_timeout | default(10) }}"
  loglevel: "{{ etcd_log_level | default('info') }}"
  quota_backend_bytes: "{{ etcd_quota_backend_bytes | default(2147483648) }}" # 2GB
  snapshot_count: "{{ etcd_snapshot_count | default(10000) }}"
  auto_compaction_retention: "{{ etcd_auto_compaction_retention | default('10m') }}"
  auto_compaction_mode: "{{ etcd_auto_compaction_mode | default('periodic') }}"
  pool_threads: "{{ etcd_pool_threads | default(10) }}"

etcd_connect_string: "{% set ret = [] %}\
                      {% for host in groups['etcd'] %}\
                        {{ ret.append( hostvars[host].ansible_host + ':' + ((etcd.client.port+loop.index-1)|string) ) }}\
                      {% endfor %}\
                      {{ ret | join(',') }}"


__scheduler_blackbox_fraction: 0.10

watcher:
    eventNotificationDelayMs: "{{ watcher_notification_delay | default('5000 ms')  }}"

durationChecker:
    spi: "{{ duration_checker_spi | default('') }}"
    timeWindow: "{{ duration_checker_time_window | default('1 d') }}"

enable_scheduler: "{{ scheduler_enable | default(true) }}"

scheduler:
  protocol: "{{ scheduler_protocol | default('http') }}"
  dir:
    become: "{{ scheduler_dir_become | default(false) }}"
  confdir: "{{ config_root_dir }}/scheduler"
  basePort: 14001
  grpc:
    basePort: 13001
    tls: "{{ scheduler_grpc_tls | default(false) }}"
  maxPeek: "{{ scheduler_max_peek | default(128) }}"
  heap: "{{ scheduler_heap | default('2g') }}"
  arguments: "{{ scheduler_arguments | default('') }}"
  instances: "{{ groups['schedulers'] | length }}"
  username: "{{ scheduler_username | default('scheduler.user') }}"
  password: "{{ scheduler_password | default('scheduler.pass') }}"
  akka:
    provider: cluster
    cluster:
      basePort: 25520
      host: "{{ groups['schedulers'] | map('extract', hostvars, 'ansible_host') | list }}"
      bindPort: 3551
      # at this moment all schedulers are seed nodes
      seedNodes: "{{ groups['schedulers'] | map('extract', hostvars, 'ansible_host') | list }}"
  loglevel: "{{ scheduler_loglevel | default(whisk_loglevel) | default('INFO') }}"
  extraEnv: "{{ scheduler_extraEnv | default({}) }}"
  dataManagementService:
    retryInterval: "{{ scheduler_dataManagementService_retryInterval | default('1 second') }}"
  inProgressJobRetention: "{{ scheduler_inProgressJobRetention | default('20 seconds') }}"
  blackboxMultiple: "{{ scheduler_blackboxMultiple | default(15) }}"
  managedFraction: "{{ scheduler_managed_fraction | default(1.0 - (scheduler_blackbox_fraction | default(__scheduler_blackbox_fraction))) }}"
  blackboxFraction: "{{ scheduler_blackbox_fraction | default(__scheduler_blackbox_fraction) }}"
  scheduling:
    staleThreshold: "{{ scheduler_scheduling_staleThreshold | default('100 milliseconds') }}"
    checkInterval: "{{ scheduler_scheduling_checkInterval | default('100 milliseconds') }}"
    dropInterval: "{{ scheduler_scheduling_dropInterval | default('10 seconds') }}"
  queueManager:
    maxSchedulingTime: "{{ scheduler_maxSchedulingTime | default('20 second') }}"
    maxRetriesToGetQueue: "{{ scheduler_maxRetriesToGetQueue | default(13) }}"
  queue:
    # the queue's state Running timeout, e.g. if have no activation comes into queue when Running, the queue state will be changed from Running to Idle and delete the decision algorithm actor
    idleGrace: "{{ scheduler_queue_idleGrace | default('10 minutes') }}"
    # the queue's state Idle timeout, e.g. if have no activation comes into queue when Idle, the queue state will be changed from Idle to Removed
    stopGrace: "{{ scheduler_queue_stopGrace | default('10 minutes') }}"
    # the queue's state Paused timeout, e.g. if have no activation comes into queue when Paused, the queue state will be changed from Paused to Removed
    flushGrace: "{{ scheduler_queue_flushGrace | default('60 seconds') }}"
    gracefulShutdownTimeout: "{{ scheduler_queue_gracefulShutdownTimeout | default('5 seconds') }}"
    maxRetentionSize: "{{ scheduler_queue_maxRetentionSize | default(10000) }}"
    maxRetentionMs: "{{ scheduler_queue_maxRetentionMs | default(60000) }}"
    maxBlackboxRetentionMs: "{{ scheduler_queue_maxBlackboxRetentionMs | default(300000) }}"
    throttlingFraction: "{{ scheduler_queue_throttlingFraction | default(0.9) }}"
    durationBufferSize: "{{ scheduler_queue_durationBufferSize | default(10) }}"
  deployment_ignore_error: "{{ scheduler_deployment_ignore_error | default('False') }}"
  dataManagementService:
    retryInterval: "{{ scheduler_dataManagementService_retryInterval | default('1 second') }}"