Add audiobookshelf

ansible/main.yml

@@ -1,3 +1,3 @@
 - hosts: pve-docker
   roles:
-    - qbittorrent
+    - gitea

ansible/roles/audiobookshelf/tasks/main.yml

@@ -1,5 +1,5 @@
 - name: Create service user
-  user:
+  ansible.builtin.user:
     name: "{{ role_name }}"
     system: true
   register: service_user
@@ -13,6 +13,15 @@
     mode: "{{ docker_compose_directory_mask }}"
   become: true
 
+- name: Create config directory
+  file:
+    path: "{{ data_dir }}/{{ role_name }}"
+    state: directory
+    owner: "{{ docker_user }}"
+    group: "{{ docker_user }}"
+    mode: "{{ docker_compose_directory_mask }}"
+  become: true
+
 - name: Copy docker-compose file to destination
   template:
     src: docker-compose.yml
@@ -22,16 +31,6 @@
     validate: docker compose -f %s config
   become: true
 
-- name: Install script files
-  ansible.builtin.copy:
-    src: "{{ item }}"
-    dest: "{{ data_dir }}/tautulli/scripts"
-    mode: "{{ docker_compose_file_mask }}"
-    owner: "{{ primary_user }}"
-  with_fileglob:
-    - "files/*"
-  become: true
-
 - name: Start docker container
   community.docker.docker_compose_v2:
     project_src: "{{ install_directory }}/{{ role_name }}"

ansible/roles/audiobookshelf/templates/docker-compose.yml

@@ -0,0 +1,21 @@
+networks:
+  traefik:
+    external: true
+
+services:
+  {{ role_name }}:
+    container_name: "{{ role_name }}"
+    image: ghcr.io/advplyr/audiobookshelf:latest
+    restart: unless-stopped
+    networks:
+      - traefik
+    environment:
+      - "TZ={{ timezone }}"
+    volumes:
+      - "{{ data_dir }}/{{ role_name }}/config:/config"
+      - "{{ data_dir }}/{{ role_name }}/metadata:/metadata"
+      - "{{ media_storage_mnt }}/data/media/books:/books:ro"
+    labels:
+      traefik.enable: true
+      traefik.http.routers.{{ role_name }}.rule: "Host(`audiobooks.{{ personal_domain }}`)"
+      #traefik.http.services.{{ role_name }}.loadbalancer.server.port: 13378

ansible/roles/beets/files/config.yaml

@@ -12,13 +12,11 @@ item_fields:
         
 import:
     write: yes
-    move: yes
-    resume: ask
-    incremental: yes
-    quiet_fallback: skip
+    move: no
+    quiet: yes
     timid: no
-    log: /config/beet.log
     languages: "en jp es"
+    autotag: yes
 
 asciify_paths: yes
 
@@ -39,7 +37,8 @@ match:
     ignored_media: ['12" Vinyl']
 
 lyrics:
-    sources: [lrclib, genius, tekstowo]
+    auto: yes
+    sources: [lrcmux]
     
 scrub:
     auto: yes

ansible/roles/gitea/tasks/main.yml

@@ -45,6 +45,8 @@
   loop:
     - data
     - config
+    - runner/data
+    - runner/config
   become: true
 
 - name: Install configuration file

ansible/roles/gitea/templates/config.yaml

