main.yml

---
# defaults file for galaxyproject.galaxy

#
# Feature control
#

# Control which tasks are included, in case you need to perform different options on different hosts or server
# directories.
galaxy_create_user: no
galaxy_manage_paths: no
galaxy_manage_clone: yes
galaxy_manage_download: no
galaxy_manage_existing: no
galaxy_manage_static_setup: yes
galaxy_manage_mutable_setup: yes
galaxy_manage_database: yes
galaxy_fetch_dependencies: yes
galaxy_build_client: yes
galaxy_manage_errordocs: no
galaxy_backup_configfiles: yes
galaxy_manage_gravity: "{{ false if __galaxy_major_version is version('22.05', '<') else true }}"
galaxy_manage_systemd: no # For Galaxy
galaxy_manage_systemd_reports: no # For Reports
galaxy_manage_cleanup: no
galaxy_manage_themes: "{{ galaxy_manage_static_setup and (galaxy_themes is defined or galaxy_themes_subdomains) }}"
galaxy_manage_subdomain_static: no
galaxy_manage_host_filters: no
galaxy_auto_brand: no # automatically sets the subdomain name as brand


# Control whether to output verbose task diffs (e.g. when performing a git update) when running Ansible with --diff.
# Only suppresses diff on tasks that are likely to be verbose, not all tasks
galaxy_diff_mode_verbose: "{{ ansible_diff_mode }}"

#
# Access method control
#

# The role needs to perform tasks as different users depending on your configuration and how you are connecting to the
# target host. Keys are the privileges needed and the values are the user to connect as or become:
#
#   root: Tasks that require "root" privileges such as creating/chowning directories inside directories owned by root
#   galaxy: Tasks that run as the Galaxy user
#   privsep: Tasks that run as the privilege separation user
#   errdocs: Tasks that install error docs (run as whatever user owns these)
#
# You would most commonly connect to the target host either as root or as a user with full sudo privileges, but if not
# using privilege separation, it is possible to run this role as an unprivileged user with no escalation. In such a
# case, set `galaxy_become_users` to an empty hash like so:
#
#galaxy_become_users: {}

# Attempt to automatically decide whether to use `become` and which users to `become`. To disable, set
# `galaxy_become_users` to an empty hash.
__galaxy_privsep_user: "{{ galaxy_privsep_user if galaxy_separate_privileges else galaxy_user }}"
# this goes through two levels of variables since there's no "else if"
__galaxy_default_root_become_users:
  galaxy: "{{ __galaxy_user_name }}"
  privsep: "{{ __galaxy_privsep_user_name }}"
__galaxy_default_nonroot_become_users:
  root: root
  galaxy: "{{ __galaxy_user_name }}"
  privsep: "{{ __galaxy_privsep_user_name }}"
__galaxy_default_become_users: "{{ __galaxy_default_root_become_users if ansible_user_uid == 0 else __galaxy_default_nonroot_become_users }}"
galaxy_become_users: "{{ {} if ansible_user_id == __galaxy_user_name and not galaxy_separate_privileges else __galaxy_default_become_users }}"

# Some sites do not allow the use of passwordless `sudo` and require logging directly in to accounts using `ssh`, this
# variable works like `galaxy_become_users` and accommodates such scenarios (if using you probably want to set
# `galaxy_become_users` to an empty hash)
galaxy_remote_users: {}

#
# Privilege separation, user and path management
#

# Privilege separation mode switch
galaxy_separate_privileges: no

# User that Galaxy runs as
galaxy_user: "{{ ansible_user_id }}"

# User that owns Galaxy code, configs, and virutalenv, and that runs `pip install` for dependencies
galaxy_privsep_user: root

# No explicit group is created by default, system policy will decide users' groups. However, in order to enable
# privilege separation without making configs world-readable, the users should share a common group. This group will be
# created if `galaxy_create_user` is enabled and it does not exist. Ideally this is the primary group of `galaxy_user`,
# on most Linux systems, just set this to the same value as `galaxy_user` if you want to enable this feature.
#galaxy_group:

