> ROLE: [1msquirro-ansible[0m (/Users/chiara/squirro/squirro-ansible/squirro-ansible)

ENTRY POINT: [1mmain[0m - The main entry point for the squirro-ansible role.

[1mOptions[0m (red indicates it is required):

   activity_tracking_cache_ttl  Sets the TTL for the activity tracking
                                cache. See `default_cache_ttl` for
                                details.
          default: 1d
          type: str

   activity_tracking_cache_type  Sets the cache type for the activity
                                 tracking cache. See
                                 `default_cache_type` for details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: '{{default_cache_type}}'
          type: str

   anyscale_key  If set SquirroGPT is configured to leverage this
                 Anyscale key (e.g. for Mistral).
          default: null
          type: str

   auth_cache_ttl  Sets the TTL for the authentication cache. See
                   `default_cache_ttl` for details.
          default: '{{default_cache_ttl}}'
          type: str

   auth_cache_type  Sets the cache type for the authentication cache.
                    See `default_cache_type` for details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: MemoryLRU
          type: str

   build_number  This is of relevance if this ansible role is used to
                 build images, e.g. via packer or in a CI/CD pipeline.
                 If set to "packer" or "docker", the behavior of the
                 role is changed to support these use cases, e.g.
                 services will not be started, log files will be
                 cleared etc. Do only use the default "normal" mode in
                 production as data loss can occur.
          default: normal
          type: str

   cerebras_key  If set SquirroGPT is configured to leverage this
                 Cerebras key.
          default: null
          type: str

   community_cache_ttl  Sets the TTL for the community cache. See
                        `default_cache_ttl` for details.
          default: 60m
          type: str

   community_cache_type  Sets the cache type for the community cache.
                         See `default_cache_type` for details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: '{{default_cache_type}}'
          type: str

   community_subscriptions_cache_ttl  Sets the TTL for the community
                                      subscriptions cache. See
                                      `default_cache_ttl` for details.
          default: 60m
          type: str

   community_subscriptions_cache_type  Sets the cache type for the
                                       community subscriptions cache.
                                       See `default_cache_type` for
                                       details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: '{{default_cache_type}}'
          type: str

   config_decrypt_command  Can be set to a command line utility that
                           will be called when the Squirro .ini files
                           encounter prefix. Azure requires
                           custom_pip_packages:
                           ['azure-keyvault-secrets',
                           'azure-identity'] to be set.
          choices: [null, /usr/bin/squirro_aws_ck_cmd2.sh, /usr/bin/squirro_aws_ck_cmd.sh, /usr/bin/squirro_azure_ck_cmd.sh]
          default: null
          type: str

   confluence_client_id  If set the confluence_client_id value in the
                         [dataloader] section of
                         /etc/squirro/common.ini is set.
          default: null
          type: str

   confluence_client_secret  If set the confluence_client_secret value
                             in the [dataloader] section of
                             /etc/squirro/common.ini is set.
          default: null
          type: str

   current_squirro_version  Which Squirro version is currently
                            installed. This is only relevant if
                            squirro_mode is set to upgrade or
                            reconfigure.
          default: null
          type: str

   custom_pip_index_url  If custom pip index-url for the squirro
                         virtualenv. This is only of relevance if
                         additional pip packages/wheel need to be
                         installed and the installation cannot reach
                         the internet / pypi.
          default: ''
          type: str

   custom_rpm_packages  Custom RPM packages to be installed.
          default: null
          type: list

   database_type  Set the sql database squirro is using. mysql is
                  default and recommended.
          choices: [mysql, postgres]
          default: mysql
          type: str

   default_cache_ttl  It specifies how long cache keys are re-used.
                      The default value is 5 minutes. The supported
                      suffixed are m -> minutes, h -> hours, d ->
                      days. This is only the default setting, and can
                      be overridden via other variables named
                      *_cache_ttl. While its tempting to set very high
                      cache times, we generally recommend lower values
                      to avoid stale data. The default value is a good
                      starting point.
          default: 5m
          type: str

   default_cache_type  Specify the default cache type for the various
                       caching groups. The recommended value in
                       production is always Redis. MemoryLRU can make
                       sense in local development environments. This
                       is only the default setting, and can be
                       overridden via other variables named
                       *_cache_type.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: MemoryLRU
          type: str

   disabled_squirro_services  List of Squirro services to disable. When a service is in this list,
                              it will be stopped, disabled, and its .ini configuration file will be
                              renamed to .ini.disabled. Supported services are: sqtrendsd,
                              sqrelatedstoryd, sqfingerprintd, sqmachinelearningd, sqdigestmailerd,
                              sqemailsenderd, sqcontentd. The role will fail if unsupported services
                              are specified.
          default: [sqtrendsd, sqrelatedstoryd, sqfingerprintd]
          type: list

   direct_attached_nvme_data_types  Specify the data types that should
                                    be stored on the additional NVMe
                                    device. Currently only
                                    elasticsearch is supported. If you
                                    want to use this feature, you also
                                    need to specify the
                                    `direct_attached_nvme_device` and
                                    `direct_attached_nvme_device_mount_point`.
                                    Further data types will be added
                                    in the future, e.g. plumber for
                                    various tmp folders. Note: Due to
                                    the ephemeral nature of the NVMe
                                    devices, it is not recommended to
                                    operate elasticsearch indices
                                    without replicas on this devices.
                                    frequent snapshots are
                                    recommended.
          choices: [elasticsearch]
          default: [elasticsearch]
          type: list

   direct_attached_nvme_device  Specify an additional NVMe device for
                                data storage. This is intended for
                                directly attached NVMe devices, e.g.
                                on AWS i3 instances, or regular
                                instances with the d suffix on AWS
                                (c5d, m5d, r5d). Typically these are
                                ephemeral devices, meaning that the
                                content is lost when the instance is
                                stopped, but these have the advantage
                                of being very fast. If you want to use
                                this feature, you also need to specify
                                the
                                `direct_attached_nvme_device_mount_point`3.4-lts
                                The device will be formatted with xfs
                                and mounted at the specified mount
                                point before any services start.
          default: null
          type: str

   direct_attached_nvme_device_mount_point  Specify the mount point
                                            for the additional NVMe
                                            device for data storage.
                                            This is intended for
                                            directly attached NVMe
                                            devices, e.g. on AWS i3
                                            instances, or regular
                                            instances with the d
                                            suffix on AWS (c5d, m5d,
                                            r5d). Typically these are
                                            ephemeral devices, meaning
                                            that the content is lost
                                            when the instance is
                                            stopped, but these have
                                            the advantage of being
                                            very fast. If you want to
                                            use this feature, you also
                                            need to specify the
                                            `direct_attached_nvme_device`
                                            The device will be
                                            formatted with xfs and
                                            mounted at the specified
                                            mount point before any
                                            services start.
          default: /mnt/nvme
          type: str

   dropbox_app_key  If set the dropbox_app_key value in the
                    [dataloader] section of /etc/squirro/common.ini is
                    set.
          default: null
          type: str

   dropbox_app_secret  If set the dropbox_app_secret value in the
                       [dataloader] section of /etc/squirro/common.ini
                       is set.
          default: null
          type: str

   dropbox_client_id  If set the dropbox_client_id value in the
                      [dataloader] section of /etc/squirro/common.ini
                      is set.
          default: null
          type: str

   dropbox_client_secret  If set the dropbox_client_secret value in
                          the [dataloader] section of
                          /etc/squirro/common.ini is set.
          default: null
          type: str

   elasticsearch_automatic_bootstrap  If set to True, the
                                      Elasticsearch cluster will not
                                      automatically bootstrap if
                                      relieant on initial master nodes
                                      settings. This is useful in
                                      scenarios where the cluster is
                                      not allowed to boostrap a new
                                      cluster without manual
                                      intervention.
          default: false
          type: bool

   elasticsearch_awareness_attributes  Comma seperated list of node
                                       attributes to use for shard
                                       allocation awareness. See
                                       elasticsearch_node_attributes
                                       for possible values
          default: null
          type: str

   elasticsearch_cluster_nodes  List of hostname or ip addresses of
                                all elasticsearch nodes. This is only
                                relevant if
                                `elasticsearch_discovery_type` is set
                                to `zen`.
          default: [127.0.0.1]
          type: list

   elasticsearch_concurrent_recoveries  Number of concurrent
                                        recoveries that Elasticsearch
                                        is allowed to perform.
          default: 10
          type: int

   elasticsearch_daily_snapshot_cron_day  CRON day string for daily
                                          snapshots. Only relevant if
                                          `elasticsearch_snapshot_repository_name`
                                          is set.
          default: '*'
          type: str

   elasticsearch_daily_snapshot_cron_hour  CRON hour string for daily
                                           snapshots. Only relevant if
                                           `elasticsearch_snapshot_repository_name`
                                           is set.
          default: 1-23
          type: str

   elasticsearch_daily_snapshot_cron_minute  CRON minute string for
                                             daily snapshots. Only
                                             relevant if
                                             `elasticsearch_snapshot_repository_name`
                                             is set.
          default: '0'
          type: str

   elasticsearch_daily_snapshot_cron_month  CRON weekday string for
                                            daily snapshots. Only
                                            relevant if
                                            `elasticsearch_snapshot_repository_name`
                                            is set.
          default: '*'
          type: str

   elasticsearch_daily_snapshot_cron_weekday  CRON month string for
                                              daily snapshots. Only
                                              relevant if
                                              `elasticsearch_snapshot_repository_name`
                                              is set.
          default: '*'
          type: str

   elasticsearch_daily_snapshots_to_keep  How many daily snapshots to
                                          keep in the snapshot
                                          repository. Only relevant if
                                          `elasticsearch_snapshot_repository_name`
                                          is set.
          default: 48
          type: int

   elasticsearch_data_dir  Location of the elasticsearch data folder.
                           Use this to place the elasticsearch indices
                           onto dedicated storage volumes. e.g. on AWS
                           you can use this to locate the data onto
                           the ephemeral but very fast NVMe drives if
                           you use a m5d, r5d or c5d instance type.
                           Note that you cannot change this after the
                           initial deployment. If you have multiple
                           volumes, you can gain extra performance by
                           letting elasticsearch span all of the
                           volumes, in this case use
                           `elasticsearch_data_dirs`3.4-lts
          default: /var/lib/elasticsearch
          type: str

   elasticsearch_data_dirs  Location of the elasticsearch data
                            folders. See `elasticsearch_data_dir` for
                            details. If both `elasticsearch_data_dir``
                            and `elasticsearch_data_dirs` is set, the
                            latter is used.
          default: ['{{ elasticsearch_data_dir }}']
          type: list

   elasticsearch_discovery_type  Set the elasticsearch discovery mode.
          choices: [single-node, zen, ec2]
          default: zen
          type: str

   elasticsearch_file_auth  Enable Elasticsearch file based
                            authentication. This is recommended in a
                            multi-node setup. If set to false, the
                            default Elasticsearch authentication is
                            used, which is not recommended, because
                            the default authentication is stored in
                            the cluster state, which can lead to
                            difficult bootstrapping issues when the
                            cluster state is lost/reset.
          default: false
          type: bool

   elasticsearch_file_auth_hashed_password  Elasticsearch file based
                                            password hash. This is
                                            only relevant if
                                            `elasticsearch_file_auth`
                                            is set to true. To create
                                            this hash, use the
                                            following command: `echo
                                            '<some_password>' |
                                            htpasswd -nbiB -C 10
                                            squirro | cut -c 9-` Some
                                            password needs to be the
                                            value set in
                                            `es_auth_password`,
                                            otherwise the squirro
                                            services will not be able
                                            to connect to
                                            Elasticsearch.
          default: null
          type: str

   elasticsearch_file_auth_user  Elasticsearch file based
                                 authentication username. This is only
                                 relevant if `elasticsearch_file_auth`
                                 is set to true. This value needs to
                                 be in sync with `es_auth_user`,
                                 otherwise the squirro services will
                                 not be able to connect to
                                 Elasticsearch. Note that value cannot
                                 be `elastic`, as this is a reserved
                                 user for the native authentication
                                 realm.
          default: squirro
          type: str

   elasticsearch_heap_size  Set the RAM that elasticsearch allocates
                            in gigabytes. If not set ansible will
                            detect the total RAM available and will
                            try to find a good setting. On a dedicated
                            machine you should use no more than 50% of
                            the available RAM, but not more than 32
                            gigabytes. On a machine with clusternode
                            and storagenode, giving 25% of RAM to
                            elasticsearch is a good starting point. In
                            general less is more. A machine starved
                            out of RAM will not perform well.
          default: null
          type: int

   elasticsearch_hourly_snapshot_cron  Cron schedule for the hourly
                                       Elasticsearch snapshot. This is
                                       only relevant if
                                       `elasticsearch_snapshot_repository_name`
                                       is set. The cronjob will be
                                       setup on all nodes, but will
                                       only go trough on the master
                                       node.
          default: null
          type: str

   elasticsearch_hourly_snapshot_cron_day  CRON day string for hourly
                                           snapshots. Only relevant if
                                           `elasticsearch_snapshot_repository_name`
                                           is set.
          default: '*'
          type: str

   elasticsearch_hourly_snapshot_cron_hour  CRON hour string for
                                            hourly snapshots. Only
                                            relevant if
                                            `elasticsearch_snapshot_repository_name`
                                            is set.
          default: 1-23
          type: str

   elasticsearch_hourly_snapshot_cron_minute  CRON minute string for
                                              hourly snapshots. Only
                                              relevant if
                                              `elasticsearch_snapshot_repository_name`
                                              is set.
          default: '0'
          type: str

   elasticsearch_hourly_snapshot_cron_month  CRON weekday string for
                                             hourly snapshots. Only
                                             relevant if
                                             `elasticsearch_snapshot_repository_name`
                                             is set.
          default: '*'
          type: str

   elasticsearch_hourly_snapshots_to_keep  How many hourly snapshots
                                           to keep in the snapshot
                                           repository. Only relevant
                                           if
                                           `elasticsearch_snapshot_repository_name`
                                           is set.
          default: 48
          type: int

   elasticsearch_http_p12_base64_string  Base64 encoded string of the
                                         http.p12 file. This is only
                                         relevant if
                                         `elasticsearch_security` is
                                         set to true. You can
                                         provision the file with other
                                         means, but this is the
                                         recommended way, as you can
                                         safely retrieve it from
                                         ansible vault or other secure
                                         storage. See the
                                         README_SSL.md for details on
                                         how to create the p12 files.
          default: null
          type: str

   elasticsearch_http_p12_password  Password for the http.p12 file.
                                    This is only relevant if
                                    `elasticsearch_security` is set to
                                    true.
          default: null
          type: str

   elasticsearch_http_p12_path  Path to the Elasticsearch http.p12
                                file. This is only relevant if
                                `elasticsearch_security` is set to
                                true. This is used by
                                `elasticsearch_http_p12_base64_string`
                                to provision the file, or needs to
                                correspond to the path where the file
                                is provisioned with other means. The
                                path is relative to the elasticsearch
                                config directory.
          default: certs/http.p12
          type: str

   elasticsearch_install_aws_plugins  Install the AWS elasticsearch
                                      plugins. Note that this is an
                                      experimental feature and will
                                      need additional work. For
                                      example this can currently fail
                                      upgrades and will not work in
                                      offline mode.
          default: false
          type: bool

   elasticsearch_install_azure_plugins  Install the azure
                                        elasticsearch plugins. Note
                                        that this is an experimental
                                        feature and will need
                                        additional work. For example
                                        this can currently fail
                                        upgrades and will not work in
                                        offline mode.
          default: false
          type: bool

   elasticsearch_install_google_plugins  Install the Google
                                         elasticsearch plugins. Note
                                         that this is an experimental
                                         feature and will need
                                         additional work. For example
                                         this can currently fail
                                         upgrades and will not work in
                                         offline mode.
          default: false
          type: bool

   elasticsearch_max_concurrent_files_chunks  Maximum number of
                                              concurrent file chunks
                                              that Elasticsearch is
                                              allowed to use for
                                              recoveries.
          default: 8
          type: int

   elasticsearch_max_mb_per_sec  Maximum throughput in MB/s that
                                 Elasticsearch is allowed to use for
                                 recoveries.
          default: 250
          type: int

   elasticsearch_memory_lock  Should Elasticsearch lock all memory to
                              prevent memory fragmentation. This
                              should always be set to True unless in
                              test / dev environment with extremely
                              low RAM. Setting this to FALSE will have
                              a severe performance impact.
          default: true
          type: bool

   elasticsearch_network_interface  Only use a given network
                                    interface, e.g. eth0 or eth1.
          default: null
          type: str

   elasticsearch_network_ip_protocol  Should elasticsearch listen to
                                      IPV4 or IPV6.
          choices: [ipv4, ipv6]
          default: ipv4
          type: str

   elasticsearch_node_attributes  List of node attributes to assign to
                                  the Elasticsearch nodes. This is
                                  only relevant if you have a
                                  multi-node setup and want to assign
                                  specific attributes to the nodes.
                                  This is used for shard allocation
                                  and other features. The dict must be
                                  populated with key value pairs
                                  consisting of only strings. e.g.
                                  {"rack": "rack1", "zone": "zone1"}
                                  The keys will be prefixed with
                                  `node.attr.` in the
                                  elasticsearch.yml file.
          default: {}
          type: dict

   elasticsearch_password  Elasticsearch bootstrapping password.
          default: null
          type: str

   elasticsearch_replica_count  Number of elasticsearch index shards
                                replicas. In multi-node deployments
                                set at least to 1 to ensure fault
                                tolerance.
          default: 9
          type: int

   elasticsearch_repo_paths  List of paths where the Elasticsearch
                             snapshot can be located. This is only
                             relevant if you use shared filesystem
                             snapshots. See
                             https://www.elastic.co/guide/en/elasticsearch/reference/current/snapshots-filesystem-repository.html
                             for details.
          default: []
          type: list

   elasticsearch_security  Enable Elasticsearch security features on
                           the node. If set to false, security
                           features are disabled, which is not
                           recommended in production.
          default: true
          type: bool

   elasticsearch_shards_number  Number of elasticsearch index shards
                                for new indices.
          default: 6
          type: int

   elasticsearch_snapshot_repository_name  Name of the Elasticsearch
                                           snapshot repository. Used
                                           to schedule snapshots. This
                                           role does not create the
                                           initial repository, but
                                           will use it if it exists.
          default: null
          type: str

   elasticsearch_squirro_cluster_name  Name of the elasticsearch
                                       cluster. Set a unique string if
                                       you intend to run a multi-node
                                       setup.
          default: squirro-cluster-{{ ansible_hostname | to_uuid }}
          type: str

   elasticsearch_threadpool_search_size  If set, the search threadpool
                                         is set to this size.
          default: null
          type: int

   elasticsearch_threadpool_search_worker_size  If set, the
                                                search_worker
                                                threadpool is set to
                                                this size.
          default: null
          type: int

   elasticsearch_transport_p12_base64_string  Base64 encoded string of
                                              the transport.p12 file.
                                              This is only relevant if
                                              `elasticsearch_security`
                                              is set to true. You can
                                              provision the file with
                                              other means, but this is
                                              the recommended way, as
                                              you can safely retrieve
                                              it from ansible vault or
                                              other secure storage.
                                              See the README_SSL.md
                                              for details on how to
                                              create the p12 files.
          default: null
          type: str

   elasticsearch_transport_p12_password  Password for the
                                         transport.p12 file. This is
                                         only relevant if
                                         `elasticsearch_security` is
                                         set to true.
          default: null
          type: str

   elasticsearch_transport_p12_path  Path to the Elasticsearch
                                     transport.p12 file. This is only
                                     relevant if
                                     `elasticsearch_security` is set
                                     to true. This is used by
                                     `elasticsearch_transport_p12_base64_string`
                                     to provision the file, or needs
                                     to correspond to the path where
                                     the file is provisioned with
                                     other means. The path is relative
                                     to the elasticsearch config
                                     directory.
          default: certs/transport.p12
          type: str

   enable_flags_for_project_ids  If set to true, the project_id flags
                                 are enabled in the Elasticsearch
                                 index. This is required for the
                                 project_id filter in the frontend.
          default: true
          type: bool

   es_auth_password  Elasticsearch authentication password. Used by
                     the squirro services to connect to Elasticsearch.
                     If this value is changed, the corresponding hash
                     In `elasticsearch_file_auth_hashed_password`
                     needs to be updated as well with a new hash if
                     file based authentication is enabled.
          default: null
          type: str

   es_auth_user  Elasticsearch authentication username. Used by the
                 squirro services to connect to Elasticsearch. This
                 value needs to be in sync with
                 `elasticsearch_file_auth_user`, if file based
                 authentication is enabled. Note that if
                 elasticsearch_file_auth is set to true, this value
                 cannot because `elastic`, as this is a reserved user
                 for the native authentication realm.
          default: elastic
          type: str

   es_auth_verify_certs  If set to false, the python elasticsearch
                         client will not verify the Elasticsearch
                         SSL/TLS certificate. This is only recommended
                         for testing not in production.
          default: true
          type: bool

   es_index_servers  List of Elasticsearch servers to use for index
                     operations.
          default: ['https://localhost:9200']
          type: list

   es_pem_path  Path to the Elasticsearch CA SSL/TLS certificate. This
                is only relevant if `es_auth_verify_certs` is set to
                true and if Elasticsearch is using a self-signed
                certificate. In this case, the certificate needs to be
                added to the CA trust store, e.g. by copying it to
                `/etc/pki/ca-trust/source/anchors/` and running
                `update-ca-trust`. Alternatively you can specify a
                custom CA pem file here.
          default: /etc/ssl/certs/ca-bundle.trust.crt
          type: str

   exchange_client_id  If set the exchange_client_id value in the
                       [dataloader] section of /etc/squirro/common.ini
                       is set.
          default: null
          type: str

   exchange_client_secret  If set the exchange_client_secret value in
                           the [dataloader] section of
                           /etc/squirro/common.ini is set.
          default: null
          type: str

   expiring_sessions  If set the expiring_sessions value in the
                      security.expiring_sessions section of
                      /etc/squirro/configuration.d/sessions.json is
                      set.
          default: null
          type: bool

   force_squirro_install  If set to true, the squirro_mode detection
                          results in install, no matter what the
                          detection is. Note that
                          force_squirro_install if also set to true
                          will overrule install. This setting is
                          useful if the install failed in a unexpected
                          way and a install has to be re-attempted.
          default: false
          type: bool

   force_squirro_upgrade  If set to true, the squirro_mode detect
                          results in upgrade, no matter what the
                          detection is. This setting is useful if the
                          upgrade failed in a unexpected way and a
                          upgrade has to be re-attempted.
          default: false
          type: bool

   frontend_flask_secret_key  If set the flask secret key for squirro
                              session is set to this value. Once set,
                              if this value is unset the previous
                              value remains in the frontend.ini file
          default: null
          type: str

   frontend_oauth2_middleman_url  If set the confluence_client_id
                                  value in the [dataloader] section of
                                  /etc/squirro/common.ini is set.
          default: null
          type: str

   gemini_key  If set SquirroGPT is configured to leverage this Gemini
               key.
          default: null
          type: str

   get_item_api_cache_ttl  Sets the TTL for the get item api. See
                           `default_cache_ttl` for details.
          default: '{{default_cache_ttl}}'
          type: str

   get_item_api_cache_type  Sets the cache type for the get item api
                            cache. See `default_cache_type` for
                            details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: 60m
          type: str

   gmail_client_id  If set the gmail_client_id value in the
                    [dataloader] section of /etc/squirro/common.ini is
                    set.
          default: null
          type: str

   gmail_client_secret  If set the gmail_client_secret value in the
                        [dataloader] section of
                        /etc/squirro/common.ini is set.
          default: null
          type: str

   googledrive_client_id  If set the googledrive_client_id value in
                          the [dataloader] section of
                          /etc/squirro/common.ini is set.
          default: null
          type: str

   googledrive_client_secret  If set the googledrive_client_secret
                              value in the [dataloader] section of
                              /etc/squirro/common.ini is set.
          default: null
          type: str

   ingester_processors  Number of processor processes spawned by the sqingesterd service.
                        Each processor is a separate Unix process that works on a single
                        batch file at a time. Processes consume batch files from
                        /var/lib/squirro/inputstream/. Increase this value for higher
                        ingestion throughput on multi-core systems.
          default: 1
          type: int

   ingester_processor_workers  Number of threads spawned by each processor process in the
                               sqingesterd service. Approximately this many items can be
                               processed concurrently per processor. Relevant for pipeline
                               steps that consume single items from batches.
          default: 3
          type: int

   jira_client_id  If set the jira_client_id value in the [dataloader] section of
                   /etc/squirro/common.ini is set.
          default: null
          type: str

   jira_client_secret  If set the jira_client_secret value in the
                       [dataloader] section of /etc/squirro/common.ini
                       is set.
          default: null
          type: str

   llama_key  If set SquirroGPT is configured to leverage this Llama
              3.1 key.
          default: null
          type: str

   local_queue_broker  Which broker to use for the local queue. redis
                       or memory. memory only recommended for local
                       dev environments.
          default: redis
          type: str

   memory_cache_max_items  Specify the maximum number of items that
                           can be stored in *_cache_type Memory and
                           MemoryLRU. This setting has no effect on
                           *_cache_type Redis. This setting affects
                           all cache types of type Memory and
                           MemoryLRU.
          default: 1000
          type: int

   metadata_cache_ttl  Sets the TTL for the authentication cache. See
                       `default_cache_ttl` for details.
          default: '{{default_cache_ttl}}'
          type: str

   metadata_cache_type  Sets the cache type for the metadata cache.
                        See `default_cache_type` for details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: MemoryLRU
          type: str

   mode      Is an installation or upgrade performed. This option is
             marked for deprecation.
          choices: [install, upgrade]
          default: install
          type: str

   monitoring_project_cache_ttl  Sets the TTL for the community
                                 subscriptions cache. See
                                 `default_cache_ttl` for details.
          default: 5m
          type: str

   monitoring_project_cache_type  Sets the cache type for the
                                  monitoring project cache. See
                                  `default_cache_type` for details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: '{{default_cache_type}}'
          type: str

   mysql_configuration_password  Password used for the configuration
                                 service sql connection.
          default: '{{ mysql_shared_service_password }}'
          type: str

   mysql_data_dir  Path where the local mysql data folder needs to be
                   placed. This only works if set before the MariaDB
                   server is installed.
          default: /var/lib/mysql
          type: str

   mysql_datasource_password  Password used for the datasource service
                              sql connection.
          default: '{{ mysql_shared_service_password }}'
          type: str

   mysql_emailsender_password  Password used for the emailsender
                               service sql connection.
          default: '{{ mysql_shared_service_password }}'
          type: str

   mysql_filtering_password  Password used for the filtering service
                             sql connection.
          default: '{{ mysql_shared_service_password }}'
          type: str

   mysql_fingerprint_password  Password used for the fingerprint
                               service sql connection.
          default: '{{ mysql_shared_service_password }}'
          type: str

   mysql_host  Hostname of the remote MySQL/MariaDB server. Example:
               `yourproject-db.abcdefghij.eu-central-1.rds.amazonaws.com`.
               Only relevant if `remote_mysql_server` is set to True
          default: null
          type: str

   mysql_machinelearning_password  Password used for the
                                   machinelearning service sql
                                   connection.
          default: '{{ mysql_shared_service_password }}'
          type: str

   mysql_notes_password  Password used for the notes service sql
                         connection.
          default: '{{ mysql_shared_service_password }}'
          type: str

   mysql_plumber_password  Password used for the plumber service sql
                           connection.
          default: '{{ mysql_shared_service_password }}'
          type: str

   mysql_port  TCP port of the remote MySQL/MariaDB server. Only
               relevant if `remote_mysql_server` is set to True
          default: 3306
          type: int

   mysql_root_password  Password of the remote MySQL/MariaDB server
                        root user. Only relevant if
                        `remote_mysql_server` is set to True.
          default: null
          type: str

   mysql_root_user  Username of the remote MySQL/MariaDB server root
                    user. Only relevant if `remote_mysql_server` is
                    set to True.
          default: null
          type: str

   mysql_scheduler_password  Password used for the scheduler service
                             sql connection.
          default: '{{ mysql_shared_service_password }}'
          type: str

   mysql_shared_service_password  Default password to use for the
                                  various squirro services. Note that
                                  options exist to have a unique
                                  password for each services.
          default: squirro/4u
          type: str

   mysql_shared_service_user_hostname  Username hostname string. This
                                       is required for some
                                       MySQL/MariaDB deployment, e.g.
                                       on Microsoft Azure. See the
                                       Azure example playbook as well.
          default: null
          type: str

   mysql_ssl  Use SSL for the MySQL/MariaDB connection.
          default: false
          type: bool

   mysql_ssl_ca_certs  Path to the ca certificate file used for the
                       MySQL/MariaDB connections.
          default: <python site-packages path>/certifi/cacert.pem
          type: str

   mysql_topic_password  Password used for the topic service sql
                         connection.
          default: '{{ mysql_shared_service_password }}'
          type: str

   mysql_trends_password  Password used for the trends service sql
                          connection.
          default: '{{ mysql_shared_service_password }}'
          type: str

   mysql_user_password  Password used for the user service sql
                        connection.
          default: '{{ mysql_shared_service_password }}'
          type: str

   nginx_primary_http_port  If set, the primary nginx http port tcp 80
                            will be changed to this port
          default: null
          type: int

   nlp_remote_services  If set the nlp_remote_services value in the
                        topic.nlp.remote-services-connection section
                        of
                        /etc/squirro/configuration.d/nlp_remote_services.json
                        is set.
          default: null
          type: list

   onedrive_client_id  If set the onedrive_client_id value in the
                       [dataloader] section of /etc/squirro/common.ini
                       is set.
          default: null
          type: str

   onedrive_client_secret  If set the onedrive_client_secret value in
                           the [dataloader] section of
                           /etc/squirro/common.ini is set.
          default: null
          type: str

   openai_key  If set SquirroGPT is configured to leverage this OpenAI
               key (for ChatGPT).
          default: null
          type: str

   provider_gunicorn_threads  Number of threads per worker process in the sqproviderd service
                              when using Gunicorn as the web server. Each worker can handle
                              this many concurrent requests using threading. Higher values
                              can improve throughput for I/O-bound operations.
          default: 1
          type: int

   provider_gunicorn_workers  Number of worker processes spawned by the sqproviderd service
                              when using Gunicorn as the web server. Each worker is a
                              separate Unix process that can handle requests independently.
                              Start with 2 workers and adjust based on system performance.
          default: 2
          type: int

   postgres_configuration_password  Password used for the configuration service sql connection.

          default: '{{ postgres_shared_service_password }}'
          type: str

   postgres_datasource_password  Password used for the datasource
                                 service sql connection.
          default: '{{ postgres_shared_service_password }}'
          type: str

   postgres_emailsender_password  Password used for the emailsender
                                  service sql connection.
          default: '{{ postgres_shared_service_password }}'
          type: str

   postgres_filtering_password  Password used for the filtering
                                service sql connection.
          default: '{{ postgres_shared_service_password }}'
          type: str

   postgres_fingerprint_password  Password used for the fingerprint
                                  service sql connection.
          default: '{{ postgres_shared_service_password }}'
          type: str

   postgres_host  Hostname of the remote PostgreSQL server. Example:
                  `yourproject-db.abcdefghij.eu-central-1.rds.amazonaws.com`.
                  Only relevant if `remote_postgres_server` is set to
                  True
          default: null
          type: str

   postgres_machinelearning_password  Password used for the
                                      machinelearning service sql
                                      connection.
          default: '{{ postgres_shared_service_password }}'
          type: str

   postgres_notes_password  Password used for the notes service sql
                            connection.
          default: '{{ postgres_shared_service_password }}'
          type: str

   postgres_plumber_password  Password used for the plumber service
                              sql connection.
          default: '{{ postgres_shared_service_password }}'
          type: str

   postgres_port  TCP port of the remote PostgreSQL server. Only
                  relevant if `remote_postgres_server` is set to True
          default: 5432
          type: int

   postgres_scheduler_password  Password used for the scheduler
                                service sql connection.
          default: '{{ postgres_shared_service_password }}'
          type: str

   postgres_shared_service_password  Default password to use for the
                                     various squirro services. Note
                                     that options exist to have a
                                     unique password for each
                                     services.
          default: squirro/4u
          type: str

   postgres_ssl  Use SSL for the Postgres connection.
          default: false
          type: bool

   postgres_ssl_ca_certs  Path to the ca certificate file used for the
                          Postgres connections.
          default: <python site-packages path>/certifi/cacert.pem
          type: str

   postgres_topic_password  Password used for the topic service sql
                            connection.
          default: '{{ postgres_shared_service_password }}'
          type: str

   postgres_trends_password  Password used for the trends service sql
                             connection.
          default: '{{ postgres_shared_service_password }}'
          type: str

   postgres_user_password  Password used for the user service sql
                           connection.
          default: '{{ postgres_shared_service_password }}'
          type: str

   pre_create_users  If set to `True`, service users and groups with
                     fixed UIDs and GIDs are created before Squirro is
                     installed. This prevents file ownership issues
                     when a cluster of Squirro instances is deployed
                     and they all need to read data from a single NFS
                     drive. The fixed User/Group ID's are currently
                     hardcoded to the following values: redis
                     | UID: 3001 | Group: redis zkeeper         | UID:
                     3002 | Group: zkeeper tika            | UID: 3003
                     | Group: tika sqprovid        | UID: 4001 |
                     Group: squirro sqtopic         | UID: 4002 |
                     Group: squirro squser          | UID: 4003 |
                     Group: squirro sqclustr        | UID: 4004 |
                     Group: squirro sqconfig        | UID: 4005 |
                     Group: squirro sqcontnt        | UID: 4006 |
                     Group: squirro sqdatasource    | UID: 4007 |
                     Group: squirro sqmailer        | UID: 4008 |
                     Group: squirro sqemails        | UID: 4009 |
                     Group: squirro sqfilter        | UID: 4010 |
                     Group: squirro sqfinger        | UID: 4011 |
                     Group: squirro sqingest        | UID: 4012 |
                     Group: squirro sqpdfcon        | UID: 4013 |
                     Group: squirro sqplumbr        | UID: 4014 |
                     Group: squirro sqrstory        | UID: 4015 |
                     Group: squirro sqsched         | UID: 4016 |
                     Group: squirro sqthumb         | UID: 4017 |
                     Group: squirro sqtproxy        | UID: 4018 |
                     Group: squirro sqtrends        | UID: 4019 |
                     Group: squirro squproxy        | UID: 4020 |
                     Group: squirro sqwebsht        | UID: 4021 |
                     Group: squirro sqfront         | UID: 4022 |
                     Group: squirro sqnotes         | UID: 4023 |
                     Group: squirro sqsearch        | UID: 4025 |
                     Group: squirro sqnlp           | UID: 4026 |
                     Group: squirro sqindexmanager  | UID: 4027 |
                     Group: squirro scrapyd         | UID: 4028 |
                     Group: squirro sqgenai         | UID: 4029 |
                     Group: squirro
          default: false
          type: bool

   project_index_stats_cache_ttl  Sets the TTL for the community
                                  subscriptions cache. See
                                  `default_cache_ttl` for details.
          default: 60m
          type: str

   project_index_stats_cache_type  Sets the cache type for the project
                                   index stats cache. See
                                   `default_cache_type` for details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: '{{default_cache_type}}'
          type: str

   pymupdf_pro_license_key  If set, the PyMuPDF Pro license key is set
                            to this value. A PyMuPDF Pro license enables
                            chatting with additional file types in the
                            genai service.
          default: null
          type: str

   python_ssl_ca_bundle  If squirro or any python code in the
                         virtualenv needs to communicate via untrusted
                         ssl sources You can set this variable and
                         point it a bundle of root and chain
                         certificates. This leverages the
                         update-ca-trust command of the underlying os.
                         If you have already integrated the custom ca
                         cert into /etc/pki/ca-trust/source/anchors/
                         and called update-ca-trust, then simply set
                         this variable to
                         /etc/pki/ca-trust/extracted/openssl/ca-bundle.trust.crt.
                         Otherwise just point it at your custom ca pem
                         file and squirro-ansible will take care of
                         the rest.Python will then trust certificates
                         issues by these authorities. Best practice is
                         to place the .pem file into
                         /etc/pki/ca-trust/source/anchors/, e.g
                         /etc/pki/ca-trust/source/anchors/squirro.pem
                         and  then call `update-ca-trust`. This way
                         both python and the OS (e.g. via curl) will
                         trust the custom certificates. The pem file
                         must be world readable.
          default: null
          type: str

   qfss_enabled  If set to `True`, the `stream_type` configuration in
                 /etc/squirro/common.ini will be set to
                 `filesystem-queue`. If set to `False`, it will be set
                 to `filesystem`. If the variable is not defined (the
                 default), no change occurs.
          default: null
          type: bool

   query_embedding_cache_ttl  Sets the TTL for the query embedding
                              cache. See `default_cache_ttl` for
                              details.
          default: 60m
          type: str

   query_embedding_cache_type  Sets the cache type for the query
                               embedding cache. See
                               `default_cache_type` for details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: '{{default_cache_type}}'
          type: str

   query_strategy_cache_ttl  Sets the TTL for the query_strategy
                             cache. See `default_cache_ttl` for
                             details.
          default: '{{default_cache_ttl}}'
          type: str

   query_strategy_cache_type  Sets the cache type for the
                              query_strategy cache. See
                              `default_cache_type` for details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: '{{default_cache_type}}'
          type: str

   redis_cache_host  Hostname of the remote Redis server for caching.
                     Example:
                     `master.storage-abcdefgh.euc1.cache.amazonaws.com`.
                     Only relevant if `remote_redis_server` is set to
                     True.
          default: null
          type: str

   redis_cache_password  Password of the remote Redis server for
                         caching. Only relevant if
                         `remote_redis_server` is set to True.
          default: null
          type: str

   redis_cache_port  TCP port of the remote Redis server for caching.
                     Only relevant if `remote_redis_server` is set to
                     True.
          default: null
          type: int

   redis_data_dir  Path where the local redis data folder needs to be
                   placed. This only works if set before the Redis
                   servers are installed.
          default: /var/lib/redis
          type: str

   redis_ssl  Use SSL/TLS for the Redis connections
          default: false
          type: bool

   redis_ssl_ca_certs  Path to the ca certificate file used for the
                       Redis connections.
          default: <python site-packages path>/certifi/cacert.pem
          type: str

   redis_ssl_verify  Set to false if the Redis server SSL/TLS
                     certificate is self signed and/or otherwise
                     untrusted or invalid.
          default: true
          type: bool

   redis_storage_host  Hostname of the remote Redis server for
                       persistent storage. Example:
                       `master.storage-abcdefgh.euc1.cache.amazonaws.com`.
                       Only relevant if `remote_redis_server` is set
                       to true.
          default: null
          type: str

   redis_storage_password  Password of the remote Redis server for
                           persistent storage. Only relevant if
                           `remote_redis_server` is set to True.
          default: null
          type: str

   redis_storage_port  TCP port of the remote Redis server for
                       persistent storage. Only relevant if
                       `remote_redis_server` is set to true.
          default: null
          type: int

   remote_filesystem  Set to true if the various Squirro assets must
                      be placed on a remote/shared filesystem.
                      Examples are NFS, EFS, SMB. This must be set
                      before the first run, and cannot be changed
                      later.
          default: false
          type: bool

   remote_filesystem_path  Path to the already mounted remote
                           filesystem. Only relevant if
                           `remote_filesystem` is set to true. This
                           must be set before the first run, and
                           cannot be changed later. Example:
                           `/mnt/efs/squirro`
          default: null
          type: str

   remote_mysql_server  Set to True if you want to leverage a remote
                        MySQL/MariaDB server. e.g. via AWS RDS.
          default: false
          type: bool

   remote_postgres_server  Set to True if you want to leverage a
                           remote PostgreSQL server. e.g. via AWS RDS.
          default: false
          type: bool

   remote_redis_server  Set to true if you want to leverage remote
                        Redis servers. e.g. via AWS ElastiCache or
                        Redis lib_squirro_storage.stat.isdir
          default: false
          type: bool

   remove_squirro_service_group  Same logic as
                                 remove_squirro_service_users, but
                                 deletes the squirro group after the
                                 installation.
          default: false
          type: bool

   remove_squirro_service_users  If set and the squirro_service_user
                                 is not "default", all squirro sq*
                                 linux users are deleted after the
                                 installation. This make only sense in
                                 a setup where squirro is never
                                 upgraded, but new instances/container
                                 are created for upgrades. This will
                                 fail upgrade runs, unless the rpm
                                 package squirro-cluster-node-users is
                                 re-installed beforehand.
          default: false
          type: bool

   rerun_from_index_queue_broker  Which broker to use for the rerun
                                  from index queue. redis or memory.
                                  memory only recommended for local
                                  dev environments.
          default: redis
          type: str

   rerun_from_index_queue_redis_visibility_timeout_secs  How long
                                                         messages
                                                         visible in
                                                         the rerun
                                                         from index
                                                         queue. Only
                                                         relevant if
                                                         rerun_from_index_queue_broker
                                                         is set to
                                                         redis.
          default: 3600
          type: int

   run_query_api_cache_ttl  Sets the TTL for the run query api cache.
                            See `default_cache_ttl` for details.
          default: '{{default_cache_ttl}}'
          type: str

   run_query_api_cache_type  Sets the cache type for the run query api
                             cache. See `default_cache_type` for
                             details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: '{{default_cache_type}}'
          type: str

   salescloud_client_id  If set the salescloud_client_id value in the
                         [dataloader] section of
                         /etc/squirro/common.ini is set.
          default: null
          type: str

   salescloud_client_secret  If set the salescloud_client_secret value
                             in the [dataloader] section of
                             /etc/squirro/common.ini is set.
          default: null
          type: str

   scoring_profile_cache_ttl  Sets the TTL for the scoring profile
                              cache. See `default_cache_ttl` for
                              details.
          default: 60m
          type: str

   scoring_profile_cache_type  Sets the cache type for the scoring
                               profile cache. See `default_cache_type`
                               for details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: '{{default_cache_type}}'
          type: str

   service_endpoint_baseurl  Can be set to a different service
                             endpoint protocol, hostname and port.
                             This is only of relevance if a custom
                             nginx server needs to be used.
          default: http://localhost:81
          type: str

   servicecloud_client_id  If set the servicecloud_client_id value in
                           the [dataloader] section of
                           /etc/squirro/common.ini is set.
          default: null
          type: str

   servicecloud_client_secret  If set the servicecloud_client_secret
                               value in the [dataloader] section of
                               /etc/squirro/common.ini is set.
          default: null
          type: str

   session_permanent  If set the session_permanent value in the
                      [frontend] section of /etc/squirro/frontend.ini
                      is set.
          default: null
          type: bool

   sharepoint_client_id  If set the sharepoint_client_id value in the
                         [dataloader] section of
                         /etc/squirro/common.ini is set.
          default: null
          type: str

   sharepoint_client_secret  If set the sharepoint_client_secret value
                             in the [dataloader] section of
                             /etc/squirro/common.ini is set.
          default: null
          type: str

   squirro_channel  Which Squirro release channel from the mirror to
                    use for the installation. Only applies when
                    squirro_install_mode is set to online.
          choices: [stable, testing, unstable, unstable-dev, unstable-packaging]
          default: stable
          type: str

   squirro_clusternode  If set to `True` the squirro-clusternode
                        package is installed
          default: false
          type: bool

   squirro_genainode  If set to `True` the SquirroGPT/genai service is
                      installed
          default: false
          type: bool

   squirro_install_mode  Where is ansible taking the packages from.
                         online: Packages are retrieved from
                         mirror.squirro.net. offline: Package is
                         installed from a tar.gz file that can be
                         downloaded from https://mirror.squirro.net.
                         filesystem: Same as offline, but the tar.gz
                         file is already extracted. custom_url: If you
                         have a custom http(s) url that is not
                         mirror.squirro.net for example via
                         artifactory, you can use this option.
          choices: [online, offline, filesystem, custom_url]
          default: online
          type: str

   squirro_packages_tar  Location of a installation tar.gz file
                         downloaded from https://mirror.squirro.net.
                         Only relevant if `squirro_install_mode` is
                         set to `offline`
          default: null
          type: str

   squirro_service_group  This parameter is related to
                          'squirro_service_user'. See there for
                          further details, all squirro related files
                          will get this gid, when squirro_service_user
                          is set to a custom value.
          default: null
          type: str

   squirro_service_user  Set the linux uid that is used to run all the
                         squirro python services. If not set
                         (default), then each service is run with it
                         own dedicated user (sqfront, sqtopic, etc) as
                         provided by the squirro packages, if set any
                         other value, all services run with this
                         specific user. The user and its group (see
                         squirro_service_group) needs to pre- exist.
                         This action cannot be reverted, as
                         information about detailed file ownership is
                         lost in the process. This is only recommended
                         in scenarios where updates are not run in
                         place, but the instances or containers are
                         discarded frequently (Cloud Instances,
                         Docker, K8S, etc.)
          default: null
          type: str

   squirro_storagenode  If set to `True` the squirro-storagenode
                        package is installed
          default: false
          type: bool

   squirro_version  Which Squirro version to install. Next to specific
                    version numbers you can also use the strings
                    `latest` (for the latest bi-weekly release) or
                    `x.y-lts` (e.g., `3.4-lts` for the latest LTS
                    release in the 3.4 series).
          default: latest
          type: str

   template_query_cache_ttl  Sets the TTL for the template query
                             cache. See `default_cache_ttl` for
                             details.
          default: '{{default_cache_ttl}}'
          type: str

   template_query_cache_type  Sets the cache type for the
                              authentication cache. See
                              `default_cache_type` for details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: '{{default_cache_type}}'
          type: str

   tmp_cleanup  Sets up a systemd service and timer to clean up
                temporary files and directories created by the Squirro
                services.
          default: true
          type: bool

   user_data_cache_ttl  Sets the TTL for the user cache. See
                        `default_cache_ttl` for details.
          default: '{{default_cache_ttl}}'
          type: str

   user_data_cache_type  Sets the cache type for the authentication
                         cache. See `default_cache_type` for details.
          choices: [Redis, MemoryLRU, Memory, Noop]
          default: '{{default_cache_type}}'
          type: str

   yum_password  Password for https://mirror.squirro.net. Only
                 relevant if `squirro_install_mode` is set to
                 `offline`. Reach out to support@squirro.com if you
                 don't have this information.
          default: null
          type: str

   yum_repo_folder  Path to the extracted contents of the offline
                    installer tar.tz file downloaded from
                    mirror.squirro.net Only relevant if
                    `squirro_install_mode` is set to `filesystem`.
          default: null
          type: str

   yum_user  Username for https://mirror.squirro.net. Only relevant if
             `squirro_install_mode` is set to `offline`. Reach out to
             support@squirro.com if you don't have this information.
          default: null
          type: str