@@ -0,0 +1,302 @@
+# Every option with its default value, all commented out. Read this file, do not copy it.
+# `./gitea-runner config init` writes a config file to copy the lines you change into.
+
+# Logging for the runner process itself (messages printed to stderr), plus the copy of
+# each task's log kept under log.job. Neither controls how workflow step output is streamed
+# to the Gitea UI; tune that with runner.log_report_* below.
+log:
+  # logrus severity: trace, debug, info, warn, error, fatal, panic.
+  # trace and debug turn on caller/file:line in log lines. Default if omitted: info.
+  #level: info
+  # Write a copy of each task's log to dir as <start time>-task-<id>.log, so a job's output
+  # survives a failure to send it to Gitea. A path turns them on, empty turns them off.
+  # retention is how long a log is kept (0s keeps all), max_size caps one log (0 is no limit).
+  #job:
+  #  dir: ""
+  #  retention: 168h
+  #  max_size: 1GB
+
+runner:
+  # Where to store the registration result.
+  #file: .runner
+  # Execute how many tasks concurrently at the same time.
+  # With `container.network` empty, each concurrent docker job takes a subnet from the
+  # daemon's address pool, so a high capacity can exhaust it. See `default-address-pools`
+  # in the docker daemon config.
+  #capacity: 1
+  # Extra environment variables to run jobs.
+  #envs:
+  #  A_TEST_ENV_NAME_1: a_test_env_value_1
+  #  A_TEST_ENV_NAME_2: a_test_env_value_2
+  # Extra environment variables to run jobs from a file.
+  # It will be ignored if it's empty or the file doesn't exist.
+  #env_file: .env
+  # The timeout for a job to be finished.
+  # Please note that the Gitea instance also has a timeout (3h by default) for the job.
+  # So the job could be stopped by the Gitea instance if its timeout is shorter than this.
+  #timeout: 3h
+  # The timeout for the runner to wait for running jobs to finish when shutting down.
+  # Any running jobs that haven't finished after this timeout will be cancelled.
+  #shutdown_timeout: 0s
+  # Whether skip verifying the TLS certificate of the Gitea instance.
+  #insecure: false
+  # The timeout for fetching the job from the Gitea instance.
+  # Values above the 60s RPC timeout are capped to it.
+  #fetch_timeout: 5s
+  # The interval for fetching the job from the Gitea instance.
+  #fetch_interval: 2s
+  # The maximum interval for fetching the job from the Gitea instance.
+  # The runner uses exponential backoff when idle, increasing the interval up to this maximum.
+  # Set to 0 or same as fetch_interval to disable backoff.
+  #fetch_interval_max: 5s
+  # While idle, remove stale bind-workdir task directories and orphaned host-mode
+  # scratch directories (left behind when a host cleanup delete stalls) older than
+  # this duration. Setting either workdir_cleanup_age or idle_cleanup_interval to 0
+  # (or any non-positive value) disables stale-directory cleanup entirely, along with
+  # the docker network and volume cleanup below.
+  #workdir_cleanup_age: 24h
+  # Cadence for the idle cleanup pass. Besides the directories above, on runners that use
+  # docker it removes the per-job networks and volumes of jobs this runner did not live to
+  # tear down, which would otherwise hold a subnet of the daemon address pool and the job's
+  # workspace contents until the host is rebuilt.
+  #idle_cleanup_interval: 10m
+  # The base interval for periodic log flush to the Gitea instance.
+  # Logs may be sent earlier if the buffer reaches log_report_batch_size
+  # or if log_report_max_latency expires after the first buffered row.
+  #log_report_interval: 5s
+  # The maximum time a log row can wait before being sent.
+  # This ensures even a single log line appears on the frontend within this duration.
+  # Must be less than log_report_interval to have any effect.
+  #log_report_max_latency: 3s
+  # Flush logs immediately when the buffer reaches this many rows.
+  # This ensures bursty output (e.g., npm install) is delivered promptly.
+  #log_report_batch_size: 100
+  # The interval for reporting task state (step status, timing) to the Gitea instance.
+  # State is also reported on step transitions (start/stop) and after each log flush.
+  #state_report_interval: 5s
+  # Per-attempt deadline for flushing the final logs and task state when a job
+  # finishes, on a detached context so a server cancel can't block the acknowledgement.
+  #report_close_timeout: 10s
+  # The github_mirror of a runner is used to specify the mirror address of the github that pulls the action repository.
+  # It works when something like `uses: actions/checkout@v4` is used and DEFAULT_ACTIONS_URL is set to github,
+  # and github_mirror is not empty. In this case,
+  # it replaces https://github.com with the value here, which is useful for some special network environments.
+  #github_mirror: ''
+  # When true (the default), fetch only the requested ref of an action repository (e.g. actions/checkout@v4) at depth 1 instead of cloning every branch's full history.
+  # Set to false to clone the full history.
+  #action_shallow_clone: true
+  # When true (the default), inject the ACT=true environment variable into jobs.
+  # Set to false so workflows gated on `if: ${{ !env.ACT }}` behave like they do on GitHub.
+  #set_act_env: true
+  # When true (the default), apply compatibility patches to the actions a job runs, so actions
+  # written for GitHub work against this instance. Set to false to run them exactly as published,
+  # at the price of the stock artifact actions refusing and the cache client keeping to v1.
+  #patch_actions: true
+  # The labels of a runner are used to determine which jobs the runner can run, and how to run them.
+  # Like: "macos-arm64:host" or "ubuntu-latest:docker://docker.gitea.com/runner-images:ubuntu-latest"
+  # Find more images provided by Gitea at https://gitea.com/gitea/runner-images .
+  # If it's empty when registering, it will ask for inputting labels.
+  # If it's empty when execute `daemon`, will use labels in `.runner` file.
+  #labels:
+  #  - "ubuntu-latest:docker://docker.gitea.com/runner-images:ubuntu-latest"
+  #  - "ubuntu-24.04:docker://docker.gitea.com/runner-images:ubuntu-24.04"
+  #  - "ubuntu-22.04:docker://docker.gitea.com/runner-images:ubuntu-22.04"
+  # Allocate a pseudo-TTY for each step's process. Applies to both host and docker backends.
+  # Default false matches GitHub actions/runner. Enable only for jobs that need an interactive
+  # terminal; tools like `docker build` emit redrawing progress frames into the captured log
+  # when a TTY is present.
+  #allocate_pty: false
+  # Image for a job whose runs-on matches none of the labels above. A runner without a
+  # docker daemon runs such a job on the host instead.
+  #default_image: "docker.gitea.com/runner-images:ubuntu-latest"
+  # What to mount at RUNNER_TOOL_CACHE (/opt/hostedtoolcache), where setup actions install tools:
+  #   none:   nothing. A docker job sees what its image ships there, a host job an empty dir, and
+  #           either way what it installs is gone when the job ends.
+  #   shared: one tool cache every job reuses. Two jobs writing the same tool version at once
+  #           corrupt it, so use it only with capacity 1.
+  #tool_cache_mode: none
+  # Optional executable on the host, run once after each task's built-in cleanup
+  # (post-steps, container teardown, bind-workdir removal). Additive only.
+  #
+  # IMPORTANT: While this script runs the runner stops task heartbeats and stays
+  # offline from Gitea's perspective until the script exits. A script that never
+  # returns blocks new work until post_task_script_timeout kills it (default 5m).
+  # Keep scripts short; set post_task_script_timeout to a safe upper bound.
+  #
+  # Output -> runner process log (not the job log). Non-zero exit -> warning only.
+  # Windows: use .exe, .bat, or .cmd. PowerShell (.ps1) is not supported yet as
+  # the configured path; wrap PowerShell commands in a .cmd file instead.
+  # Full guide: docs/post-task-script.md
+  #post_task_script: ''
+  # Hard limit on post_task_script runtime. Default if omitted: 5m.
+  #post_task_script_timeout: 5m
+  # Scripts run inside the job environment before the job's first step and after its last
+  # one, the equivalent of GitHub's ACTIONS_RUNNER_HOOK_JOB_STARTED and
+  # ACTIONS_RUNNER_HOOK_JOB_COMPLETED, which are read when these are unset. The paths are
+  # resolved inside the job environment. Either one failing fails the job.
+  # Full guide: docs/job-hooks.md
+  #hooks:
+  #  job_started: ''
+  #  job_completed: ''
+
+cache:
+  # Enable caching (used by actions/cache and similar actions). Off means no built-in server is
+  # started and no job is registered with an external_server either.
+  #enabled: true
+  # Directory where cache blobs are stored on disk. Default: $HOME/.cache/actcache
+  # Ignored when external_server is set.
+  #dir: ""
+  # Outbound IP or hostname that job containers use to reach this runner's cache server.
+  # Leave empty to detect automatically. 0.0.0.0 is not valid here.
+  # If the runner itself runs in Docker, automatic detection can choose an
+  # address on the runner container's network that job containers cannot reach
+  # when the runner creates a separate per-job network. In that case, set this
+  # to a hostname/IP reachable from job containers, and set port to a fixed
+  # published port or put the job containers on a shared Docker network.
+  # Ignored when external_server is set.
+  #host: ""
+  # Port for the built-in cache server. 0 picks a random free port.
+  # Ignored when external_server is set.
+  #port: 0
+  # URL of a shared `gitea-runner cache-server` to use instead of starting a local one.
+  # Set on every runner that should share a cache pool. A trailing slash is optional.
+  # Jobs reach the server at this URL too, so set it to the reverse proxy when one fronts the server.
+  # Example: "http://cache-host:8088/"
+  # Requires external_secret (below) to match the value on the cache-server.
+  #external_server: ""
+  # Shared secret between this runner and the external cache-server.
+  # Required when external_server is set. Must be identical on every runner and the cache-server.
+  # Generate with: openssl rand -hex 32
+  #external_secret: ""
+  # Path to a file containing the shared secret, as an alternative to external_secret.
+  # Use this to keep the secret out of this file.
+  # Surrounding whitespace is trimmed, so a trailing newline in the file is fine.
+  # Setting both external_secret and external_secret_file is an error.
+  #external_secret_file: ""
+  # When true, reuse a cached action instead of fetching from the remote on every job.
+  # A moved tag (e.g. a re-tagged "v6") or an updated branch stays at the cached commit
+  # until its cache entry expires or is manually removed.
+  #offline_mode: false
+  # Serve the actions cache service v2 API. The actions that use it fall back to v1 on any host
+  # they do not take for GitHub, so reaching it means editing that check out of their own bundle,
+  # put back after the copy into the job. That edit is made either way, this only governs the API
+  # advertised. A bundle that does not match is left alone. With v2, artifact uploads go via the
+  # cache server unless container jobs cannot reach its Docker network.
+  #v2: true
+  # How the cache server discards entries, ignored when external_server is set since that
+  # server applies its own. Leave a setting out for its default; 0s or 0 turns the three
+  # limits off. Sizes accept 10GB, 512mb, 1TiB or a plain byte count, binary either way.
+  # Whatever these allow, the cache still sheds entries to keep free space on its volume
+  # above health_check.min_free_disk_space_mb when health checks are enabled.
+  # Remove entries nothing has read or written within this window. Only last access counts.
+  #retention: 168h
+  # Cap one repository, removing its least recently accessed entries until it fits. An entry
+  # larger than the limit is dropped rather than emptying the repository to make room.
+  #repo_size_limit: 10GB
+  # Cap the whole cache the same way. Off by default, since the free space floor bounds it.
+  #size_limit: 0
+  # Minimum time between two eviction sweeps. This one has no "off".
+  #sweep_interval: 1h
+
+container:
+  # Specifies the network to which the container will connect.
+  # Could be host, bridge or the name of a custom network.
+  # If it's empty, runner will create a network automatically.
+  # For dockerized runners using the built-in cache server, a custom shared
+  # network can be required so job containers can reach cache.host/cache.port.
+  # Deprecated: `network_mode` is still accepted for old configs; use `network` instead.
+  #network: ""
+  # network_create_options only apply when `network` is left empty and the runner
+  # auto-creates a per-job network that does not already exist. They have no effect
+  # when a custom `network` name is set, because that network is used as-is and never
+  # created by the runner. Omit the entire block to use Docker's defaults. An auto-created
+  # network is labelled com.gitea.runner.uuid=<this runner's uuid>, which is how the idle
+  # cleanup tells its own leftovers apart from those of other runners on the same daemon.
+  #network_create_options:
+  #  enable_ipv4: true # Omit to use Docker's default (IPv4 enabled). Set false to disable IPv4.
+  #  enable_ipv6: false # Omit to use Docker's default (IPv6 disabled). Enabling it requires dockerd started with --ipv6.
+  # Whether to use privileged mode or not when launching task containers (privileged mode is required for Docker-in-Docker).
+  #privileged: false
+  # Any other options to be used when the container is started, for example:
+  #   options: --add-host=my.gitea.url:host-gateway
+  # A volume declared here replaces the one the runner would mount on the same container path, so the
+  # tool cache can be kept on the host. Its source must also be allowed by valid_volumes below:
+  #   options: --volume /host/toolcache:/opt/hostedtoolcache
+  # With privileged disabled, options that could escape the container (--security-opt, --device,
+  # --cap-add, --pid, ...) are ignored in a workflow's container.options, but keep working here.
+  #options:
+  # The parent directory of a job's working directory.
+  # NOTE: There is no need to add the first '/' of the path as runner will add it automatically.
+  # If the path starts with '/', the '/' will be trimmed.
+  # For example, if the parent directory is /path/to/my/dir, workdir_parent should be path/to/my/dir
+  # If it's empty, /workspace will be used.
+  # Purely numeric subdirectories under this path are reserved for task workspaces and may be removed by idle cleanup.
+  #workdir_parent:
+  # Volumes (including bind mounts) can be mounted to containers. Glob syntax is supported, see https://github.com/gobwas/glob
+  # You can specify multiple volumes. If the sequence is empty, no volumes can be mounted.
+  # For example, if you only allow containers to mount the `data` volume and all the json files in `/src`, you should change the config to:
+  # valid_volumes:
+  #   - data
+  #   - /src/*.json
+  # If you want to allow any volume, please use the following configuration:
+  # valid_volumes:
+  #   - '**'
+  #valid_volumes: []
+  # Overrides the docker client host with the specified one.
+  # If it's empty, runner will find an available docker host automatically.
+  # If it's "-", runner will find an available docker host automatically, but won't mount it into the job and action containers.
+  # If it's not empty or "-", the specified docker host will be used. An error will be returned if it doesn't work.
+  #docker_host: ""
+  # Pull docker image(s) even if already present.
+  # Defaults to false when the key is omitted.
+  # Two exceptions: an image pinned by digest (image@sha256:...) cannot change, so it is never
+  # re-pulled, and a pull that fails while a copy is already on the host does not fail the job,
+  # which runs on that copy with a warning in its log.
+  #force_pull: false
+  # Rebuild docker image(s) even if already present
+  #force_rebuild: false
+  # Always require a reachable docker daemon, even if not required by runner
+  #require_docker: false
+  # Timeout to wait for the docker daemon to be reachable, if docker is required by require_docker or runner
+  #docker_timeout: 0s
+  # Mount the workspace from a host directory instead of a Docker volume, so jobs
+  # can bind-mount it by its own path into sibling containers (".:/app" in docker
+  # compose). Not needed when jobs get the Docker proxy or workflows use the
+  # GITEA_DOCKER_WORKSPACE variable.
+  # The workspace parent directory must be mounted into the runner container.
+  #bind_workdir: false
+  # How long a job waits for a service container that declares a healthcheck to become
+  # healthy. A negative value (e.g. -1s) starts the steps without waiting.
+  #service_ready_timeout: 5m
+
+host:
+  # The parent directory of a job's working directory.
+  # If it's empty, $HOME/.cache/act/ will be used.
+  #workdir_parent:
+
+# Optional local task-admission checks. Disabled by default. When enabled, low
+# disk space or a failing script pauses new task fetching; existing jobs continue.
+# No health checks run while any job is active; the last result is reused until idle.
+health_check:
+  #enabled: false
+  # Minimum free space required on the filesystem holding runner workspaces.
+  # Defaults to 1024 MiB when omitted or set to zero.
+  #min_free_disk_space_mb: 1024
+  # Optional additional executable. A non-zero exit, timeout, or startup failure
+  # marks the runner unavailable.
+  #script: ''
+  # How long a script result is cached and its maximum execution time.
+  #interval: 30s
+  #timeout: 10s
+
+metrics:
+  # Enable the Prometheus metrics endpoint.
+  # When enabled, metrics are served at /metrics, liveness at /healthz, and
+  # task-admission readiness at /readyz.
+  #enabled: false
+  # The address for the metrics HTTP server to listen on.
+  # Defaults to localhost only. Set to ":9101" to allow external access,
+  # but ensure the port is firewall-protected as there is no authentication.
+  #addr: "127.0.0.1:9101"
+  # Consecutive polling failures may last this long before /readyz returns 503.
+  #readiness_grace: 30s