# Because these vars can be either a bare username or a dict
__galaxy_user_name: "{{ galaxy_user.name | default(galaxy_user) }}"
__galaxy_privsep_user_name: "{{ galaxy_privsep_user.name | default(galaxy_privsep_user) }}"

# If `galaxy_create_user` is enabled, the privsep user will also be created, but you can override this behavior
galaxy_create_privsep_user: "{{ galaxy_create_user if __galaxy_privsep_user_name != 'root' else false }}"

# Where to write Galaxy logs to
galaxy_log_dir: "{{ galaxy_mutable_data_dir }}/log"

# Directories to create as the Galaxy user if galaxy_manage_paths is enabled
galaxy_dirs:
  - "{{ galaxy_mutable_data_dir }}"
  - "{{ galaxy_mutable_config_dir }}"
  - "{{ galaxy_cache_dir }}"
  - "{{ galaxy_shed_tools_dir }}"
  - "{{ galaxy_tool_dependency_dir }}"
  - "{{ galaxy_file_path }}"
  - "{{ galaxy_job_working_directory }}"
  - "{{ galaxy_tool_data_path }}"
  - "{{ galaxy_log_dir }}"

# Additional directories to create as the Galaxy user, so you don't have to copy the default galaxy_dirs
galaxy_extra_dirs: []

# Directories to create as the privilege separated user if galaxy_manage_paths is enabled
galaxy_privsep_dirs:
  - "{{ galaxy_venv_dir }}"
  - "{{ galaxy_server_dir }}"
  - "{{ galaxy_config_dir }}"
  - "{{ galaxy_local_tools_dir }}"

# Additional directories to create as the privilege separated user, so you don't have to copy the default galaxy_dirs
galaxy_extra_privsep_dirs: []

# Local (relative to playbook) path to local tools
galaxy_local_tools_src_dir: files/galaxy/tools

# Local (relative to playbook) path to dynamic job rules
galaxy_dynamic_job_rules_src_dir: files/galaxy/dynamic_job_rules

# Remote path to dynamic job rules (must be on Galaxy's $PYTHONPATH if not the default)
galaxy_dynamic_job_rules_dir: "{{ galaxy_server_dir }}/lib/galaxy/jobs/rules"

# List of dynamic rules to install
galaxy_dynamic_job_rules: []

#
# Cleanup
#

# Galaxy can leave behind certain job and execution artifacts that make debugging failures easier, but can consume a lot
# of disk space. This option uses the standard tmpwatch (RedHat) or tmpreaper (Debian) utility to clean up files and
# directories older than a given age in these direcotires.
#
# This utility must be installed on your Galaxy server. This role does not install it for you. See the utility's man
# page for a more detailed understanding of the options below.

# List of directories to clean
galaxy_tmpclean_dirs:
  - "{{ galaxy_job_working_directory }}"
  - "{{ galaxy_config.galaxy.new_file_path | default((galaxy_mutable_data_dir, 'tmp') | path_join) }}"

# Files and directories with a *modification time* older than this are removed
galaxy_tmpclean_age: 30d

# Log the command output, default (true) is cron mail, set to a path to log to file instead or YAML null to send to
# /dev/null
galaxy_tmpclean_log: true

# File in /etc/cron.d to write the cron job, set to YAML null to use user crontab instead
galaxy_tmpclean_cron_file: ansible_galaxy_tmpclean

# Set the tmpwatch/tmpreaper -v option, which outputs a line for each deletion
galaxy_tmpclean_verbose: false

# When to run the cron job, hash keys correspond to the cron module options:
#   https://docs.ansible.com/ansible/latest/collections/ansible/builtin/cron_module.html
#
#galaxy_tmpclean_time:
#  special_time:
#  hour:
#  minute:
#  day:
#  month:
#  weekday:
#
# Use @daily by default:
galaxy_tmpclean_time:
  special_time: daily

# On Debian-based systems, the tmpreaper command has a maximum runtime to help avoid race conditions. This default of 20
# hours is suitable for the default daily frequency above but should be adjusted if you run with a different frequency.
galaxy_tmpclean_tmpreaper_runtime: "{{ 20 * 60 * 60 }}"