ansible/roles/gitea/templates/docker-compose.yml

@@ -1,4 +1,3 @@
-
 networks:
   traefik:
     external: true
@@ -36,3 +35,16 @@ services:
       POSTGRESS_DB: gitea
     volumes:
       - "{{ data_dir }}/postgres/gitea:/var/lib/postgresql/data"
+
+  runner:
+    image: docker.io/gitea/runner:3
+    restart: unless-stopped
+    environment:
+      CONFIG_FILE: /config/config.yaml
+      GITEA_INSTANCE_URL: "https://git.{{ personal_domain }}"
+      GITEA_RUNNER_REGISTRATION_TOKEN: "{{ runner_registration_token }}"
+    volumes:
+      - "{{ data_dir }}/gitea/runner/config:/config"
+      - "{{ data_dir }}/gitea/runner/data:/data"
+      - /var/run/docker.sock:/var/run/docker.sock
+

ansible/roles/gitea/vars/main.yml

@@ -29,3 +29,13 @@ internal_token: !vault |
   62363962636132333266646431373162313261363635646166643462396161303635653338626431
   35626638386562386361383035623431306465623738616361346139343134643134613563343038
   38623638373335346533613536616136346638616465386637666463353234366237
+
+runner_registration_token: !vault |
+  $ANSIBLE_VAULT;1.1;AES256
+  64313833353738306166363964613936303966333837356133383161373830366365363934646532
+  3539343564386232373765643437393463383036323033630a353934353933316566343863303039
+  38666537613663656633646439323930333036613937656238356538316338346537303663626531
+  3632623339383237380a643361616566663334353935313733346236353237633163633835333164
+  36366635373236343666616230613033333733376264663761353731353662643163306137343066
+  3664343135613539306537306330376331396264373631316439
+

ansible/roles/lidarr/files/scripts_init.bash

@@ -1,5 +0,0 @@
-#!/usr/bin/with-contenv bash
-set -euo pipefail
-
-curl -sfL https://raw.githubusercontent.com/RandomNinjaAtk/arr-scripts/main/lidarr/setup.bash | bash
-exit

ansible/roles/lidarr/tasks/main.yml

@@ -26,29 +26,12 @@
 
 - name: Create data directory
   ansible.builtin.file:
-    path: "{{ data_dir }}/{{ item }}"
+    path: "{{ data_dir }}/{{ role_name }}/config"
     state: directory
     owner: "{{ service_user.uid }}"
     group: "{{ primary_gid }}"
     mode: "{{ docker_compose_directory_mask }}"
   become: true
-  loop:
-    - "{{ role_name }}/config"
-    - "{{ role_name }}/custom-services"
-    - "{{ role_name }}/custom-cont"
-
-- name: Copy arr-scripts init script
-  ansible.builtin.copy:
-    src: "scripts_init.bash"
-    dest: "{{ data_dir }}/{{ role_name }}/custom-cont"
-    owner: "{{ service_user.uid }}"
-    mode: 0564
-  become: true
-
-- name: Copy extended.conf
-  ansible.builtin.template:
-    src: "extended.conf"
-    dest: "{{ data_dir }}/{{ role_name }}/config"
 
 - name: Start docker container
   community.docker.docker_compose_v2:

ansible/roles/lidarr/templates/docker-compose.yml

@@ -17,9 +17,6 @@ services:
     volumes:
       - "{{ data_dir }}/{{ role_name }}/config:/config"
       - "{{ media_storage_mnt }}/data:/data"
-    # arr-scripts - https://github.com/RandomNinjaAtk/arr-scripts/blob/main/lidarr/readme.md
-      - "{{ data_dir }}/{{ role_name }}/custom-services:/custom-services.d"
-      - "{{ data_dir }}/{{ role_name }}/custom-cont:/custom-cont-init.d"
     labels:
       traefik.enable: true
       traefik.http.routers.{{ role_name }}.rule: "Host(`{{ role_name }}.local.{{ personal_domain }}`)"

ansible/roles/lidarr/templates/extended.conf