# You generally shouldn't have to mess with the rest of the options in this section

_galaxy_tmpclean_command:
  redhat: "/usr/bin/tmpwatch -all --mtime --dirmtime"
  debian: "/usr/sbin/tmpreaper --all --mtime --mtime-dir --runtime={{ galaxy_tmpclean_tmpreaper_runtime }}"

galaxy_tmpclean_verbose_statement: "{{ galaxy_tmpclean_verbose | ternary(' -v', '') }}"
galaxy_tmpclean_log_statement: >-
  {{ (galaxy_tmpclean_log != true) | ternary(
      ((galaxy_tmpclean_log is none) | ternary(
          '>/dev/null',
          '>>' ~ galaxy_tmpclean_log
      )),
      ''
  ) }}
  
galaxy_tmpclean_command: "{{ _galaxy_tmpclean_command[(ansible_os_family | lower)] }}{{ galaxy_tmpclean_verbose_statement }}"

#
# Version control
#

# This is now automatically determined in tasks/_inc_node_version.yml, but it can be set to force a version
#galaxy_node_version: "XX.YY.Z"

# Where to clone Galaxy from. Backwards compatibility with galaxy_git_repo
galaxy_repo: "{{ galaxy_git_repo | default('https://github.com/galaxyproject/galaxy.git') }}"

# Automatically delete things in the repo that do not belong there
galaxy_force_checkout: no

# Git clone depth for the galaxy repository. Leave unset to ignore.
#galaxy_clone_depth:

# This can be a tag (as shown here) but doing so will cause the revision check task to always report "changed".
# Backwards compatibility with galaxy_changeset_id.
galaxy_commit_id: "{{ galaxy_changeset_id | default('master') }}"

# Download URL (if used)
galaxy_download_url: "{{ galaxy_repo | replace('.git', '') }}/archive/{{ galaxy_commit_id }}.tar.gz"

#
# Path and Galaxy configuration
#

# Directory layout for deployment (legacy is the default)
#galaxy_layout: legacy

# List of tool configs to load
galaxy_tool_config_files:
  - "{{ galaxy_server_dir }}/config/tool_conf.xml.sample"

# The shed tool conf path is needed separate from the value of tool_conf for instantiation. The 'conf' version is a
# legacy variable name and should not be used.
galaxy_shed_tool_conf_file: "{{ galaxy_mutable_config_dir }}/shed_tool_conf.xml"
galaxy_shed_tool_config_file: "{{ galaxy_shed_tool_conf_file }}"

# The Python `requirements.txt` file that should be used to install Galaxy dependent modules using pip
galaxy_requirements_file: "{{ galaxy_server_dir }}/lib/galaxy/dependencies/pinned-requirements.txt"

# This will be configurable at some point
galaxy_static_dir: "{{ galaxy_server_dir }}/static"

# Galaxy config file can either be 'ini-paste' (old style) or 'yaml'
galaxy_config_style: "yaml"
galaxy_config_file_basename: "galaxy.{{ 'yml' if galaxy_config_style in ('yaml', 'yml') else 'ini' }}"
galaxy_config_file_template: "{{ galaxy_config_file_basename }}.j2"
galaxy_config_file: "{{ galaxy_config_dir }}/{{ galaxy_config_file_basename }}"
galaxy_app_config_section: "{{ 'galaxy' if galaxy_config_style in ('yaml', 'yml') else 'app:main' }}"

# Galaxy configuration files will be written with these permissions (mode argument to Ansible copy/template module)
galaxy_config_perms: 0640
galaxy_config_perms_public: 0644