@@ -1,89 +0,0 @@
-##### LIDARR EXTENDED SCRIPTS SETTINGS #####
-
-##### PATHS
-downloadPath="/config/extended/downloads" # OPTIONAL, only change if needed.... Temporary Download Location for incoming Audio files from included clients
-importPath="/config/extended/import"      # OPTIONAL, only change if needed.... Completed downloads are stored here for the Usenet Blackhole client to import from. When Using queue cleaner, failed imports will be automatically cleaned up.
-videoPath=""                              # Final destination/location of completed Videos
-
-##### SCRIPT ENABLEMENT
-enableAutoConfig="true"            # true = enabled :: Automatically configures Lidarr with optimal settings
-enableAudio="true"                 # true = enabled :: Enables the Audio script to run automatically
-enableVideo="false"                 # true = enabled :: Enables the Video script to run automatically
-enableUnmappedFilesCleaner="false" # true = enabled :: Enables the UnmappedFilesCleaner script to run automatically
-enableQueueCleaner="true"          # true = enabled :: Enables the QueueCleaner script to run automatically
-
-##### SCRIPT INTERVALS
-audioScriptInterval=15m                 #s or #m or #h or #d :: s = seconds, m = minutes, h = hours, d = days :: Amount of time between each script run, when script is enabled
-videoScriptInterval=15m                 #s or #m or #h or #d :: s = seconds, m = minutes, h = hours, d = days :: Amount of time between each script run, when script is enabled
-autoArtistAdderInterval=12h             #s or #m or #h or #d :: s = seconds, m = minutes, h = hours, d = days :: Amount of time between each script run, when script is enabled
-unmappedFolderCleanerScriptInterval=15m #s or #m or #h or #d :: s = seconds, m = minutes, h = hours, d = days :: Amount of time between each script run, when script is enabled
-queueCleanerScriptInterval=15m          #s or #m or #h or #d :: s = seconds, m = minutes, h = hours, d = days :: Amount of time between each script run, when script is enabled
-
-##### AUTOCONFIG SCRIPT SETTINGS
-configureMediaManagement="true"               # Configures Lidarr Media Management Settings
-configureMetadataConsumerSettings="false"      # Configures Lidarr Metadata Consumer Settings
-configureMetadataProviderSettings="false"      # Configures Lidarr Metadata Provider Settings
-configureCustomScripts="true"                  # Adds custom scripts to Lidarr
-configureLidarrUiSettings="true"              # Configures Lidarr UI Settings
-configureMetadataProfileSettings="false"       # Configures Lidarr Metadata Profile Settings
-configureTrackNamingSettings="true"           # Configures Lidarr Track Naming Settings
-
-##### AUDIO SCRIPT
-# SEARCH
-searchSort="date"                 # date or album :: Sorts the missing/cutoff list by release date (newest -> oldest) or album type (album -> single) for processing the list
-matchDistance="3"                 # The number of changes required to transform the searched album title into a possible found album title match... (0, requires a perfect match)
-lidarrSearchForMissing="false"     # true = enabled :: When artists are added, search for them using Lidarr's built in functionality
-retryNotFound="90"                ## :: Number of days between re-attempting the download of previously notfound albums
-ignoreInstrumentalRelease="false" # true = enabled :: Skips albums releases that have the word "instrumental" in either the title or disambiguation
-preferSpecialEditions="true"      # true = enabled :: This changes the release title sort order, when true, it will search for releases with longest release names first, which are more likely to be deluxe/special versions...
-
-# CLIENT
-dlClientSource="deezer"                # deezer, tidal or both :: set to both, to use both clients, tidal requires extra steps, view logging output
-arlToken="{{ deezer_arl }}"                            # OPTIONAL (fallback using Freyr) - User ARL token for deemix client
-tidalCountryCode="US"                  # Country Code required for tidal
-failedDownloadAttemptThreshold="6"     # Maximum number of attempts to download a particular album ID from the service before considering it a failed download...
-deezerClientTestDownloadId="197472472" # A known good deezer track id that is used to test/verify the client is functioning in the event all download attempts have failed. Prevents the script from exiting...
-tidalClientTestDownloadId="166356219"  # A known good tidal track id that is used to test/verify the client is functioning in the event all download attempts have failed. Prevents the script from exiting...
-downloadClientTimeOut="10m"            # 's' for seconds (the default), 'm' for minutes, 'h' for hours or 'd' for days :: Kills freyr download client after the set timeout period, prevents lock ups...
-
-# QUALITY
-audioLyricType="both"   # both or explicit or clean :: both, is explicit preferred matching, explicit is explicit releases only matching and clean is clean releases only matching
-audioFormat="native"    # native or alac or mp3 or aac or opus :: native is the native download client file type, selected by the matching audio bit-rate
-audioBitrate="lossless" # master or lossless or high or low or ### :: master = MQA/lossless flac files, lossless = flac files, high = 320K, low = 128k/96k, ### = the output bit-rate of converted lossless files to selected audioFormat that is not native, example: 192...
-requireQuality="true"  # true = enabled :: Downloads will be checked for quality and require to have the requested file format & quality
-
-# POST PROCESSING
-enableBeetsTagging="true"   # true = enabled :: Downloads will be processed and tagged by Beets
-beetsMatchPercentage="90"   # 1-100 :: Set this to the minimum percentage required for Beets to match the downloaded album to a musicbrainz release :: Lower percentage is less restrictive
-enableReplaygainTags="true" # true = enabled :: Downloads will be tagged with ReplayGain Metadata
-
-# ADD ARTIST AUTOMATION
-addDeezerTopArtists="false"              # true = enabled :: Enabling this will enable the extended script to automatically add artists that are on the Deezer Top Artist Chart to your existing Lidarr instance
-addDeezerTopAlbumArtists="false"         # true = enabled :: Enabling this will enable the extended script to automatically add artists that are on the Deezer Top Album Chart to your existing Lidarr instance
-addDeezerTopTrackArtists="false"         # true = enabled :: Enabling this will enable the extended script to automatically add artists that are on the Deezer Top Track Chart to your existing Lidarr instance
-topLimit="3"                             # This setting controls the amount of Top Artist (Albums/Tracks/Artists) to add to Lidarr from Deezer
-addRelatedArtists="false"                # true = enabled :: WARNING !!! WARNING !!! Enabling this can cause an endless loop of additional artists.... Enabling this will enable the extended script to automatically add artists that are related to your existing Lidarr artists from Tidal & Deezer
-numberOfRelatedArtistsToAddPerArtist="1" # 1-20 :: This will limit the number of related artists to add per artist in your library :: Minimum is 1, Maximum is 20
-autoArtistAdderMonitored="true"          # true or false :: If true, artists that are added automatically are monitored, when false they are added in an unmonitored state
-preventRelatedArtistsLoop="true"         # true = enabled :: This will prevent added related artists from adding additional related artists, thus killing an endless loop. This works by using the Lidarr's tag system (arr-extended), Remove tag from artist to allow it to be proessed for related artists...
-
-##### VIDEO SCRIPT
-addFeaturedVideoArtists="false"  # true = enabled :: WARNING !!! WARNING !!! Enabling this can cause an endless loop of additional artists.... Enabling this will enable the extended Video script to automatically add Music Video Featured Artists to your existing Lidarr artists from IMVDB
-videoFormat="bv[width>=1920]+ba" # ONLY CHANGE if you know what your doing, for guidence, please see yt-dlp documentation.
-videoInfoJson="false"            # true = enabled :: Stores yt-dlp info-json files alongside video files.
-youtubeSubtitleLanguage="en"     # Desired Language Code :: For guidence, please see yt-dlp documentation.
-disableImvd="false"              # true = enabled :: Use this to disable IMVDB as a source, will result in only tidal videos
-
-##### DEEZER ARLCHECKER
-arlUpdateInterval="24h"   # Interval to check ARL Validity (default 24 hours). Reboot container after changing. s = seconds, m = minutes, h = hours, d = days
-telegramBotEnable="false" # Enable/Disable  Telegram Bot to notify if ARL expires. Otherwise check text file in custom-services.d/python for status.
-telegramBotToken=""       # Get token from BotFather during bot creation. If you use a notify channel for Lidarr, you can probably use the same bot, as this script only takes temporary control.
-telegramUserChatID=""     # Get your userid by chatting: t.me/userinfobot
-pushoverEnable="false"    # Pushover Notification Support
-pushoverUserKey=""
-pushoverAppAPIKey=""
-ntfyEnable="false"        # ntfy Notification Support
-ntfyServerTopic=""        # Put your server + topic address ex: https://ntfy.mydomain.com/lidarr
-ntfyUserToken=""          # create a new user token using the ntfy cli commands. See ntfy documentation on how to do that.
-
-

ansible/roles/tautulli/files/kill_stream.py

@@ -1,639 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-Description: Use conditions to kill a stream
-Author: Blacktwin, Arcanemagus, Samwiseg0, JonnyWong16, DirtyCajunRice
-
-Adding the script to Tautulli:
-Tautulli > Settings > Notification Agents > Add a new notification agent >
- Script
-
-Configuration:
-Tautulli > Settings > Notification Agents > New Script > Configuration:
-
- Script Folder: /path/to/your/scripts
- Script File: ./kill_stream.py (Should be selectable in a dropdown list)
- Script Timeout: {timeout}
- Description: Kill stream(s)
- Save
-
-Triggers:
-Tautulli > Settings > Notification Agents > New Script > Triggers:
-
- Check: Playback Start and/or Playback Pause
- Save
-
-Conditions:
-Tautulli > Settings > Notification Agents > New Script > Conditions:
-
- Set Conditions: [{condition} | {operator} | {value} ]
- Save
-
-Script Arguments:
-Tautulli > Settings > Notification Agents > New Script > Script Arguments:
-
- Select: Playback Start, Playback Pause
- Arguments: --jbop SELECTOR --userId {user_id} --username {username}
-            --sessionId {session_id} --notify notifierID
-            --interval 30 --limit 1200
-            --richMessage RICH_TYPE --serverName {server_name}
-            --plexUrl {plex_url} --posterUrl {poster_url}
-            --richColor '#E5A00D'
-            --killMessage 'Your message here.'
-
- Save
- Close
-"""
-from __future__ import print_function
-from __future__ import unicode_literals
-
-
-from builtins import object
-from builtins import str
-import os
-import sys
-import json
-import time
-import argparse
-from datetime import datetime
-from requests import Session
-from requests.adapters import HTTPAdapter
-from requests.exceptions import RequestException
-
-
-TAUTULLI_URL = ''
-TAUTULLI_APIKEY = ''
-TAUTULLI_PUBLIC_URL = ''
-TAUTULLI_URL = os.getenv('TAUTULLI_URL', TAUTULLI_URL)
-TAUTULLI_PUBLIC_URL = os.getenv('TAUTULLI_PUBLIC_URL', TAUTULLI_PUBLIC_URL)
-TAUTULLI_APIKEY = os.getenv('TAUTULLI_APIKEY', TAUTULLI_APIKEY)
-TAUTULLI_ENCODING = os.getenv('TAUTULLI_ENCODING', 'UTF-8')
-VERIFY_SSL = False
-
-if TAUTULLI_PUBLIC_URL != '/':
-    # Check to see if there is a public URL set in Tautulli
-    TAUTULLI_LINK = TAUTULLI_PUBLIC_URL
-else:
-    TAUTULLI_LINK = TAUTULLI_URL
-
-SUBJECT_TEXT = "Tautulli has killed a stream."
-BODY_TEXT = "Killed session ID '{id}'. Reason: {message}"
-BODY_TEXT_USER = "Killed {user}'s stream. Reason: {message}."
-
-
-SELECTOR = ['stream', 'allStreams', 'paused']
-
-RICH_TYPE = ['discord', 'slack']
-
-TAUTULLI_ICON = 'https://github.com/Tautulli/Tautulli/raw/master/data/interfaces/default/images/logo-circle.png'
-
-
-def utc_now_iso():
-    """Get current time in ISO format"""
-    utcnow = datetime.utcnow()
-
-    return utcnow.isoformat()
-
-
-def hex_to_int(value):
-    """Convert hex value to integer"""
-    try:
-        return int(value, 16)
-    except (ValueError, TypeError):
-        return 0
-
-
-def arg_decoding(arg):
-    """Decode args, encode UTF-8"""
-    if sys.version_info[0] < 3:
-        return arg.decode(TAUTULLI_ENCODING).encode('UTF-8')
-    else:
-        return arg
-
-
-def debug_dump_vars():
-    """Dump parameters for debug"""
-    print('Tautulli URL - ' + TAUTULLI_URL)
-    print('Tautulli Public URL - ' + TAUTULLI_PUBLIC_URL)
-    print('Verify SSL - ' + str(VERIFY_SSL))
-    print('Tautulli API key - ' + TAUTULLI_APIKEY[-4:]
-          .rjust(len(TAUTULLI_APIKEY), "x"))
-
-
-def get_all_streams(tautulli, user_id=None):
-    """Get a list of all current streams.
-
-    Parameters
-    ----------
-    user_id : int
-        The ID of the user to grab sessions for.
-    tautulli : obj
-        Tautulli object.
-    Returns
-    -------
-    objects
-        The of stream objects.
-    """
-    sessions = tautulli.get_activity()['sessions']
-
-    if user_id:
-        streams = [Stream(session=s) for s in sessions if s['user_id'] == user_id]
-    else:
-        streams = [Stream(session=s) for s in sessions]
-
-    return streams
-
-
-def notify(all_opts, message, kill_type=None, stream=None, tautulli=None):
-    """Decides which notifier type to use"""
-    if all_opts.notify and all_opts.richMessage:
-        rich_notify(all_opts.notify, all_opts.richMessage, all_opts.richColor, kill_type,
-                    all_opts.serverName, all_opts.plexUrl, all_opts.posterUrl, message, stream, tautulli)
-    elif all_opts.notify:
-        basic_notify(all_opts.notify, all_opts.sessionId, all_opts.username, message, stream, tautulli)
-
-
-def rich_notify(notifier_id, rich_type, color=None, kill_type=None, server_name=None,
-                plex_url=None, poster_url=None, message=None, stream=None, tautulli=None):
-    """Decides which rich notifier type to use. Set default values for empty variables
-
-    Parameters
-    ----------
-    notifier_id : int
-        The ID of the user to grab sessions for.
-    rich_type : str
-        Contains 'discord' or 'slack'.
-    color : Union[int, str]
-        Hex string or integer representation of color.
-    kill_type : str
-        The kill type used.
-    server_name : str
-        The name of the plex server.
-    plex_url : str
-        Plex media URL.
-    poster_url : str
-        The media poster URL.
-    message : str
-        Message sent to the client.
-    stream : obj
-        Stream object.
-    tautulli : obj
-        Tautulli object.
-    """
-    notification = Notification(notifier_id, None, None, tautulli, stream)
-    # Initialize Variables
-    title = ''
-    footer = ''
-    # Set a default server_name if none is provided
-    if server_name is None:
-        server_name = 'Plex Server'
-
-    # Set a default color if none is provided
-    if color is None:
-        color = '#E5A00D'
-
-    # Set a default plexUrl if none is provided
-    if plex_url is None:
-        plex_url = 'https://app.plex.tv'
-
-    # Set a default posterUrl if none is provided
-    if poster_url is None:
-        poster_url = TAUTULLI_ICON
-
-    # Set a default message if none is provided
-    if message is None:
-        message = 'The server owner has ended the stream.'
-
-    if kill_type == 'Stream':
-        title = "Killed {}'s stream.".format(stream.friendly_name)
-        footer = '{} | Kill {}'.format(server_name, kill_type)
-
-    elif kill_type == 'Paused':
-        title = "Killed {}'s paused stream.".format(stream.friendly_name)
-        footer = '{} | Kill {}'.format(server_name, kill_type)
-
-    elif kill_type == 'All Streams':
-        title = "Killed {}'s stream.".format(stream.friendly_name)
-        footer = '{} | Kill {}'.format(server_name, kill_type)
-        poster_url = TAUTULLI_ICON
-        plex_url = 'https://app.plex.tv'
-
-    if rich_type == 'discord':
-        color = hex_to_int(color.lstrip('#'))
-        notification.send_discord(title, color, poster_url, plex_url, message, footer)
-
-    elif rich_type == 'slack':
-        notification.send_slack(title, color, poster_url, plex_url, message, footer)
-
-
-def basic_notify(notifier_id, session_id, username=None, message=None, stream=None, tautulli=None):
-    """Basic notifier"""
-    notification = Notification(notifier_id, SUBJECT_TEXT, BODY_TEXT, tautulli, stream)
-
-    if username:
-        body = BODY_TEXT_USER.format(user=username,
-                                     message=message)
-    else:
-        body = BODY_TEXT.format(id=session_id, message=message)
-    notification.send(SUBJECT_TEXT, body)
-
-
-class Tautulli(object):
-    def __init__(self, url, apikey, verify_ssl=False, debug=None):
-        self.url = url
-        self.apikey = apikey
-        self.debug = debug
-
-        self.session = Session()
-        self.adapters = HTTPAdapter(max_retries=3,
-                                    pool_connections=1,
-                                    pool_maxsize=1,
-                                    pool_block=True)
-        self.session.mount('http://', self.adapters)
-        self.session.mount('https://', self.adapters)
-
-        # Ignore verifying the SSL certificate
-        if verify_ssl is False:
-            self.session.verify = False
-            # Disable the warning that the request is insecure, we know that...
-            import urllib3
-            urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-
-    def _call_api(self, cmd, payload, method='GET'):
-        payload['cmd'] = cmd
-        payload['apikey'] = self.apikey
-
-        try:
-            response = self.session.request(method, self.url + '/api/v2', params=payload)
-        except RequestException as e:
-            print("Tautulli request failed for cmd '{}'. Invalid Tautulli URL? Error: {}".format(cmd, e))
-            if self.debug:
-                traceback.print_exc()
-            return
-
-        try:
-            response_json = response.json()
-        except ValueError:
-            print(
-                "Failed to parse json response for Tautulli API cmd '{}': {}"
-                .format(cmd, response.content))
-            return
-
-        if response_json['response']['result'] == 'success':
-            if self.debug:
-                print("Successfully called Tautulli API cmd '{}'".format(cmd))
-            return response_json['response']['data']
-        else:
-            error_msg = response_json['response']['message']
-            print("Tautulli API cmd '{}' failed: {}".format(cmd, error_msg))
-            return
-
-    def get_activity(self, session_key=None, session_id=None):
-        """Call Tautulli's get_activity api endpoint"""
-        payload = {}
-
-        if session_key:
-            payload['session_key'] = session_key
-        elif session_id:
-            payload['session_id'] = session_id
-
-        return self._call_api('get_activity', payload)
-
-    def notify(self, notifier_id, subject, body):
-        """Call Tautulli's notify api endpoint"""
-        payload = {'notifier_id': notifier_id,
-                   'subject': subject,
-                   'body': body}
-
-        return self._call_api('notify', payload)
-
-    def terminate_session(self, session_key=None, session_id=None, message=''):
-        """Call Tautulli's terminate_session api endpoint"""
-        payload = {}
-
-        if session_key:
-            payload['session_key'] = session_key
-        elif session_id:
-            payload['session_id'] = session_id
-
-        if message:
-            payload['message'] = message
-
-        return self._call_api('terminate_session', payload)
-
-
-class Stream(object):
-    def __init__(self, session_id=None, user_id=None, username=None, tautulli=None, session=None):
-        self.state = None
-        self.ip_address = None
-        self.session_id = session_id
-        self.user_id = user_id
-        self.username = username
-        self.session_exists = False
-        self.tautulli = tautulli
-
-        if session is not None:
-            self._set_stream_attributes(session)
-
-    def _set_stream_attributes(self, session):
-        for k, v in session.items():
-            setattr(self, k, v)
-
-    def get_all_stream_info(self):
-        """Get all stream info from Tautulli."""
-        session = self.tautulli.get_activity(session_id=self.session_id)
-        if session:
-            self._set_stream_attributes(session)
-            self.session_exists = True
-        else:
-            self.session_exists = False
-
-    def terminate(self, message=''):
-        """Calls Tautulli to terminate the session.
-
-        Parameters
-        ----------
-        message : str
-            The message to use if the stream is terminated.
-        """
-        self.tautulli.terminate_session(session_id=self.session_id, message=message)
-
-    def terminate_long_pause(self, message, limit, interval):
-        """Kills the session if it is paused for longer than <limit> seconds.
-
-        Parameters
-        ----------
-        message : str
-            The message to use if the stream is terminated.
-        limit : int
-            The number of seconds the session is allowed to remain paused before it
-            is terminated.
-        interval : int
-            The amount of time to wait between checks of the session state.
-        """
-        start = datetime.now()
-        checked_time = 0
-        # Continue checking 2 intervals past the allowed limit in order to
-        # account for system variances.
-        check_limit = limit + (interval * 2)
-
-        while checked_time < check_limit:
-            self.get_all_stream_info()
-
-            if self.session_exists is False:
-                sys.stdout.write(
-                    "Session '{}'  from user '{}' is no longer active "
-                    .format(self.session_id, self.username) +
-                    "on the server, stopping monitoring.\n")
-                return False
-
-            now = datetime.now()
-            checked_time = (now - start).total_seconds()
-
-            if self.state == 'paused':
-                if checked_time >= limit:
-                    self.terminate(message)
-                    sys.stdout.write(
-                        "Session '{}' from user '{}' has been killed.\n"
-                        .format(self.session_id, self.username))
-                    return True
-                else:
-                    time.sleep(interval)
-
-            elif self.state == 'playing' or self.state == 'buffering':
-                sys.stdout.write(
-                    "Session '{}' from user '{}' has been resumed, "
-                    .format(self.session_id, self.username) +
-                    "stopping monitoring.\n")
-                return False
-
-
-class Notification(object):
-    def __init__(self, notifier_id, subject, body, tautulli, stream):
-        self.notifier_id = notifier_id
-        self.subject = subject
-        self.body = body
-
-        self.tautulli = tautulli
-        self.stream = stream
-
-    def send(self, subject='', body=''):
-        """Send to Tautulli notifier.
-
-        Parameters
-        ----------
-        subject : str
-            Subject of the message.
-        body : str
-            Body of the message.
-        """
-        subject = subject or self.subject
-        body = body or self.body
-        self.tautulli.notify(notifier_id=self.notifier_id, subject=subject, body=body)
-
-    def send_discord(self, title, color, poster_url, plex_url, message, footer):
-        """Build the Discord message.
-
-        Parameters
-        ----------
-        title : str
-            The title of the message.
-        color : int
-            The color of the message
-        poster_url : str
-            The media poster URL.
-        plex_url : str
-            Plex media URL.
-        message : str
-            Message sent to the player.
-        footer : str
-            Footer of the message.
-        """
-        discord_message = {
-            "embeds": [
-                {
-                    "author": {
-                        "icon_url": TAUTULLI_ICON,
-                        "name": "Tautulli",
-                        "url": TAUTULLI_LINK.rstrip('/')
-                    },
-                    "color": color,
-                    "fields": [
-                        {
-                            "inline": True,
-                            "name": "User",
-                            "value": self.stream.friendly_name
-                        },
-                        {
-                            "inline": True,
-                            "name": "Session Key",
-                            "value": self.stream.session_key
-                        },
-                        {
-                            "inline": True,
-                            "name": "Watching",
-                            "value": self.stream.full_title
-                        },
-                        {
-                            "inline": False,
-                            "name": "Message Sent",
-                            "value": message
-                        }
-                    ],
-                    "thumbnail": {
-                        "url": poster_url
-                    },
-                    "title": title,
-                    "timestamp": utc_now_iso(),
-                    "url": plex_url,
-                    "footer": {
-                        "text": footer
-                    }
-
-                }
-
-            ],
-        }
-
-        discord_message = json.dumps(discord_message, sort_keys=True,
-                                     separators=(',', ': '))
-        self.send(body=discord_message)
-
-    def send_slack(self, title, color, poster_url, plex_url, message, footer):
-        """Build the Slack message.
-
-        Parameters
-        ----------
-        title : str
-            The title of the message.
-        color : int
-            The color of the message
-        poster_url : str
-            The media poster URL.
-        plex_url : str
-            Plex media URL.
-        message : str
-            Message sent to the player.
-        footer : str
-            Footer of the message.
-        """
-        slack_message = {
-            "attachments": [
-                {
-                    "title": title,
-                    "title_link": plex_url,
-                    "author_icon": TAUTULLI_ICON,
-                    "author_name": "Tautulli",
-                    "author_link": TAUTULLI_LINK.rstrip('/'),
-                    "color": color,
-                    "fields": [
-                        {
-                            "title": "User",
-                            "value": self.stream.friendly_name,
-                            "short": True
-                        },
-                        {
-                            "title": "Session Key",
-                            "value": self.stream.session_key,
-                            "short": True
-                        },
-                        {
-                            "title": "Watching",
-                            "value": self.stream.full_title,
-                            "short": True
-                        },
-                        {
-                            "title": "Message Sent",
-                            "value": message,
-                            "short": False
-                        }
-                    ],
-                    "thumb_url": poster_url,
-                    "footer": footer,
-                    "ts": time.time()
-                }
-
-            ],
-        }
-
-        slack_message = json.dumps(slack_message, sort_keys=True,
-                                   separators=(',', ': '))
-        self.send(body=slack_message)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Killing Plex streams from Tautulli.")
-    parser.add_argument('--jbop', required=True, choices=SELECTOR,
-                        help='Kill selector.\nChoices: (%(choices)s)')
-    parser.add_argument('--userId', type=int,
-                        help='The unique identifier for the user.')
-    parser.add_argument('--username', type=arg_decoding,
-                        help='The username of the person streaming.')
-    parser.add_argument('--sessionId',
-                        help='The unique identifier for the stream.')
-    parser.add_argument('--notify', type=int,
-                        help='Notification Agent ID number to Agent to ' +
-                        'send notification.')
-    parser.add_argument('--limit', type=int, default=(20 * 60),  # 20 minutes
-                        help='The time session is allowed to remain paused.')
-    parser.add_argument('--interval', type=int, default=30,
-                        help='The seconds between paused session checks.')
-    parser.add_argument('--killMessage', nargs='+', type=arg_decoding,
-                        help='Message to send to user whose stream is killed.')
-    parser.add_argument('--richMessage', type=arg_decoding, choices=RICH_TYPE,
-                        help='Rich message type selector.\nChoices: (%(choices)s)')
-    parser.add_argument('--serverName', type=arg_decoding,
-                        help='Plex Server Name')
-    parser.add_argument('--plexUrl', type=arg_decoding,
-                        help='URL to plex media')
-    parser.add_argument('--posterUrl', type=arg_decoding,
-                        help='Poster URL of the media')
-    parser.add_argument('--richColor', type=arg_decoding,
-                        help='Color of the rich message')
-    parser.add_argument("--debug", action='store_true',
-                        help='Enable debug messages.')
-
-    opts = parser.parse_args()
-
-    if not opts.sessionId and opts.jbop != 'allStreams':
-        sys.stderr.write("No sessionId provided! Is this synced content?\n")
-        sys.exit(1)
-
-    if opts.debug:
-        # Import traceback to get more detailed information
-        import traceback
-        # Dump the ENVs passed from tautulli
-        debug_dump_vars()
-
-    # Create a Tautulli instance
-    tautulli_server = Tautulli(TAUTULLI_URL.rstrip('/'), TAUTULLI_APIKEY, VERIFY_SSL, opts.debug)
-
-    # Create initial Stream object with basic info
-    tautulli_stream = Stream(opts.sessionId, opts.userId, opts.username, tautulli_server)
-
-    # Only pull all stream info if using richMessage
-    if opts.notify and opts.richMessage:
-        tautulli_stream.get_all_stream_info()
-
-    # Set a default message if none is provided
-    if opts.killMessage:
-        kill_message = ' '.join(opts.killMessage)
-    else:
-        kill_message = 'The server owner has ended the stream.'
-
-    if opts.jbop == 'stream':
-        tautulli_stream.terminate(kill_message)
-        notify(opts, kill_message, 'Stream', tautulli_stream, tautulli_server)
-
-    elif opts.jbop == 'allStreams':
-        all_streams = get_all_streams(tautulli_server, opts.userId)
-        for a_stream in all_streams:
-            tautulli_server.terminate_session(session_id=a_stream.session_id, message=kill_message)
-            notify(opts, kill_message, 'All Streams', a_stream, tautulli_server)
-
-    elif opts.jbop == 'paused':
-        killed_stream = tautulli_stream.terminate_long_pause(kill_message, opts.limit, opts.interval)
-        if killed_stream:
-            notify(opts, kill_message, 'Paused', tautulli_stream, tautulli_server)