# The default Galaxy configuration, ensures that Galaxy can find all of the configs if galaxy_config_dir !=
# galaxy_server_dir
galaxy_paste_app_factory: "galaxy.web.buildapp:app_factory"
galaxy_app_config_default:
  # Defaults for sample configs that require a value to be set
  builds_file_path: "{{ galaxy_server_dir }}/tool-data/shared/ucsc/builds.txt.sample"
  data_manager_config_file: "{{ galaxy_server_dir }}/config/data_manager_conf.xml.sample"
  datatypes_config_file: "{{ galaxy_server_dir }}/config/datatypes_conf.xml.sample"
  external_service_type_config_file: "{{ galaxy_server_dir }}/config/external_service_types_conf.xml.sample"
  openid_config_file: "{{ galaxy_server_dir }}/config/openid_conf.xml.sample"
  ucsc_build_sites: "{{ galaxy_server_dir }}/tool-data/shared/ucsc/ucsc_build_sites.txt.sample"
  tool_data_table_config_path: "{{ galaxy_server_dir }}/config/tool_data_table_conf.xml.sample"
  tool_sheds_config_file: "{{ galaxy_server_dir }}/config/tool_sheds_conf.xml.sample"
  themes_config_file: "{{ galaxy_config_dir }}/themes_conf.yml"

  # Various cache and temporary directories
  data_dir: "{{ galaxy_mutable_data_dir }}"

  # Mutable config files
  integrated_tool_panel_config: "{{ galaxy_mutable_config_dir }}/integrated_tool_panel.xml"
  migrated_tools_config: "{{ galaxy_mutable_config_dir }}/migrated_tools_conf.xml"
  shed_data_manager_config_file: "{{ galaxy_mutable_config_dir }}/shed_data_manager_conf.xml"
  shed_tool_data_table_config: "{{ galaxy_mutable_config_dir }}/shed_tool_data_table_conf.xml"

  # Directories that would often be stored outside the mutable data dir, these values are either from the layout or set by the user
  file_path: "{{ galaxy_file_path }}"
  job_working_directory: "{{ galaxy_job_working_directory }}"
  tool_dependency_dir: "{{ galaxy_tool_dependency_dir }}"
  tool_data_path: "{{ galaxy_tool_data_path }}"

  # Static config files
  tool_config_file: "{{ galaxy_tool_config_files | join(',') }}"
  shed_tool_config_file: "{{ galaxy_shed_tool_config_file }}"

  # Static configs that default to .xml files in the config dir but the role writes as .yml if configured
  job_metrics_config_file: "{{ galaxy_config_dir }}/job_metrics_conf.{{ (galaxy_job_metrics_plugins is defined) | ternary('yml', 'xml') }}"
  dependency_resolvers_config_file: "{{ galaxy_config_dir }}/dependency_resolvers_conf.{{ (galaxy_dependency_resolvers is defined) | ternary('yml', 'xml') }}"
  container_resolvers_config_file: "{{ (galaxy_container_resolvers is defined) | ternary(galaxy_config_dir ~ '/container_resolvers_conf.yml', none) }}"

  # Everything else
  visualization_plugins_directory: "config/plugins/visualizations"

  # Static and themes configuration, will only be added if galaxy_manage_themes
  static_enabled: "{{ galaxy_manage_subdomain_static }}"
  static_dir_by_host: >
    { {% if galaxy_manage_subdomain_static %}
    '{{ galaxy_themes_instance_domain }}': '{{ galaxy_static_dir }}/',
    {% for subdomain in galaxy_themes_subdomains %}
    '{{ subdomain.name }}.{{ galaxy_themes_instance_domain}}': '{{ galaxy_themes_static_path }}/static-{{ subdomain.name }}/',
    {% endfor %}
    {% endif %} }
  static_images_dir_by_host: >
    { {% if galaxy_manage_subdomain_static %}
    '{{ galaxy_themes_instance_domain }}': '{{ galaxy_static_dir }}/images',
    {% for subdomain in galaxy_themes_subdomains %}
    '{{ subdomain.name }}.{{ galaxy_themes_instance_domain}}': '{{ galaxy_themes_static_path }}/static-{{ subdomain.name }}/images',
    {% endfor %}
    {% endif %} }
  static_welcome_html_by_host: >
    { {% if galaxy_manage_subdomain_static %}
    '{{ galaxy_themes_instance_domain }}': '{{ galaxy_static_dir }}/welcome.html',
    {% for subdomain in galaxy_themes_subdomains %}
    '{{ subdomain.name }}.{{ galaxy_themes_instance_domain}}': '{{ galaxy_themes_static_path }}/static-{{ subdomain.name }}/welcome.html',
    {% endfor %}
    {% endif %} }
  static_scripts_dir_by_host: >
    { {% if galaxy_manage_subdomain_static %}
    '{{ galaxy_themes_instance_domain }}': '{{ galaxy_static_dir }}/scripts',
    {% for subdomain in galaxy_themes_subdomains %}
    '{{ subdomain.name }}.{{ galaxy_themes_instance_domain}}': '{{ galaxy_themes_static_path }}/static-{{ subdomain.name }}/scripts',
    {% endfor %}
    {% endif %} }
  static_favicon_dir_by_host: >
    { {% if galaxy_manage_subdomain_static %}
    '{{ galaxy_themes_instance_domain }}': '{{ galaxy_static_dir }}',
    {% for subdomain in galaxy_themes_subdomains %}
    '{{ subdomain.name }}.{{ galaxy_themes_instance_domain}}': '{{ galaxy_themes_static_path }}/static-{{ subdomain.name }}',
    {% endfor %}
    {% endif %} }
  static_robots_txt_by_host: >
    { {% if galaxy_manage_subdomain_static %}
    '{{ galaxy_themes_instance_domain }}': '{{ galaxy_static_dir }}',
    {% for subdomain in galaxy_themes_subdomains %}
    '{{ subdomain.name }}.{{ galaxy_themes_instance_domain}}': '{{ galaxy_themes_static_path }}/static-{{ subdomain.name }}',
    {% endfor %}
    {% endif %} }
  themes_config_file_by_host: >
    { {% if galaxy_manage_themes and galaxy_themes_subdomains %}
    '{{ galaxy_themes_instance_domain }}': '{{ galaxy_config.galaxy.themes_config_file | default((galaxy_config_dir, "themes_conf.yml") | path_join) }}',
    {% for subdomain in galaxy_themes_subdomains %}
    {% if subdomain.theme is defined %}
    '{{ subdomain.name  }}.{{ galaxy_themes_instance_domain}}': 'themes_conf-{{ subdomain.name }}.yml',
    {% endif %}
    {% endfor %}
    {% endif %} }
  brand_by_host: >
    { {% if galaxy_auto_brand %}
    '{{ galaxy_themes_instance_domain }}': '{{ galaxy_themes_instance_domain }}',
    {% for subdomain in galaxy_themes_subdomains %}
    '{{ subdomain.name  }}.{{ galaxy_themes_instance_domain}}': '{{ subdomain.name[0]|upper }}{{ subdomain.name[1:] }}',
    {% endfor %}
    {% endif %} }
# Need to set galaxy_config_default[galaxy_app_config_section] dynamically but Ansible/Jinja2 does not make this easy
galaxy_config_default: "{{ {} | combine({galaxy_app_config_section: galaxy_app_config_default}) }}"
galaxy_config_merged: "{{ galaxy_config_default | combine(galaxy_config | default({}), recursive=True) }}"

# Automatically instantiate mutable config files from copies in role if they don't exist
galaxy_mutable_config_files:
  - src: "shed_data_manager_conf.xml"
    dest: "{{ galaxy_config_merged[galaxy_app_config_section].shed_data_manager_config_file }}"
  - src: "shed_tool_data_table_conf.xml"
    dest: "{{ galaxy_config_merged[galaxy_app_config_section].shed_tool_data_table_config }}"
galaxy_mutable_config_templates:
  - src: "shed_tool_conf.xml.j2"
    dest: "{{ galaxy_config_merged[galaxy_app_config_section].migrated_tools_config }}"
  - src: "shed_tool_conf.xml.j2"
    dest: "{{ galaxy_shed_tool_config_file }}"

galaxy_config_error_email_to: "{{ galaxy_config_merged[galaxy_app_config_section].error_email_to | default('') }}"
galaxy_config_instance_resource_url: "{{ galaxy_config_merged[galaxy_app_config_section].instance_resource_url | default('') }}"
galaxy_errordocs_server_name: Galaxy
galaxy_errordocs_prefix: /error