ansible/roles/tautulli/templates/docker-compose.yml

@@ -1,22 +0,0 @@
-
-networks:
-  traefik:
-    external: true
-
-services:
-  tautulli:
-    container_name: "tautulli"
-    image: lscr.io/linuxserver/tautulli:latest
-    restart: unless-stopped
-    networks:
-      - traefik
-    environment:
-      - "PUID={{ service_user.uid }}"
-      - "PGID={{ service_user.uid }}"
-      - "TZ={{ timezone }}"
-    volumes:
-      - "{{ data_dir }}/{{ role_name }}:/config"
-    labels:
-      traefik.enable: true
-      traefik.http.routers.tautulli.rule: "Host(`tautulli.local.{{ personal_domain }}`)"
-      traefik.http.routers.tautulli.middlewares: lan-whitelist@file

ansible/roles/tracearr/tasks/main.yml

@@ -0,0 +1,22 @@
+- name: Create install directory
+  file:
+    path: "{{ install_directory }}/{{ role_name }}"
+    state: directory
+    owner: "{{ docker_user }}"
+    mode: "{{ docker_compose_directory_mask }}"
+  become: true
+
+- name: Copy docker-compose file to destination
+  template:
+    src: docker-compose.yml
+    dest: "{{ install_directory }}/{{ role_name }}/docker-compose.yml"
+    owner: "{{ docker_user }}"
+    mode: "{{ docker_compose_file_mask }}"
+    validate: docker compose -f %s config
+  become: true
+
+- name: Start docker container
+  community.docker.docker_compose_v2:
+    project_src: "{{ install_directory }}/{{ role_name }}"
+    pull: always
+    remove_orphans: yes

ansible/roles/tracearr/templates/docker-compose.yml

@@ -0,0 +1,19 @@
+networks:
+  traefik:
+    external: true
+
+services:
+  tracearr:
+    container_name: "tracearr"
+    image: ghcr.io/connorgallopo/tracearr:supervised
+    restart: unless-stopped
+    networks:
+      - traefik
+    environment:
+      - "TZ={{ timezone }}"
+    volumes:
+      - "{{ data_dir }}/{{ role_name }}:/data"
+    labels:
+      traefik.enable: true
+      traefik.http.routers.tracearr.rule: "Host(`{{ role_name }}.local.{{ personal_domain }}`)"
+      traefik.http.routers.tracearr.middlewares: lan-whitelist@file

ansible/roles/traefik/templates/conf/file-provider-lubelogger.yml

@@ -0,0 +1,11 @@
+http:
+  routers:
+    router-lubelogger:
+      rule: "Host(`lubelogger.local.{{ personal_domain }}`)"
+      service: service-lubelogger
+
+  services:
+    service-lubelogger:
+      loadBalancer:
+        servers:
+          - url: http://arch-web:5000

ansible/roles/traefik/templates/conf/file-provider-redlib.yml

@@ -0,0 +1,11 @@
+http:
+  routers:
+    router-redlib:
+      rule: "Host(`redlib.local.{{ personal_domain }}`)"
+      service: service-redlib
+
+  services:
+    service-redlib:
+      loadBalancer:
+        servers:
+          - url: http://arch-web:13225

ansible/roles/traefik/templates/docker-compose.yml

@@ -7,7 +7,7 @@ networks:
 services:
   traefik:
     container_name: traefik
-    image: traefik:v3.1
+    image: traefik:latest
     depends_on:
       docker_socket_proxy:
         condition: service_healthy