# These are lists of hashes in the same format as galaxy_mutable_configs that can be used to cause extra files and
# templates to be installed on the managed host.
galaxy_config_files: []
galaxy_config_templates: []
# Like above, except with world readable permissions
galaxy_config_files_public: []

# Default Gravity configuration
galaxy_gravity_state_dir: "{{ (galaxy_mutable_data_dir, 'gravity') | path_join }}"
galaxy_gravity_config_default:
  galaxy_root: "{{ galaxy_server_dir }}"
  log_dir: "{{ galaxy_log_dir }}"
  virtualenv: "{{ galaxy_venv_dir }}"
  app_server: gunicorn
  gunicorn:
    bind: localhost:8080

# Default uWSGI configuration
galaxy_uwsgi_yaml_parser: internal
galaxy_uwsgi_config_default:
  http: 127.0.0.1:8080
  buffer-size: 16384
  processes: 1
  threads: 4
  offload-threads: 2
  static-map:
    - /static/style={{ galaxy_server_dir }}/static/style/blue
    - /static={{ galaxy_server_dir }}/static
  master: true
  virtualenv: "{{ galaxy_venv_dir }}"
  pythonpath: "{{ galaxy_server_dir }}/lib"
  module: galaxy.webapps.galaxy.buildapp:uwsgi_app()
  thunder-lock: true
  die-on-term: true
  hook-master-start:
    - unix_signal:2 gracefully_kill_them_all
    - unix_signal:15 gracefully_kill_them_all
  py-call-osafterfork: true
  enable-threads: true

# TODO: Implement something like this for starter/restarter
#galaxy_server_type: paste_singleprocess

#
# Client build settings
#


# If this is set to true, instead of building the client from source, a prebuilt version of the client will be installed from NPM.
# This mimics the behavior of the GALAXY_INSTALL_PREBUILT_CLIENT=1 setting when running Galaxy with run.sh.
# When setting this to true, none of the other client settings below will be used.
galaxy_client_use_prebuilt: false

# Options include: client / client-production / client-production-maps (default). Set to null to invoke each step of the
# build separately, but this is not guaranteed to work for all version of Galaxy - using `make` is the safer choice.
galaxy_client_make_target: client-production-maps

# Build the client even if it is not out of date
galaxy_client_force_build: false

# If galaxy_client_make_target is null, you can set this to `development` to build the client for development
galaxy_client_node_env: production
galaxy_client_build_steps:
  default:
    - client
    - plugins
  "19.09":
    - fonts
    - stageLibs
    - plugins

__galaxy_node_version_max:
  "redhat7": "16.19.1"
galaxy_node_version_max: >-
  {{
    (__galaxy_node_version_max[(ansible_os_family | lower) ~ ansible_distribution_major_version]) | default(galaxy_node_version)
  }}

#
# systemd options
#

__galaxy_gravity_pm: "{{ (galaxy_config_merged.gravity | default({})).process_manager | default('supervisor') }}"
__galaxy_gravity_instance_name: "{{ (galaxy_config_merged.gravity | default({})).instance_name | default(none) }}"
galaxy_gravity_wrapper_path: "/usr/local/bin/galaxyctl{{ __galaxy_gravity_instance_name | ternary('-' ~ __galaxy_gravity_instance_name, '') }}"
galaxy_gravity_command: "{{ galaxy_venv_dir }}/bin/galaxyctl"

# Currently `mule` (aka uWSGI) and `gravity` (runs Galaxy 22.01+ under gunicorn) are supported
galaxy_systemd_mode: "{{ 'mule' if __galaxy_major_version is version('22.05', '<') else 'gravity' }}"

# Control whether the systemd service unit is installed/controlled as root or the Galaxy user
galaxy_systemd_root: true

# The command that systemd will run to start Galaxy, depends on galaxy_systemd_mode or override
galaxy_systemd_command: "{{ __galaxy_systemd_command[galaxy_systemd_mode] }}"
__galaxy_systemd_command:
  mule: "{{ galaxy_venv_dir }}/bin/uwsgi {{ '--yaml' if galaxy_config_style in ('yaml', 'yml') else '--ini' }} {{ galaxy_config_file }}"
  gravity: "{{ galaxy_venv_dir }}/bin/galaxyctl start --foreground --quiet"

# TimeoutStartSec is unfortunately also the timeout used for reload operations, which take longer
galaxy_systemd_timeout_start_sec: "{{ (galaxy_systemd_mode == 'gravity') | ternary(60, 10) }}"

# Systemd will create cgroups to enforce these limits (sizes in GB), override individual limits by setting
# `galaxy_systemd_memory_limit.<limit>` in your vars.
__galaxy_systemd_memory_limit:
  # This is for the entire group of uWSGI master, web worker, and mule processes
  mule: 16
  reports: 5
  #workflow: 5
  #zergpool: 8
  #zergling: 16
  #handler: 5
__galaxy_systemd_memory_limit_merged: "{{ __galaxy_systemd_memory_limit | combine(galaxy_systemd_memory_limit | default({})) }}"

# A list of KEY=val strings to be added as `Environment=KEY=val` to the systemd service unit
galaxy_systemd_env: []

# A list of additional python packages to install into galaxy's virtual environment
galaxy_additional_venv_packages: []

# galaxy themes variables
galaxy_themes_subdomains: []
# - name: assembly
#   tool_sections:
#     - "hicexplorer"
#     - "graph_display_data"
#     - "peak_calling"
#     - "assembly"
#     - "annotation"
#     - "genome_diversity"
#     - "multiple_alignments"
#   extra_tool_labels:
#     - "proteomics"
#   # default theme (optional)
#   theme:
#     assembly:
#       masthead:
#         color: >
#           bottom -90px left / 1000px no-repeat url("/static/dist/flying-bird-1.svg"),
#           bottom -90px left / 1000px no-repeat url("/static/dist/flying-bird-2.svg"),
#           linear-gradient( 20deg,
#             rgb(7, 40, 98) 0%,
#             rgb(69, 122, 184) 48%,
#             rgba(165, 204, 210, 0.9676562309265136) 74%,
#             rgb(228, 195, 131) 92%,
#             rgb(203, 119, 79) 100%)
galaxy_themes_static_keys:
  static_dir: ""
  static_images_dir: "images/"
  static_scripts_dir: "scripts/"
  static_welcome_html: "welcome.html/"
  static_favicon_dir: "favicon.ico"
  static_robots_txt: "robots.txt"
galaxy_themes_static_path: "{{ galaxy_root }}/server"
galaxy_themes_static_dir: "{{ galaxy_root }}/server/static"
galaxy_themes_symlinks: true
galaxy_themes_symlinks_no_log: false # Hides extended logs for the symlink task in static/dist
galaxy_themes_welcome_url_prefix: https://usegalaxy-eu.github.io/index-
galaxy_themes_default_welcome: https://galaxyproject.org
galaxy_themes_ansible_file_path: files/galaxy/static
galaxy_themes_instance_domain: usegalaxy.eu
galaxy_themes_global_host_filters_path: "{{ galaxy_root }}/server/lib/galaxy/tool_util/toolbox/filters/global_host_filters.py"
galaxy_themes_tool_base_labels:
  - "file_and_meta_tools"
  - "general_text_tools"
  - "genomic_file_manipulation"
  - "gff"
  - "common_genomics"
galaxy_themes_tool_ngs_labels:
  - "specific_genomics"
  - "genomics_toolkits"

# These sections will be displayed in the tool panel for every subdomain
galaxy_themes_tool_base_sections:
  - "getext"
  - "send"
  - "collection_operations"
  - "textutil"
  - "convert"
  - "filter"
  - "group"
  - "expression_tools"

# There sections are a collection of general NGS tools and will be used in most but not all subdomains
galaxy_themes_tool_ngs_sections:
  - "deeptools"
  - "bed"
  - "sambam"
  - "bxops"
  - "fastafastq"
  - "fastq_quality_control"
  - "picard"
  - "mapping"
  - "sambam"