Tasks

main.yml

Synopsis: Main task.

Import tasks if enabled.

[tasks/main.yml]

---
# linux_postinstall tasks

- name: Import vars.yml
  ansible.builtin.import_tasks: vars.yml
  tags: [lp_vars, always]

- name: Import debug.yml
  ansible.builtin.import_tasks: debug.yml
  when: lp_debug | bool
  tags: [lp_debug, always]

- name: Import swap.yml
  ansible.builtin.import_tasks: swap.yml
  when: ((ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')) and lp_swap | bool
  tags: lp_swap

- name: Import modules.yml
  ansible.builtin.import_tasks: modules.yml
  when: (ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')
  tags: lp_modules

- name: Import udev.yml
  ansible.builtin.import_tasks: udev.yml
  when: ((ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')) and lp_udev | bool
  tags: lp_udev

- name: Import fstab.yml
  ansible.builtin.import_tasks: fstab.yml
  when: ((ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian'))
  tags: lp_fstab

- name: Import networkmanager.yml
  ansible.builtin.import_tasks: networkmanager.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_nm | bool
  tags: lp_nm

- name: Import netplan.yml
  ansible.builtin.import_tasks: netplan.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_netplan | bool
  tags: lp_netplan

- name: Import systemd.yml
  ansible.builtin.import_tasks: systemd.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_systemd | bool
  tags: lp_systemd

- name: Import networkd.yml
  ansible.builtin.import_tasks: networkd.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_networkd | bool
  tags: lp_networkd

- name: Import timezone.yml
  ansible.builtin.import_tasks: timezone.yml
  when: ((ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')) and lp_timezone | bool
  tags: lp_timezone

- name: Import timesyncd.yml
  ansible.builtin.import_tasks: timesyncd.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_timesyncd | bool
  tags: lp_timesyncd

- name: Import chrony.yml
  ansible.builtin.import_tasks: chrony.yml
  when: ((ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')) and lp_chrony | bool
  tags: lp_chrony

- name: Import apt.yml
  ansible.builtin.import_tasks: apt.yml
  when: ansible_facts['os_family'] == 'Debian' and lp_apt | bool
  tags: lp_apt

- name: Import snap.yml
  ansible.builtin.import_tasks: snap.yml
  when: ansible_facts['os_family'] == 'Debian' and lp_snap | bool
  tags: lp_snap

- name: Import repos.yml
  ansible.builtin.import_tasks: repos.yml
  when: ansible_facts['os_family'] == 'Debian'
  tags: lp_repos

- name: Import packages.yml
  ansible.builtin.import_tasks: packages.yml
  when: (ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')
  tags: lp_packages

- name: Import upgrades.yml
  ansible.builtin.import_tasks: auto_upgrades.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_auto_upgrades | bool
  tags: lp_auto_upgrades

- name: Import sysctl.yml
  ansible.builtin.import_tasks: sysctl.yml
  when: (ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')
  tags: lp_sysctl

- name: Import zfs.yml
  ansible.builtin.import_tasks: zfs.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_zfs | bool
  tags: lp_zfs

- name: Import hostname.yml
  ansible.builtin.import_tasks: hostname.yml
  when: (ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')
  tags: lp_hostname

- name: Import hosts.yml
  ansible.builtin.import_tasks: hosts.yml
  when: (ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')
  tags: lp_hosts

- name: Import iptables.yml
  ansible.builtin.import_tasks: iptables.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_iptables | bool
  tags: lp_iptables

- name: Import grub.yml
  ansible.builtin.import_tasks: grub.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_grub | bool
  tags: lp_grub
  # https://unix.stackexchange.com/questions/152222/
  # equivalent-of-update-grub-for-rhel-fedora-centos-systems

- name: Import groups.yml
  ansible.builtin.import_tasks: groups.yml
  when: (ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')
  tags: lp_groups

- name: Import users.yml
  ansible.builtin.import_tasks: users.yml
  when: (ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')
  tags: lp_users

- name: Import gpg.yml
  ansible.builtin.import_tasks: gpg.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_gpg | bool
  tags: lp_gpg

- name: Import passwords.yml
  ansible.builtin.import_tasks: passwords.yml
  when: (ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian') and lp_passwords | bool
  tags: lp_passwords

- name: Import sudoers.yml
  ansible.builtin.import_tasks: sudoers.yml
  when: (ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')
  tags: lp_sudoers

- name: Import keys.yml
  ansible.builtin.import_tasks: authorized_keys.yml
  when: (ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')
  tags: lp_authorized_keys

- name: Import aliases.yml
  ansible.builtin.import_tasks: aliases.yml
  when: ((ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')) and lp_aliases | bool
  tags: lp_aliases

- name: Import utils.yml
  ansible.builtin.import_tasks: pm_utils.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_pm | bool
  tags: lp_pm

- name: Import ssh.yml
  ansible.builtin.import_tasks: ssh.yml
  when: ((ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')) and lp_ssh | bool
  tags: lp_ssh

- name: Import sshd.yml
  ansible.builtin.import_tasks: sshd.yml
  when: ((ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')) and lp_sshd | bool
  tags: lp_sshd

- name: Import bluetooth.yml
  ansible.builtin.import_tasks: bluetooth.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_bluetooth | bool
  tags: lp_bluetooth

- name: Import xorg.yml
  ansible.builtin.import_tasks: xorg.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_xorg | bool
  tags: lp_xorg

- name: Import cron.yml
  ansible.builtin.import_tasks: cron.yml
  when: (ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')
  tags: lp_cron

- name: Import modemmanager.yml
  ansible.builtin.import_tasks: modemmanager.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_modemmanager | bool
  tags: lp_modemmanager

- name: Import gpsd.yml
  ansible.builtin.import_tasks: gpsd.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_gpsd | bool
  tags: lp_gpsd

- name: Import postfix.yml
  ansible.builtin.import_tasks: postfix.yml
  when: ((ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')) and lp_postfix | bool
  tags: lp_postfix

- name: Import smart.yml
  ansible.builtin.import_tasks: smart.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_smart | bool
  tags: lp_smart

- name: Import apparmor.yml
  ansible.builtin.import_tasks: apparmor.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_apparmor | bool
  tags: lp_apparmor

- name: Flush handlers
  ansible.builtin.meta: flush_handlers

- name: Import zeitgeist.yml
  ansible.builtin.import_tasks: zeitgeist.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_zeitgeist | bool
  tags: lp_zeitgeist

- name: Import lid.yml
  ansible.builtin.import_tasks: lid.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_lid | bool
  tags: lp_lid

- name: Import acpi.yml
  ansible.builtin.import_tasks: acpi.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_acpi | bool
  tags: lp_acpi

- name: Import speechd.yml
  ansible.builtin.import_tasks: speechd.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_speechd | bool
  tags: lp_speechd

- name: Import nfsd.yml
  ansible.builtin.import_tasks: nfsd.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_nfsd | bool
  tags: lp_nfsd

- name: Flush handlers
  ansible.builtin.meta: flush_handlers
- name: Import latex.yml
  ansible.builtin.import_tasks: latex.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_latex | bool
  tags: lp_latex

- name: Import kvm.yml
  ansible.builtin.import_tasks: kvm.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_kvm | bool
  tags: lp_kvm

- name: Import xen.yml
  ansible.builtin.import_tasks: xen.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_xen | bool
  tags: lp_xen

- name: Import virtualbox.yml
  ansible.builtin.import_tasks: virtualbox.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_virtualbox | bool
  tags: lp_virtualbox

- name: Import wpagui.yml
  ansible.builtin.import_tasks: wpagui.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_wpagui | bool
  tags: lp_wpagui

- name: Import wpasupplicant.yml
  ansible.builtin.import_tasks: wpasupplicant.yml
  when: ((ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')) and lp_wpasupplicant | bool
  tags: lp_wpasupplicant

- name: Import logrotate.yml
  ansible.builtin.import_tasks: logrotate.yml
  when: ((ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')) and lp_logrotate | bool
  tags: lp_logrotate

- name: Import tlp.yml
  ansible.builtin.import_tasks: tlp.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_tlp | bool
  tags: lp_tlp

- name: Import autofs.yml
  ansible.builtin.import_tasks: autofs.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_autofs | bool
  tags: lp_autofs

- name: Import libvirt.yml
  ansible.builtin.import_tasks: libvirt.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_libvirt | bool
  tags: lp_libvirt

- name: Import ufw.yml
  ansible.builtin.import_tasks: ufw.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_ufw | bool
  tags: lp_ufw

- name: Import debsums.yml
  ansible.builtin.import_tasks: debsums.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_debsums | bool
  tags: lp_debsums

- name: Flush handlers
  ansible.builtin.meta: flush_handlers
- name: Import rc_local.yml
  ansible.builtin.import_tasks: rc_local.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_rc_local | bool
  tags: lp_rc_local

- name: Import resolvconf.yml
  ansible.builtin.import_tasks: resolvconf.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_resolvconf | bool
  tags: lp_resolvconf

- name: Import dnsmasq.yml
  ansible.builtin.import_tasks: dnsmasq.yml
  when: (ansible_facts['os_family'] == 'Debian') and lp_dnsmasq | bool
  tags: lp_dnsmasq

- name: Import service.yml
  ansible.builtin.import_tasks: service.yml
  tags: lp_service

- name: Import reboot.yml
  ansible.builtin.import_tasks: reboot.yml
  when: ((ansible_facts['os_family'] == 'RedHat') or (ansible_facts['os_family'] == 'Debian')) and lp_reboot | bool
  tags: lp_reboot

# EOF

acpi.yml

Synopsis: Configure acpi

Description of the task.

[tasks/acpi.yml]

---
# linux_postinstall acpi

- name: "Acpi: Debug lp_acpi_debug={{ lp_acpi_debug }}"
  when: lp_acpi_debug | bool
  tags: lp_acpi_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      ansible_distribution: {{ ansible_facts['distribution'] }}
      ansible_distribution_version: {{ ansible_facts['distribution_version'] }}
      ansible_distribution_release: {{ ansible_facts['distribution_release'] }}

      lp_acpi_install: {{ lp_acpi_install }}
      lp_acpi_enable: {{ lp_acpi_enable }}
      lp_acpi_service: {{ lp_acpi_service }}
      lp_acpi_dir: {{ lp_acpi_dir }}
      lp_acpi_owner: {{ lp_acpi_owner }}
      lp_acpi_group: {{ lp_acpi_group }}
      lp_acpi_event_mode: {{ lp_acpi_event_mode }}
      lp_acpi_action_mode: {{ lp_acpi_action_mode }}
      lp_acpi_packages: {{ lp_acpi_packages }}

      lp_acpi_events:
        {{ lp_acpi_events | to_nice_yaml(indent=2) | indent(2) }}
      lp_acpi_actions:
        {{ lp_acpi_actions | to_nice_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Acpi: Install packages"
  when: lp_acpi_install | bool
  tags: lp_acpi_packages
  vars:
    ll_ipkg_list: "{{ lp_acpi_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_acpi_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Acpi: Configure {{ lp_acpi_dir ~ '/events' }}"
  tags: lp_acpi_events
  notify: restart acpid
  ansible.builtin.template:
    src: "{{ item.value.template }}"
    dest: "{{ lp_acpi_dir }}/events/{{ item.value.file }}"
    owner: "{{ lp_acpi_owner }}"
    group: "{{ lp_acpi_group }}"
    mode: "{{ lp_acpi_event_mode }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_acpi_events | dict2items }}"
  loop_control:
    label: "{{ item.key }}"

- name: "Acpi: Create actions in {{ lp_acpi_dir }}"
  tags: lp_acpi_actions
  notify: restart acpid
  ansible.builtin.template:
    src: "{{ item.value.template }}"
    dest: "{{ lp_acpi_dir }}/{{ item.value.file }}"
    owner: "{{ lp_acpi_owner }}"
    group: "{{ lp_acpi_group }}"
    mode: "{{ lp_acpi_action_mode }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_acpi_actions | dict2items }}"
  loop_control:
    label: "{{ item.value.file }}"

- name: "Acpi: Service/State {{ state ~ '/' ~ enable }}"
  tags: lp_acpi_service
  register: result
  vars:
    enabled: "{{ lp_acpi_enable | bool | d(false) }}"
    state: "{{ lp_acpi_state | d(default_state) }}"
    default_state: "{{ enabled | ternary('started', 'stopped') }}"
    enable: "{{ enabled | ternary('enabled', 'disabled') }}"
  ansible.builtin.service:
    name: "{{ lp_acpi_service }}"
    state: "{{ state }}"
    enabled: "{{ enabled }}"

# EOF

aliases.yml

Synopsis: Configure aliases

Description of the task.

[tasks/aliases.yml]

---
# linux_postinstall aliases

- name: "Aliases: Configure /etc/aliases"
  notify: newaliases
  ansible.builtin.template:
    src: aliases.j2
    dest: /etc/aliases
    owner: root
    group: root
    mode: "0644"
    backup: "{{ lp_backup_conf }}"

# EOF

See also

• Handler newaliases.yml

• Template aliases.j2

apt.yml

Synopsis: Configure apt

Description of the task.

[tasks/apt.yml]

---
# linux_postinstall apt

- name: "Apt: Debug lp_apt_debug={{ lp_apt_debug }}"
  when: lp_apt_debug | bool
  tags: lp_apt_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_apt_conf:
        {{ lp_apt_conf | to_nice_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Apt: Configure /etc/apt/apt.conf.d"
  notify: "{{ item.notify | d(omit) }}"
  tags: lp_apt_conf
  ansible.builtin.template:
    src: "{{ item.template | d('apt-confd.j2') }}"
    dest: /etc/apt/apt.conf.d/{{ item.file }}
    owner: "{{ item.owner | d('root') }}"
    group: "{{ item.group | d('root') }}"
    mode: "{{ item.mode | d('0644') }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_apt_conf }}"
  loop_control:
    label: "{{ item.file }}"

# EOF

See also

• Template apt_confd.j2

apparmor.yml

Synopsis: Configure apparmor

Description of the task.

[tasks/apparmor.yml]

---
# linux_postinstall apparmor

- name: "Apparmor: Debug lp_apparmor_debug={{ lp_apparmor_debug }}"
  when: lp_apparmor_debug | bool
  tags: lp_apparmor_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_apparmor_install: {{ lp_apparmor_install }}
      lp_apparmor_packages:
        {{ lp_apparmor_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Apparmor: Install packages"
  when: lp_apparmor_install | bool
  tags: lp_apparmor_packages
  vars:
    ll_ipkg_list: "{{ lp_apparmor_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_apparmor_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Apparmor: Create list of profiles"
  tags: lp_apparmor_profiles

  block:
    - name: "Apparmor: List profiles"
      register: result
      changed_when: false
      ansible.builtin.shell:
        cmd: >
          set -o pipefail && aa-status --json | jq .profiles | jq to_entries
        executable: /usr/bin/bash

    - name: "Apparmor: Debug: List of profiles lp_apparmor_debug={{ lp_apparmor_debug }}"
      when: lp_apparmor_debug | bool
      ansible.builtin.debug:
        var: result

    - name: "Apparmor: Instantiate profiles"
      ansible.builtin.set_fact:
        lp_apparmor_profiles_enforce: "{{ lp_apparmor_profiles_enforce }}"
        lp_apparmor_profiles_complain: "{{ lp_apparmor_profiles_complain }}"

    - name: "Apparmor: Debug profiles lp_apparmor_debug={{ lp_apparmor_debug }}"
      when: lp_apparmor_debug | bool
      ansible.builtin.debug:
        msg: |
          lp_apparmor_profiles_enforce:
            {{ lp_apparmor_profiles_enforce | to_nice_yaml(indent=2) | indent(2) }}
          lp_apparmor_profiles_complain:
            {{ lp_apparmor_profiles_complain | to_nice_yaml(indent=2) | indent(2) }}

- name: "Apparmor: Disable profiles"
  when: item in lp_apparmor_profiles_enforce or item in lp_apparmor_profiles_complain
  tags: lp_apparmor_disable
  ansible.builtin.command: # noqa: no-changed-when
    cmd: >
      aa-disable {{ item }}
  loop: "{{ lp_apparmor_disable }}"

- name: "Apparmor: Enforce profiles"
  when: item not in lp_apparmor_profiles_enforce
  tags: lp_apparmor_enforce
  ansible.builtin.command: # noqa: no-changed-when
    cmd: >
      aa-enforce {{ item }}
  loop: "{{ lp_apparmor_enforce }}"

- name: "Apparmor: Complain profiles"
  when: item not in lp_apparmor_profiles_complain
  tags: lp_apparmor_complain
  ansible.builtin.command: # noqa: no-changed-when
    cmd: >
      aa-complain {{ item }}
  loop: "{{ lp_apparmor_complain }}"

- name: Service
  tags: lp_apparmor_service
  block:

    - name: "Apparmor: Service {{ state ~ ' and ' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_apparmor_enable | bool | d(false) }}"
        state: "{{ lp_apparmor_state | d(default_state) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_apparmor_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Apparmor: Debug service lp_apparmor_debug={{ lp_apparmor_debug }}"
      when: lp_apparmor_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

authorized_keys.yml

Synopsis: Configure authorized_keys

Description of the task.

[tasks/authorized_keys.yml]

---
# linux_postinstall authorized_keys

- name: "Authorized_key: Configure authorized_keys"
  vars:
    arr: "{{ item.key | split }}"
  ansible.posix.authorized_key:
    user: "{{ item.user }}"
    key: "{{ item.key }}"
    manage_dir: true
  loop: "{{ lp_authorized_keys }}"
  loop_control:
    label: "{{ item.user }} {{ arr.0 }} {{ arr.2 }}"

# EOF

autofs.yml

Synopsis: Configure autofs

Description of the task.

[tasks/autofs.yml]

---
# linux_postinstall autofs

- name: "Autofs: Debug lp_autofs_debug={{ lp_autofs_debug }}"
  when: lp_autofs_debug | bool
  tags: lp_autofs_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_autofs_install: {{ lp_autofs_install }}
      lp_autofs_enable: {{ lp_autofs_enable }}
      lp_autofs_flush_handlers: {{ lp_swap_flush_handlers }}
      lp_autofs_rescue_end_host: {{ lp_swap_rescue_end_host }}
      lp_autofs_service: {{ lp_autofs_service }}
      lp_autofs_conf_file: {{ lp_autofs_conf_file }}
      lp_autofs_conf:
        {{ lp_autofs_conf | to_nice_yaml(indent=2) | indent(2) }}
      lp_autofs_master_conf_file: {{ lp_autofs_master_conf_file }}
      lp_autofs_master_conf:
        {{ lp_autofs_master_conf | to_nice_yaml(indent=2) | indent(2) }}
      lp_autofs_misc_conf_file: {{ lp_autofs_misc_conf_file }}
      lp_autofs_misc_conf:
        {{ lp_autofs_misc_conf | to_nice_yaml(indent=2) | indent(2) }}
      lp_autofs_packages:
        {{ lp_autofs_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Autofs: Install packages"
  when: lp_autofs_install | bool
  tags: lp_autofs_packages
  vars:
    ll_ipkg_list: "{{ lp_autofs_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_autofs_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: Configure autofs
  notify: reload autofs
  block:

    - name: "Autofs: Configure {{ lp_autofs_conf_file }}"
      tags: lp_autofs_conf
      ansible.builtin.lineinfile:
        dest: "{{ lp_autofs_conf_file }}"
        regexp: ^\s*{{ item.key }}\s*=\s*(.*)$
        line: "{{ item.key }} = {{ item.value }}"
        backup: "{{ lp_backup_conf }}"
      loop: "{{ lp_autofs_conf }}"

    - name: "Autofs: Configure {{ lp_autofs_master_conf_file }}"
      tags: lp_autofs_master_conf
      ansible.builtin.lineinfile:
        dest: "{{ lp_autofs_master_conf_file }}"
        regexp: ^\s*{{ item.key }}\s*(.*)$
        line: "{{ item.key }} {{ item.value }}"
        backup: "{{ lp_backup_conf }}"
      loop: "{{ lp_autofs_master_conf }}"

    - name: "Autofs: Configure {{ lp_autofs_misc_conf_file }}"
      tags: lp_autofs_misc_conf
      ansible.builtin.lineinfile:
        dest: "{{ lp_autofs_misc_conf_file }}"
        regexp: ^\s*{{ item.key }}\s*(.*)$
        line: "{{ item.key }} {{ item.value }}"
        backup: "{{ lp_backup_conf }}"
      loop: "{{ lp_autofs_misc_conf }}"

- name: Service autofs
  tags: lp_autofs_service
  block:

    - name: "Autofs: Service {{ state ~ ' and ' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_autofs_enable | bool }}"
        state: "{{ lp_sutofs_state | d(default_state) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_autofs_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Autofs: Debug service lp_autofs_debug={{ lp_autofs_debug }}"
      when: lp_autofs_debug | bool
      ansible.builtin.debug:
        var: result

  rescue:

    - name: "Autofs: Print errors"
      ansible.builtin.debug:
        msg: |
          [ERR] task {{ ansible_failed_task.name }} failed. End host.
          ansible_failed_task:
            {{ ansible_failed_task | to_yaml(indent=2) | indent(2) }}
          ansible_failed_result:
            {{ ansible_failed_result | to_yaml(indent=2) | indent(2) }}

    - name: "Autofs: End host"
      when: lp_autofs_rescue_end_host | bool
      ansible.builtin.meta: end_host

    - name: "Autofs: Clear host errors"
      ansible.builtin.meta: clear_host_errors

- name: "Autofs: Flush handlers"
  ansible.builtin.meta: flush_handlers
  when: lp_autofs_flush_handlers | bool

# EOF

See also

• Handler autofs.yml

auto_upgrades.yml

Synopsis: Configure auto_upgrades

Description of the task.

[tasks/auto_upgrades.yml]

---
# linux_postinstall auto_upgrades

- name: "Auto_upgrades: Configure /etc/apt/apt.conf.d/20auto-upgrades"
  tags: lp_auto_upgrades_conf
  ansible.builtin.template:
    src: auto-upgrades.j2
    dest: /etc/apt/apt.conf.d/20auto-upgrades
    owner: root
    group: root
    mode: "0644"
    backup: "{{ lp_backup_conf }}"

- name: Service
  tags: lp_auto_upgrades_service
  block:

    - name: "Auto_upgrades: Service {{ state ~ ' and ' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_auto_upgrades_enable | bool }}"
        state: "{{ lp_auto_upgrades_state | d(default_state) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_auto_upgrades_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Auto_upgrades: Debug service lp_auto_upgrades_debug={{ lp_auto_upgrades_debug }}"
      when: lp_auto_upgrades_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

bluetooth.yml

Synopsis: Configure bluetooth

Description of the task.

[tasks/bluetooth.yml]

---
# linux_postinstall bluetooth

- name: "Bluetooth: Debug lp_bluetooth_debug={{ lp_bluetooth_debug }}"
  when: lp_bluetooth_debug | bool
  tags: lp_bluetooth_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_bluetooth_enable: {{ lp_bluetooth_enable }}
      lp_bluetooth_main_conf:
        {{ lp_bluetooth_main_conf | to_yaml(indent=2) | indent(2) }}
      lp_bluetooth_ini:
        {{ lp_bluetooth_ini | to_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: Configure bluetooth
  notify: restart bluetooth
  block:

    - name: "Bluetooth: Configure /etc/bluetooth/main.conf"
      tags: lp_bluetooth_conf
      ansible.builtin.lineinfile:
        dest: /etc/bluetooth/main.conf
        regexp: ^\s*{{ item.key }}\s*=\s*(.*)$
        insertbefore: ^[\s#]*{{ item.key }}(.*)$
        line: "{{ item.key }} = {{ item.value }}"
        backup: "{{ lp_backup_conf }}"
      loop: "{{ lp_bluetooth_main_conf }}"
      loop_control:
        label: "{{ item.key }} {{ item.value }}"

    - name: "Bluetooth: Configure bluetooth"
      tags: lp_bluetooth_ini
      community.general.ini_file:
        path: "{{ item.0.path }}"
        mode: "{{ item.0.mode }}"
        section: "{{ item.1.section }}"
        option: "{{ item.1.option | d(omit) }}"
        value: "{{ item.1.value }}"
        backup: "{{ lp_backup_conf }}"
      loop: "{{ lp_bluetooth_ini | subelements('conf') }}"
      loop_control:
        label: "{{ item.1.option }}: {{ item.1.value }}"

- name: Service bluetooth
  tags: lp_bluetooth_service
  block:

    - name: "Bluetooth: Service {{ state ~ ' and ' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_bluetooth_enable | bool | d(false) }}"
        state: "{{ lp_bluetooth_state | d(default_state) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_bluetooth_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Bluetooth: Debug service lp_bluetooth_debug={{ lp_bluetooth_debug }}"
      when: lp_bluetooth_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

See also

• Handler bluetooth.yml

chrony.yml

Synopsis: Configure chrony

Description of the task.

[tasks/chrony.yml]

---
# linux_postinstall chrony

- name: "Chrony: Debug lp_chrony_debug={{ lp_chrony_debug }}"
  when: lp_chrony_debug | bool
  tags: lp_chrony_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      ansible_distribution: {{ ansible_facts['distribution'] }}
      ansible_distribution_version: {{ ansible_facts['distribution_version'] }}
      ansible_distribution_release: {{ ansible_facts['distribution_release'] }}

      lp_backup_conf: {{ lp_backup_conf }}

      lp_chrony_install: {{ lp_chrony_install }}
      lp_chrony_enable: {{ lp_chrony_enable }}
      lp_chrony_service: {{ lp_chrony_service }}
      lp_chrony_sanity: {{ lp_chrony_sanity }}
      lp_chrony_service_exists_fatal: {{ lp_chrony_service_exists_fatal }}
      lp_chrony_rescue_end_host: {{ lp_swap_rescue_end_host }}
      lp_chrony_flush_handlers: {{ lp_swap_flush_handlers }}
      lp_chrony_conf_file: {{ lp_chrony_conf_file }}
      lp_chrony_conf_file_orig: {{ lp_chrony_conf_file_orig }}
      lp_chrony_conf_template: {{ lp_chrony_conf_template }}
      lp_chrony_conf:
        {{ lp_chrony_conf | to_nice_yaml(indent=2) | indent(2) }}
      lp_chrony_packages:
        {{ lp_chrony_packages | to_nice_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: Sanity
  when: lp_chrony_sanity | bool
  tags: lp_chrony_sanity
  block:

    - name: "Chrony: sanity: Assert chrony and timesyncd packages mutually exclusive."
      ansible.builtin.assert:
        that: not (lp_chrony_install | bool and lp_timesyncd_install | bool)
        fail_msg: >
          [ERR] Packages for chrony and timesyncd are mutually exclusive.

    - name: "Chrony: sanity: Assert chrony and timesyncd services mutually exclusive."
      ansible.builtin.assert:
        that: not (lp_chrony_enable | bool and lp_timesyncd_enable | bool)
        fail_msg: >
          [ERR] Services {{ lp_chrony_service }} and {{ lp_timesyncd_service }}
          are mutually exclusive.

    - name: "Chrony: sanity: Get package facts"
      ansible.builtin.package_facts:

    - name: "Chrony: sanity: Assert installed lp_chrony_packages in ansible_check_mode"
      ansible.builtin.assert:
        that: missing | length == 0
        fail_msg: >
          [ERR] Packages must be installed before running --check
          Missing packages: {{ missing }}
      vars:
        missing: "{{ lp_chrony_packages | difference(ansible_facts.packages) }}"
      when: ansible_check_mode

- name: "Chrony: Install packages"
  when: lp_chrony_install | bool
  tags: lp_chrony_packages
  vars:
    ll_ipkg_list: "{{ lp_chrony_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_chrony_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: Set lp_chrony_service_exists/found
  block:

    - name: "Chrony: Get Service facts"
      ansible.builtin.service_facts:

    - name: "Chrony: Set lp_chrony_service_exists/found={{ exists ~ '/' ~ found }}"
      vars:
        service: "{{ lp_chrony_service | splitext | first }}.service"
        exists: "{{ service in ansible_facts.services }}"
        found: "{{ ansible_facts.services[service]['status'] | d('not-found') != 'not-found' }}"
      ansible.builtin.set_fact:
        lp_chrony_service_exists: "{{ exists }}"
        lp_chrony_service_found: "{{ found }}"

    - name: "Chrony: Debug lp_timesyncd_service lp_timesyncd_debug={{ lp_timesyncd_debug }}"
      when: lp_chrony_debug | bool
      vars:
        service: "{{ lp_chrony_service | splitext | first }}.service"
      ansible.builtin.debug:
        msg: |
          lp_chrony_service_exists: {{ lp_chrony_service_exists }}
          lp_chrony_service_found: {{ lp_chrony_service_found }}
          {% if lp_chrony_service_exists %}
          {{ service }}:
            {{ ansible_facts.services[service] | to_nice_yaml(indent=2) | indent(2) }}
          {% endif %}

    - name: "Chrony: Assert exists and found {{ lp_chrony_service }}"
      when: lp_chrony_service_exists_fatal | bool
      ansible.builtin.assert:
        that:
          - lp_chrony_service_exists
          - lp_chrony_service_found
        fail_msg: "[ERR] Service {{ lp_chrony_service }} must exists and be found."

- name: Configure chrony
  block:

    - name: "Chrony: Keep original {{ lp_chrony_conf_file }}"
      when: lp_chrony_conf_file_orig | bool
      tags: lp_chrony_conf_orig
      ansible.builtin.copy:
        src: "{{ lp_chrony_conf_file }}"
        dest: "{{ lp_chrony_conf_file }}.orig"
        mode: "0644"
        remote_src: true
        force: false

    - name: "Chrony: Configure {{ lp_chrony_conf_file }}"
      tags: lp_chrony_conf
      notify: restart chrony
      ansible.builtin.template:
        src: "{{ lp_chrony_conf_template }}"
        dest: "{{ lp_chrony_conf_file }}"
        owner: root
        group: root
        mode: "0644"
        backup: "{{ lp_backup_conf }}"

- name: Service chrony
  tags: lp_chrony_service
  block:

    - name: "Chrony: Set service state/status {{ state ~ '/' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_chrony_enable | bool | d(false) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        state: "{{ lp_chrony_state | d(default_state) }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_chrony_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Chrony: Debug set state/status result lp_chrony_debug2={{ lp_chrony_debug2 | d(false) | bool }}"
      when: lp_chrony_debug2 | d(false) | bool
      ansible.builtin.debug:
        var: result

  rescue:
    - name: "Chrony: Print errors"
      ansible.builtin.debug:
        msg: |
          [ERR] task {{ ansible_failed_task.name }} failed. End host.
          ansible_failed_task:
            {{ ansible_failed_task | to_yaml(indent=2) | indent(2) }}
          ansible_failed_result:
            {{ ansible_failed_result | to_yaml(indent=2) | indent(2) }}

    - name: "Chrony: End host"
      ansible.builtin.meta: end_host
      when: lp_chrony_rescue_end_host | bool

    - name: "Chrony: Clear host errors"
      ansible.builtin.meta: clear_host_errors

- name: "Chrony: Flush handlers"
  ansible.builtin.meta: flush_handlers
  when: lp_chrony_flush_handlers | bool
  tags: lp_chrony_flush_handlers

# EOF

cron.yml

Synopsis: Configure cron

Description of the task.

[tasks/cron.yml]

---
# linux_postinstall cron

- name: "Cron: Configure cron variables"
  tags: lp_cron_var
  community.general.cronvar:
    name: "{{ item.name }}"
    value: "{{ item.value }}"
    user: "{{ item.user }}"
  loop: "{{ lp_cron_var }}"

- name: "Cron: Configure cron"
  tags: lp_cron_tab
  ansible.builtin.cron:
    state: "{{ item.state }}"
    user: "{{ item.user }}"
    name: "{{ item.name }}"
    minute: "{{ item.minute }}"
    hour: "{{ item.hour }}"
    day: "{{ item.day }}"
    month: "{{ item.month }}"
    weekday: "{{ item.weekday }}"
    job: "{{ item.command }}"
  loop: "{{ lp_cron_tab }}"
  loop_control:
    label: "{{ item.name }}"

# EOF

debsums.yml

Synopsis: Configure debsums

Description of the task.

[tasks/debsums.yml]

---
# linux_postinstall debsums

- name: "Debsums: Debug lp_debsums_debug={{ lp_debsums_debug }}"
  when: lp_debsums_debug | bool
  tags: lp_debsums_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_debsums_install: {{ lp_debsums_install }}
      lp_debsums_default_file: {{ lp_debsums_default_file }}
      lp_debsums_default_conf:
        {{ lp_debsums_default_conf | to_yaml(indent=2) | indent(2) }}
      lp_debsums_ignore_file: {{ lp_debsums_ignore_file }}
      lp_debsums_ignore_conf:
        {{ lp_debsums_ignore_conf | to_nice_yaml(indent=2) | indent(2) }}
      lp_debsums_packages:
        {{ lp_debsums_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Debsums: Install packages"
  when: lp_debsums_install | bool
  tags: lp_debsums_packages
  vars:
    ll_ipkg_list: "{{ lp_debsums_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_debsums_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Debsums: Configure {{ lp_debsums_default_file }}"
  tags: lp_debsums_default_conf
  ansible.builtin.lineinfile:
    dest: "{{ lp_debsums_default_file }}"
    state: "{{ item.state | d(omit) }}"
    regexp: ^\s*{{ item.key }}\s*=(.*)$
    line: "{{ item.key }}={{ item.value }}"
    backup: "{{ lp_backup_conf }}"
    create: true
    mode: "0644"
  loop: "{{ lp_debsums_default_conf }}"

- name: "Debsums: Configure {{ lp_debsums_ignore_file }}"
  tags: lp_debsums_ignore_conf
  ansible.builtin.lineinfile:
    dest: "{{ lp_debsums_ignore_file }}"
    state: "{{ item.state | d(omit) }}"
    line: "{{ item }}"
    backup: "{{ lp_backup_conf }}"
    create: true
    mode: "0644"
  loop: "{{ lp_debsums_ignore_conf }}"

# EOF

debug.yml

Synopsis: Configure debug

Description of the task.

[tasks/debug.yml]

---
# Hint: Get readable output with stdout_callback = yaml

- name: Debug
  vars:
    msg: |-
      lp_role_version: {{ lp_role_version }}
      ansible_architecture: {{ ansible_facts['architecture'] }}
      ansible_os_family: {{ ansible_facts['os_family'] }}
      ansible_distribution: {{ ansible_facts['distribution'] }}
      ansible_distribution_major_version: {{ ansible_distribution_major_version }}
      ansible_distribution_version: {{ ansible_facts['distribution_version'] }}
      ansible_distribution_release: {{ ansible_facts['distribution_release'] }}
      ansible_python_version: {{ ansible_facts['python_version'] }}

      lp_vars_distro: {{ lp_vars_distro }}
      lp_vars_distro_firstfound_skip: {{ lp_vars_distro_firstfound_skip }}
      lp_vars_flavors: {{ lp_vars_flavors }}
      lp_flavors_enable: {{ lp_flavors_enable }}
      my_release:
        {{ my_release | d([]) | to_nice_yaml(indent=2) | indent(2) }}
      lp_packages_auto: {{ lp_packages_auto }}
      lp_package_state: {{ lp_package_state }}
      lp_package_state_remove: {{ lp_package_state_remove }}
      lp_backup_conf: {{ lp_backup_conf }}
      lp_service:
        {{ lp_service | to_yaml(indent=2) | indent(2) }}
      lp_tasks_enabled: {{ lp_tasks_enabled_print | ternary(lp_tasks_enabled, 'Disabled') }}
      lp_tasks_disabled: {{ lp_tasks_disabled_print | ternary(lp_tasks_disabled, 'Disabled') }}

      lp_aliases: {{ lp_aliases }}
      lp_apt: {{ lp_apt }}
      lp_debsums: {{ lp_debsums }} lp_debsums_install: {{ lp_debsums_install }}
      lp_gpg: {{ lp_gpg }} lp_gpg_install: {{ lp_gpg_install }}
      lp_grub: {{ lp_grub }}
      lp_iptables: {{ lp_iptables }}
      lp_kvm: {{ lp_kvm }} lp_kvm_install: {{ lp_kvm_install }}
      lp_latex: {{ lp_latex }} lp_latex_install: {{ lp_latex_install }}
      lp_lid: {{ lp_lid }}
      lp_logrotate: {{ lp_logrotate }} lp_logrotate_install: {{ lp_logrotate_install }}
      lp_netplan: {{ lp_netplan }}
      lp_packages_autoremove: {{ lp_packages_autoremove }}
      lp_passwords: {{ lp_passwords }}
      lp_pm: {{ lp_pm }}
      lp_rc_local: {{ lp_rc_local }}
      lp_reboot: {{ lp_reboot }}
      lp_ssh: {{ lp_ssh }}
      lp_swap: {{ lp_swap }} lp_swap_enable: {{ lp_swap_enable }}
      lp_systemd: {{ lp_systemd }} lp_systemd_install: {{ lp_systemd_install }}
      lp_timezone: {{ lp_timezone }}
      lp_wpagui: {{ lp_wpagui }} lp_wpagui_install: {{ lp_wpagui_install }}

      {% for service in lp_service_all %}
      lp_{{ service }}: {{ lookup('vars', 'lp_' ~ service) }}, {% for suffix in ['_install', '_enable', '_service'] -%}
      lp_{{ service }}{{ suffix }}: {{ lookup('vars', 'lp_' ~ service ~ suffix, default='UNDEFINED') }}, {% endfor %}

      {% endfor %}

      {% for group in lp_services_all %}
      lp_{{ group }}: {{ lookup('vars', 'lp_' ~ group) }}, {% for suffix in ['_install', '_enable'] -%}
      lp_{{ group }}{{ suffix }}: {{ lookup('vars', 'lp_' ~ group ~ suffix, default='UNDEFINED') }}, {% endfor %}

      services:
      {% for service in lookup('vars', 'lp_' ~ group ~ '_services') %}
      - {{ service }}
      {% endfor %}
      {% endfor %}

      lp_wpasupplicant: {{ lp_wpasupplicant }} lp_wpasupplicant_install: {{ lp_wpasupplicant_install }}
      lp_xen: {{ lp_xen }} lp_xen_install: {{ lp_xen_install }}
      lp_zeitgeist: {{ lp_zeitgeist }} lp_zeitgeist_install: {{ lp_zeitgeist_install }}
      lp_zfs: {{ lp_zfs }} lp_zfs_install: {{ lp_zfs_install }}
      [WIP] lp_snap: {{ lp_snap }} lp_snap_install: {{ lp_snap_install }} lp_snap_enable: {{ lp_snap_enable }}

  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

# EOF

dnsmasq.yml

Synopsis: Configure dnsmasq

Description of the task.

[tasks/dnsmasq.yml]

---
# linux_postinstall dnsmasq

- name: "Dnsmasq: Debug lp_dnsmasq_debug={{ lp_dnsmasq_debug }}"
  when: lp_dnsmasq_debug | bool
  tags: lp_dnsmasq_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_dnsmasq_install: {{ lp_dnsmasq_install }}
      lp_dnsmasq_enable: {{ lp_dnsmasq_enable }}
      lp_dnsmasq_service: {{ lp_dnsmasq_service }}
      lp_dnsmasq_packages:
        {{ lp_dnsmasq_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_dnsmasq_config:
        {{ lp_dnsmasq_config | to_nice_yaml(indent=2) | indent(2) }}
      lp_dnsmasq_hosts:
        {{ lp_dnsmasq_hosts | to_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Dnsmasq: Install packages"
  when: lp_dnsmasq_install | bool
  tags: lp_dnsmasq_packages
  vars:
    ll_ipkg_list: "{{ lp_dnsmasq_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_dnsmasq_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Dnsmasq: Create directories"
  tags: lp_dnsmasq_directories
  ansible.builtin.file:
    state: directory
    path: "{{ item.dest | dirname }}"
    owner: "{{ item.downer | d('root') }}"
    group: "{{ item.dgroup | d('root') }}"
    mode: "{{ item.dmode | d('0755') }}"
  loop: "{{ lp_dnsmasq_config }}"
  loop_control:
    label: "{{ item.dest | dirname }}"

- name: "Dnsmasq: Configure"
  tags: lp_dnsmasq_config
  notify: restart dnsmasq
  ansible.builtin.template:
    src: "{{ item.src }}"
    dest: "{{ item.dest }}"
    owner: "{{ item.owner | d('root') }}"
    group: "{{ item.group | d('root') }}"
    mode: "{{ item.mode | d('0600') }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_dnsmasq_config }}"
  loop_control:
    label: "{{ item.dest }}"

- name: Service
  tags: lp_dnsmasq_service
  block:

    - name: "Dnsmasq: Service {{ state ~ ' and ' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_dnsmasq_enable | bool | d(false) }}"
        state: "{{ lp_dnsmasq_state | d(default_state) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_dnsmasq_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Dnsmasq: Debug service lp_dnsmasq_debug={{ lp_dnsmasq_debug }}"
      when: lp_dnsmasq_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

fstab.yml

Synopsis: Configure fstab

Description of the task.

[tasks/fstab.yml]

---
# linux_postinstall fstab

- name: "Fstab: Configure fstab entries"
  ansible.posix.mount:
    name: "{{ item.name }}"
    state: "{{ item.state | d('mounted') }}"
    src: "{{ item.src | d(omit) }}"
    fstype: "{{ item.fstype | d(omit) }}"
    opts: "{{ item.opts | d(omit) }}"
    dump: "{{ item.dump | d(omit) }}"
    passno: "{{ item.passno | d(omit) }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_fstab_entries }}"

# EOF

gpg.yml

Synopsis: Configure gpg

Description of the task.

[tasks/gpg.yml]

---
# linux_postinstall gpg

- name: "Gpg: Debug lp_gpg_debug={{ lp_gpg_debug }}"
  when: lp_gpg_debug | bool
  tags: lp_gpg_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      ansible_python_version: {{ ansible_facts['python_version'] }}
      lp_gpg_install: {{ lp_gpg_install }}
      lp_gpg_packages:
        {{ lp_gpg_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_gpg_packages_extra:
        {{ lp_gpg_packages_extra | to_nice_yaml(indent=2) | indent(2) }}
      lp_gpg_conf_template: {{ lp_gpg_conf_template }}
      lp_gpg_conf:
        {{ lp_gpg_conf | to_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Gpg: Install packages"
  when: lp_gpg_install | bool
  tags: lp_gpg_packages
  vars:
    ll_ipkg_list: "{{ lp_gpg_packages + lp_gpg_packages_extra }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_gpg_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Gpg: Create directories .gnupg"
  tags: lp_gpg_dir
  ansible.builtin.file:
    state: directory
    dest: /home/{{ item }}/.gnupg
    owner: "{{ item }}"
    group: "{{ item }}"
    mode: "0700"
  loop: "{{ lp_gpg_conf | map(attribute='owner') | unique | sort }}"

- name: "Gpg: Configure gnupg"
  tags: lp_gpg_conf
  register: lp_gpg_conf_reg
  notify: gpgconf reload
  ansible.builtin.template:
    src: "{{ lp_gpg_conf_template }}"
    dest: "{{ ['/home/', item.owner, '/.gnupg/', item.component, '.conf'] | join }}"
    owner: "{{ item.owner }}"
    group: "{{ item.owner }}"
    mode: "0600"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_gpg_conf }}"
  loop_control:
    label: "{{ item.owner }} {{ item.component }}"

# TODO: import keys, template blocks

# EOF

See also

• Handler gpg.yml

• Template gpg.conf.j2

gpsd.yml

Synopsis: Configure gpsd

Description of the task.

[tasks/gpsd.yml]

---
# linux_postinstall gpsd

- name: "Gpsd: Debug lp_gpsd_debug={{ lp_gpsd_debug }}"
  when: lp_gpsd_debug | bool
  tags: lp_gpsd_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_gpsd_install: {{ lp_gpsd_install }}
      lp_gpsd_packages:
        {{ lp_gpsd_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Gpsd: Install packages for gpsd"
  when: lp_gpsd_install | bool
  tags: lp_gpsd_packages
  vars:
    ll_ipkg_list: "{{ lp_gpsd_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_gpsd_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Gpsd: Add user gpsd to group dialout"
  tags: lp_gpsd_group
  ansible.builtin.user:
    name: gpsd
    groups: dialout
    append: true

- name: "Gpsd: Configure /etc/bluetooth/rfcomm.conf"
  tags: lp_gpsd_bt_rfcom
  notify: restart bluetooth
  ansible.builtin.blockinfile:
    dest: /etc/bluetooth/rfcomm.conf
    create: true
    marker: "# {mark} ANSIBLE MANAGED BLOCK rfcomm{{ item.rfcomm }}"
    insertafter: EOF
    owner: root
    group: root
    mode: "0644"
    backup: "{{ lp_backup_conf }}"
    block: |
      rfcomm{{ item.rfcomm }} {
        bind {{ item.bind }}
        device {{ item.device }}
        channel {{ item.channel }}
        comment "{{ item.comment }}"
        }
  loop: "{{ lp_gpsd_bt_rfcomm }}"

- name: "Gpsd: Configure /etc/default/gpsd"
  tags: lp_gpsd_config
  notify: restart gpsd
  ansible.builtin.template:
    src: gpsd.j2
    dest: /etc/default/gpsd
    owner: root
    group: root
    mode: "0644"
    backup: "{{ lp_backup_conf }}"

- name: Service gpsd
  tags: lp_gpsd_service
  block:

    - name: "Gpsd: Service {{ state ~ ' and ' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_gpsd_enable | bool | d(false) }}"
        state: "{{ lp_gpsd_state | d(default_state) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_gpsd_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Gpsd: Debug service lp_gpsd_debug={{ lp_gpsd_debug }}"
      when: lp_gpsd_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

See also

• Handler gpsd.yml

• Handler bluetooth.yml

• Template gpsd.j2

groups.yml

Synopsis: Configure groups

Description of the task.

[tasks/groups.yml]

---
# linux_postinstall groups

- name: "Groups: Debug lp_groups_debug={{ lp_groups_debug }}"
  when: lp_groups_debug | bool
  tags: lp_groups_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_groups:
        {{ lp_groups | to_nice_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Groups: Manage groups"
  ansible.builtin.group:
    name: "{{ item.name }}"
    gid: "{{ item.gid | d(omit) }}"
    state: "{{ item.state | d(omit) }}"
    system: "{{ item.system | d(omit) }}"
  loop: "{{ lp_groups }}"

# EOF

grub.yml

Synopsis: Configure grub

Description of the task.

[tasks/grub.yml]

---
# linux_postinstall grub

- name: "Grub: Debug lp_grub_debug={{ lp_grub_debug }}"
  when: lp_grub_debug | bool
  tags: lp_grub_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_grub_default:
        {{ lp_grub_default | to_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Grub: Configure /etc/default/grub"
  tags: lp_grub_conf
  notify: update grub
  ansible.builtin.lineinfile:
    dest: /etc/default/grub
    regexp: ^\s*{{ item.var }}\s*=(.*)$
    line: "{{ item.var }}={{ item.value }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_grub_default }}"
  loop_control:
    label: "{{ item.var }}: {{ item.value }}"

# EOF

See also

• Handler grub.yml

hostname.yml

Synopsis: Configure hostname

Description of the task.

[tasks/hostname.yml]

---
# linux_postinstall hostname

# TODO:
# 1) SET/DONT_SET hostname via DHCP
# /etc/dhcp/dhclient.conf
# #send host-name = gethostname();
# request host-name = "myhostname";
# https://askubuntu.com/questions/104918/how-to-get-the-hostname-from-a-dhcp-server
# http://blog.schlomo.schapiro.org/2013/11/setting-hostname-from-dhcp-in-debian.html
# https://askubuntu.com/questions/757423/how-to-force-dhcp-client-to-allow-a-self-defined-domain-name

- name: Sanity
  block:

    - name: "Hostname: Sanity lp_hostname not empty"
      ansible.builtin.assert:
        that: lp_hostname | length > 0
        fail_msg: The variable lp_hostname is empty.

    - name: "Hostname: Sanity lp_hostname RFC 1123 and RFC 952"
      when: lp_hostname_fqdn_valid | bool
      ansible.builtin.assert:
        that: lp_hostname is community.general.fqdn_valid
        fail_msg: The variable lp_hostname not conforming RFC 1123 and RFC 952.

- name: "Hostname: Configure hostname in /etc/hostname"
  when: ansible_facts['os_family'] == 'Debian'
  ansible.builtin.template:
    src: hostname.j2
    dest: /etc/hostname
    owner: root
    group: root
    mode: "0644"
    backup: "{{ lp_backup_conf }}"

- name: "Hostname: Configure hostname"
  ansible.builtin.hostname:
    name: "{{ lp_hostname }}"

# EOF

hosts.yml

Synopsis: Configure hosts

Description of the task.

[tasks/hosts.yml]

---
# linux_postinstall hosts

- name: "Hosts: Debug lp_hosts_debug={{ lp_hosts_debug }}"
  when: lp_hosts_debug | bool
  tags: lp_hosts_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_hosts_sanity: {{ lp_hosts_sanity }}
      lp_hosts_default_override:
        {{ lp_hosts_default_override | to_yaml(indent=2) | indent(2) }}
      lp_hosts_default:
        {{ lp_hosts_default | to_yaml(indent=2) | indent(2) }}
      lp_hosts_template: {{ lp_hosts_template }}
      lp_hosts:
        {{ lp_hosts | to_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Hosts: Sanity"
  when: lp_hosts_sanity | bool
  tags: lp_hosts_sanity
  block:

    - name: "Hosts: Sanity valid IP"
      ansible.builtin.assert:
        that: (lp_hosts | map(attribute='ip') | map('ansible.utils.ipaddr')) is all
        fail_msg: "[ERR] Invalid IP address."

    - name: "Hosts: Sanity unique FQDN"
      vars:
        no_records: "{{ lp_hosts | length }}"
        no_hosts: "{{ lp_hosts | map(attribute='fqdn') | list | unique | length }}"
      ansible.builtin.assert:
        that: no_records == no_hosts
        fail_msg: "[ERR] FQDN not unique."

- name: "Hosts: Configure hosts in /etc/hosts"
  tags: lp_hosts_conf
  ansible.builtin.template:
    src: "{{ lp_hosts_template }}"
    dest: /etc/hosts
    owner: root
    group: root
    mode: "0644"
    backup: "{{ lp_backup_conf }}"

# EOF

See also

• Template hosts.j2

iptables.yml

Synopsis: Configure iptables

Description of the task.

[tasks/iptables.yml]

---
# linux_postinstall iptables

- name: "Iptables: Create /etc/network/if-pre-up.d/iptables"
  ansible.builtin.template:
    src: iptables-restore.j2
    dest: /etc/network/if-pre-up.d/iptables
    owner: root
    group: root
    mode: "0755"

- name: "Iptables: Create /etc/network/iptables using {{ lp_iptables_type ~ '-iptables.j2' }}"
  notify: reload iptables
  ansible.builtin.template:
    src: "{{ lp_iptables_type }}-iptables.j2"
    dest: /etc/network/iptables
    owner: root
    group: root
    mode: "0644"

# EOF

See also

• Handler iptables.yml

• Template iptables_restore.j2

• Template default_iptables.j2

• Template router1_iptables.j2

kvm.yml

Synopsis: Configure kvm

Description of the task.

[tasks/kvm.yml]

---
# linux_postinstall kvm

- name: "Kvm: Debug lp_kvm_debug={{ lp_kvm_debug }}"
  when: lp_kvm_debug | bool
  tags: lp_kvm_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_kvm_packages:
        {{ lp_kvm_packages | to_nice_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Kvm: Install packages"
  when: lp_kvm_install | bool
  tags: lp_kvm_packages
  vars:
    ll_ipkg_list: "{{ lp_kvm_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_kvm_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

# EOF

latex.yml

Synopsis: Configure latex

Description of the task.

[tasks/latex.yml]

---
# linux_postinstall LaTeX

- name: "Latex: Debug lp_latex_debug={{ lp_latex_debug }}"
  when: lp_latex_debug | bool
  tags: lp_latex_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_backup_conf: {{ lp_backup_conf }}
      lp_latex_install: {{ lp_latex_install }}
      lp_latex_packages:
        {{ lp_latex_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_latex_macros:
        {{ lp_latex_macros | to_nice_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Latex: Install packages"
  when: lp_latex_install | bool
  tags: lp_latex_packages
  vars:
    ll_ipkg_list: "{{ lp_latex_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_latex_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Latex: Create directory /usr/share/texmf/tex/latex"
  tags: lp_latex_dir
  ansible.builtin.file:
    state: directory
    path: /usr/share/texmf/tex/latex
    mode: "0755"

- name: "Latex: Create directories for macros"
  tags: lp_latex_macros
  ansible.builtin.file:
    state: directory
    path: "{{ item }}"
    mode: "0755"
  loop: "{{ lp_latex_macros | map(attribute='dest') | unique }}"

- name: "Latex: Download macros"
  tags: lp_latex_labels
  ignore_errors: "{{ lp_latex_get_url_ignore_errors }}" # noqa ignore-errors
  changed_when: false
  environment:
    CRYPTOGRAPHY_OPENSSL_NO_LEGACY: '1'
  ansible.builtin.get_url:
    url: "{{ item.url }}"
    dest: "{{ item.dest }}"
    mode: "0644"
    timeout: "{{ lp_latex_download_timeout }}"
  loop: "{{ lp_latex_macros }}"
  loop_control:
    label: "{{ item.url }}"

# Note
# get_url: check mode reports changes with force enabled
# https://github.com/ansible/ansible/issues/25418#issuecomment-307208773
# https://github.com/ansible/ansible/issues/25418

# [TODO]
# 1) Compile and register labels.sty
# cd /usr/share/texmf/tex/latex/labels/
# latex labels.ins
# texhash /usr/share/texmf

# EOF

libvirt.yml

Synopsis: Configure libvirt

Description of the task.

[tasks/libvirt.yml]

---
# linux_postinstall libvirt

- name: "Libvirt Debug lp_libvirt_debug={{ lp_libvirt_debug }}"
  when: lp_libvirt_debug | bool
  tags: lp_libvirt_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_libvirt_guests_enable: {{ lp_libvirt_guests_enable }}
      lp_libvirt_libvirtd_enable: {{ lp_libvirt_libvirtd_enable }}
      lp_libvirt_conf_owner: {{ lp_libvirt_conf_owner }}
      lp_libvirt_conf_group: {{ lp_libvirt_conf_group }}
      lp_libvirt_conf_mode: {{ lp_libvirt_conf_mode }}
      lp_libvirt_conf_dir: {{ lp_libvirt_conf_dir }}
      lp_libvirt_install: {{ lp_libvirt_install }}
      lp_libvirt_packages:
        {{ lp_libvirt_packages | to_nice_yaml | indent(2) }}
      lp_libvirt_conf:
        {{ lp_libvirt_conf | to_nice_yaml | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Libvirt: Install packages"
  when: lp_libvirt_install | bool
  tags: lp_libvirt_packages
  vars:
    ll_ipkg_list: "{{ lp_libvirt_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_libvirt_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Libvirt: Configure {{ lp_libvirt_conf_dir }}"
  tags: lp_libvirt_conf
  notify:
    - reload libvirtd
    - reload libvirt_guests
  ansible.builtin.lineinfile:
    dest: "{{ lp_libvirt_conf_dir }}/{{ item.0.key }}"
    regexp: ^\s*{{ item.1.0 }}(\s|=)(.*)$
    line: "{{ item.1.0 }} = {{ item.1.1 }}"
    state: "{{ item.1.2 | d('present') }}"
    backup: "{{ lp_backup_conf }}"
    create: true
    owner: "{{ item.0.owner | d('root') }}"
    group: "{{ item.0.group | d('root') }}"
    mode: "{{ item.0.mode | d('0644') }}"
  loop: "{{ lp_libvirt_conf | dict2items | subelements('value.conf', {'skip_missing': True}) }}"
  loop_control:
    label: "{{ item.0.key }} {{ item.1.0 }}: {{ item.1.1 }} {{ item.1.2 | d('present') }}"

- name: "Libvirt: Service {{ lp_libvirt_libvirtd_service ~ ' ' ~ state ~ ' and ' ~ enable }}"
  tags: lp_libvirt_libvirtd_service
  register: result
  vars:
    enabled: "{{ lp_libvirt_libvirtd_enable | bool | d(false) }}"
    state: "{{ lp_libvirt_libvirtd_state | d(default_state) }}"
    default_state: "{{ enabled | ternary('started', 'stopped') }}"
    enable: "{{ enabled | ternary('enabled', 'disabled') }}"
  ansible.builtin.service:
    name: "{{ lp_libvirt_libvirtd_service }}"
    state: "{{ state }}"
    enabled: "{{ enabled }}"

- name: "Libvirt: Service {{ lp_libvirt_guests_service ~ ' ' ~ state ~ ' and ' ~ enable }}"
  tags: lp_libvirt_guests_service
  register: result
  vars:
    enabled: "{{ lp_libvirt_guests_enable | bool | d(false) }}"
    state: "{{ lp_libvirt_guests_state | d(default_state) }}"
    default_state: "{{ enabled | ternary('started', 'stopped') }}"
    enable: "{{ enabled | ternary('enabled', 'disabled') }}"
  ansible.builtin.service:
    name: "{{ lp_libvirt_guests_service }}"
    state: "{{ state }}"
    enabled: "{{ enabled }}"

# EOF

lid.yml

Synopsis: Configure lid

Description of the task.

[tasks/lid.yml]

---
# linux_postinstall lid

- name: "Lid: Configure {{ lp_lid_logind_conf }}"
  notify: logind message reboot
  ansible.builtin.lineinfile:
    dest: "{{ lp_lid_logind_conf }}"
    regexp: ^\s*{{ item.var }}\s*=\s*(.*)$
    line: "{{ item.var }}={{ item.value }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_lid_logind_conf_vars }}"
  loop_control:
    label: "{{ item.var }}: {{ item.value }}"

- name: "Lid: Configure {{ lp_lid_upower_conf }}"
  ansible.builtin.lineinfile:
    dest: "{{ lp_lid_upower_conf }}"
    regexp: ^\s*{{ item.var }}\s*=\s*(.*)$
    line: "{{ item.var }}={{ item.value }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_lid_upower_conf_vars }}"
  loop_control:
    label: "{{ item.var }}: {{ item.value }}"

# EOF

See also

• Handler messages.yml

logrotate.yml

Synopsis: Configure logrotate

Description of the task.

[tasks/logrotate.yml]

---
# linux_postinstall logrotate

- name: "Logrotate: Debug lp_logrotate_debug={{ lp_logrotate_debug }}"
  when: lp_logrotate_debug | bool
  tags: lp_logrotate_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_logrotate_install: {{ lp_logrotate_install }}
      lp_logrotate_packages:
        {{ lp_logrotate_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Logrotate: Install packages for logrotate"
  when: lp_logrotate_install | bool
  tags: lp_logrotate_packages
  vars:
    ll_ipkg_list: "{{ lp_logrotate_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_logrotate_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Logrotate: Configure blocks in {{ lp_logrotate_conf_file }}"
  tags: lp_logrotate_conf_blocks
  ansible.builtin.blockinfile:
    path: "{{ lp_logrotate_conf_file }}"
    mark: "{{ item.mark }}"
    block: "{{ item.block }}"
    state: "{{ item.state }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_logrotate_conf_blocks }}"

- name: "Logrotate: Configure lines in {{ lp_logrotate_conf_file }}"
  tags: lp_logrotate_conf_lines
  ansible.builtin.lineinfile:
    path: "{{ lp_logrotate_conf_file }}"
    line: "{{ item.line }}"
    state: "{{ item.state }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_logrotate_conf_lines }}"

- name: "Logrotate: Configure {{ lp_logrotate_conf_dir }}"
  tags: lp_logrotate_confd
  ansible.builtin.blockinfile:
    path: "{{ lp_logrotate_conf_dir }}/{{ item.path }}"
    block: "{{ item.conf }}"
    backup: "{{ lp_backup_conf }}"
    create: true
    owner: "{{ item.owner | d('root') }}"
    group: "{{ item.group | d('root') }}"
    mode: "{{ item.mode | d('0644') }}"
  loop: "{{ lp_logrotate_confd }}"
  loop_control:
    label: "{{ item.path }}"

# EOF

modemmanager.yml

Synopsis: Configure modemmanager

Description of the task.

[tasks/modemmanager.yml]

---
# linux_postinstall ModemManager

- name: "Modemmanager: Configure /etc/init/modemmanager.override"
  tags: lp_modemmanager_override
  ansible.builtin.template:
    src: modem-manager-override.j2
    dest: /etc/init/modemmanager.override
    owner: root
    group: root
    mode: "0644"

- name: Service
  tags: lp_modemmanager_service
  block:

    - name: "Modemmanager: Service {{ state ~ ' and ' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_modemmanager_enable | bool | d(false) }}"
        state: "{{ lp_modemmanager_state | d(default_state) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_modemmanager_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Modemmanager: Debug service lp_modemmanager_service={{ lp_modemmanager_service }}"
      when: lp_modemmanager_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

modules.yml

Synopsis: Configure modules

Description of the task.

[tasks/modules.yml]

---
# linux_postinstall modules

- name: "Modules: Debug lp_modules_debug={{ lp_modules_debug }}"
  when: lp_modules_debug | bool
  tags: lp_modules_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_modules_conf: {{ lp_modules_conf }}
      lp_modules:
        {{ lp_modules | to_yaml(indent=2) | indent(2) }}
      lp_modules_options_path:  {{ lp_modules_options_path }}
      lp_modules_options:
        {{ lp_modules_options | to_nice_yaml(indent=2) | indent(2) }}
      lp_modules_blacklist_path: {{ lp_modules_blacklist_path }}
      lp_modules_blacklist:
        {{ lp_modules_blacklist | to_nice_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Modules: modprobe modules"
  community.general.modprobe:
    name: "{{ item.name }}"
    params: "{{ item.params }}"
    state: "{{ item.state | d('present') }}"
  loop: "{{ lp_modules }}"

- name: "Modules: Configure in Debian {{ lp_modules_conf }}"
  ansible.builtin.lineinfile:
    dest: "{{ lp_modules_conf }}"
    regexp: ^\s*{{ item.name }}\s*(.*)$
    line: "{{ item.name }} {{ item.params }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_modules }}"
  when:
    - ansible_facts['os_family'] == 'Debian'
    - item.state | d('present') == 'present'

- name: "Modules: Configure in RedHat {{ lp_modules_conf }}"
  ansible.builtin.lineinfile:
    dest: "{{ lp_modules_conf }}"
    regexp: ^\s*modprobe\s+{{ item.name }}\s*(.*)$
    line: modprobe {{ item.name }} {{ item.params }}
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_modules }}"
  when:
    - ansible_facts['os_family'] == 'RedHat'
    - item.state | d('present') == 'present'

- name: Configure modules
  notify: update initramfs
  block:

    - name: "Modules: Blacklist modules in {{ lp_modules_blacklist_path }}"
      ansible.builtin.template:
        src: blacklist-module.j2
        dest: "{{ lp_modules_blacklist_path }}/blacklist-{{ item }}.conf"
        backup: "{{ lp_backup_conf }}"
        mode: "0644"
      loop: "{{ lp_modules_blacklist }}"

    - name: "Modules: Set modules options in {{ lp_modules_options_path }}"
      ansible.builtin.template:
        src: options-module.j2
        dest: "{{ lp_modules_options_path }}/{{ item.module }}.conf"
        backup: "{{ lp_backup_conf }}"
        mode: "0644"
      loop: "{{ lp_modules_options }}"
      loop_control:
        label: "{{ item.module }}: {{ item.options }}"

# EOF

netplan.yml

Synopsis: Configure netplan

Description of the task.

[tasks/netplan.yml]

---
# linux_postinstall netplan

- name: Configure 01-network-manager-all.yaml if it exists
  block:

    - name: "Netplan: Stat {{ lp_netplan_default }}"
      register: result
      ansible.builtin.stat:
        path: "{{ lp_netplan_root }}/{{ lp_netplan_default }}"

    - name: "Netplan: Configure {{ lp_netplan_root ~ '/' ~ lp_netplan_default }}"
      when: result.stat.exists | d(false)
      notify: netplan apply
      ansible.builtin.template:
        src: netplan-default.j2
        dest: "{{ lp_netplan_root }}/{{ lp_netplan_default }}"
        owner: "{{ lp_netplan_owner }}"
        group: "{{ lp_netplan_group }}"
        mode: "{{ lp_netplan_mode }}"
        backup: "{{ lp_backup_conf }}"

- name: "Netplan: Configure files in {{ lp_netplan_root }}"
  notify: netplan apply
  ansible.builtin.template:
    src: netplan-conf.j2
    dest: "{{ lp_netplan_root }}/{{ item.file }}"
    owner: "{{ item.owner | d(lp_netplan_owner) }}"
    group: "{{ item.group | d(lp_netplan_group) }}"
    mode: "{{ item.mode | d(lp_netplan_mode) }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_netplan_conf }}"
  loop_control:
    label: "{{ item.file }}"

# EOF

See also

• Handler netplan.yml

• Template netplan_default.j2

• Template netplan_conf.j2

networkd.yml

Synopsis: Configure networkd

Description of the task.

[tasks/networkd.yml]

---
# linux_postinstall networkd

- name: "Networkd: Debug lp_networkd_debug={{ lp_networkd_debug }}"
  when: lp_networkd_debug | bool
  tags: lp_networkd_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_networkd_install: {{ lp_networkd_install }}
      lp_networkd_packages:
        {{ lp_networkd_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_networkd_enable: {{ lp_networkd_enable }}
      lp_networkd_service: {{ lp_networkd_service }}
      lp_networkd_conf:
        {{ lp_networkd_conf | to_yaml(indent=2) | indent(2) }}
      lp_systemd_owner: {{ lp_systemd_owner }}
      lp_systemd_group: {{ lp_systemd_group }}
      lp_systemd_mode: {{ lp_systemd_mode }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Networkd: Install packages"
  when: lp_networkd_install | bool
  tags: lp_networkd_packages
  vars:
    ll_ipkg_list: "{{ lp_networkd_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_networkd_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Networkd: Configure networkd"
  tags: lp_networkd_conf
  notify: restart networkd
  ansible.builtin.template:
    src: "{{ item.src }}"
    dest: "{{ item.dest }}"
    owner: "{{ item.owner | d(lp_systemd_owner) }}"
    group: "{{ item.group | d(lp_systemd_group) }}"
    mode: "{{ item.mode | d(lp_systemd_mode) }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_networkd_conf }}"
  loop_control:
    label: "{{ item.dest }}"

- name: Service
  tags: lp_networkd_service
  block:

    - name: "Networkd: Service {{ state ~ ' and ' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_networkd_enable | bool | d(false) }}"
        state: "{{ lp_networkd_state | d(default_state) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_networkd_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Networkd: Debug service lp_networkd_debug={{ lp_networkd_debug }}"
      when: lp_networkd_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

networkmanager.yml

Synopsis: Configure networkmanager

Description of the task.

[tasks/networkmanager.yml]

---
# linux_postinstall networkmanager

- name: "Nm: Debug lp_nm_debug={{ lp_nm_debug }}"
  when: lp_nm_debug | bool
  tags: lp_nm_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      ansible_distribution: {{ ansible_facts['distribution'] }}
      ansible_distribution_version: {{ ansible_facts['distribution_version'] }}
      ansible_distribution_release: {{ ansible_facts['distribution_release'] }}

      lp_backup_conf: {{ lp_backup_conf }}

      lp_nm_install: {{ lp_nm_install }}
      lp_nm_packages:
        {{ lp_nm_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_nm_enable: {{ lp_nm_enable }}
      lp_nm_override: {{ lp_nm_override }}
      lp_nm_conf_path: {{ lp_nm_conf_path }}
      lp_nm_conf_no_extra_spaces: {{ lp_nm_conf_no_extra_spaces }}
      lp_nm_conf:
        {{ lp_nm_conf | to_yaml(indent=2) | indent(2) }}
      lp_nm_services:
        {{ lp_nm_services | to_nice_yaml(indent=2) | indent(2) }}
      lp_nm_mask: {{ lp_nm_mask }}
      lp_nm_service_mask:
        {{ lp_nm_services_mask | to_nice_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Nm: Install packages"
  when: lp_nm_install | bool
  tags: lp_nm_packages
  vars:
    ll_ipkg_list: "{{ lp_nm_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_nm_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: Override Network Manager
  tags: lp_nm_override
  block:

    - name: "Nm: Create /etc/init/network-manager.override"
      when: not lp_nm_enable | bool
      ansible.builtin.template:
        src: network-manager-override.j2
        dest: /etc/init/network-manager.override
        owner: root
        group: root
        mode: "0644"

    - name: "Nm: Remove /etc/init/network-manager.override"
      when: lp_nm_enable | bool
      ansible.builtin.file:
        state: absent
        dest: /etc/init/network-manager.override

- name: "Nm: Configure {{ lp_nm_conf_path }}"
  tags: lp_nm_conf
  community.general.ini_file:
    path: "{{ lp_nm_conf_path }}"
    section: "{{ item.section }}"
    option: "{{ item.key }}"
    value: "{{ item.val }}"
    no_extra_spaces: "{{ lp_nm_conf_no_extra_spaces }}"
    backup: "{{ lp_backup_conf }}"
    mode: "0644"
  loop: "{{ lp_nm_conf }}"

- name: Service enable or disable
  tags: lp_nm_service
  vars:
    srv_name: "{{ lookup('vars', 'lp_' ~ item ~ '_service', default=item) }}"
    srv_enbl: "{{ lookup('vars', 'lp_' ~ item ~ '_enable', default=false) }}"
    srv_stat: "{{ lookup('vars', 'lp_' ~ item ~ '_state', default=default_stat) }}"
    default_stat: "{{ srv_enbl | bool | ternary('started', 'stopped') }}"
    status: "{{ dict(out.results | json_query('[].[name, status.UnitFileState]')) }}"
  block:

    - name: "Nm: Get services status."
      register: out
      ansible.builtin.service:
        name: "{{ srv_name }}"
      loop: "{{ lp_nm_services }}"
      loop_control:
        label: "{{ srv_name }}"

    - name: "Nm: Debug service status lp_nm_debug={{ lp_nm_debug }}"
      when: lp_nm_debug | bool
      ansible.builtin.debug:
        var: status

    - name: "Nm: Services start/stop and enable/disable"
      when: status[srv_name] in ['disabled', 'enabled']
      ansible.builtin.service:
        name: "{{ srv_name }}"
        state: "{{ srv_stat }}"
        enabled: "{{ srv_enbl }}"
      loop: "{{ lp_nm_services }}"
      loop_control:
        label: "{{ srv_name }} state: {{ srv_stat }} enabled: {{ srv_enbl }}"

- name: "Nm: Services mask={{ lp_nm_mask }}"
  tags: lp_nm_mask
  vars:
    srv_name: "{{ lookup('vars', 'lp_' ~ item ~ '_service', default=item) }}"
  ansible.builtin.systemd_service:
    name: "{{ srv_name }}"
    masked: "{{ lp_nm_mask }}"
  loop: "{{ lp_nm_services_mask }}"
  loop_control:
    label: "{{ srv_name }}"

# EOF

nfsd.yml

Synopsis: Configure nfsd

Description of the task.

[tasks/nfsd.yml]

---
# linux_postinstall nfsd

- name: "Nfsd: Debug lp_nfsd_debug={{ lp_nfsd_debug }}"
  when: lp_nfsd_debug | bool
  tags: lp_nfsd_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_nfsd_install: {{ lp_nfsd_install }}
      lp_nfsd_packages:
        {{ lp_nfsd_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Nfsd: Install packages"
  when: lp_nfsd_install | bool
  tags: lp_nfsd_packages
  vars:
    ll_ipkg_list: "{{ lp_nfsd_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_nfsd_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Nfsd: Configure exports"
  tags: lp_nfsd_exports
  notify: reload nfsd
  ansible.builtin.template:
    src: exports.j2
    dest: /etc/exports
    owner: root
    group: root
    mode: "0644"

- name: Service
  tags: lp_nfsd_service
  block:

    - name: "Nfsd: Debug service lp_nfsd_debug={{ lp_nfsd_debug }}"
      when: lp_nfsd_debug | bool
      ansible.builtin.debug:
        var: result

    - name: "Nfsd: Services start/stop and enable/disable"
      register: result
      vars:
        srv_name: "{{ lookup('vars', 'lp_' ~ item ~ '_service', default=item) }}"
        srv_enbl: "{{ lookup('vars', 'lp_' ~ item ~ '_enable', default=false) }}"
        srv_stat: "{{ lookup('vars', 'lp_' ~ item ~ '_state', default=default_stat) }}"
        default_stat: "{{ srv_enbl | bool | ternary('started', 'stopped') }}"
      ansible.builtin.service:
        name: "{{ srv_name }}"
        state: "{{ srv_stat }}"
        enabled: "{{ srv_enbl }}"
      loop: "{{ lp_nfsd_services }}"
      loop_control:
        label: "{{ srv_name }} state: {{ srv_stat }} enabled: {{ srv_enbl }}"

    # - name: "Nfsd: Enable and start nfsd services"
    #   ansible.builtin.service:
    #     name: "{{ item }}"
    #     enabled: true
    #     state: started
    #   loop: "{{ lp_nfsd_services }}"
    #   when: lp_nfsd_enable | bool

    # - name: "Nfsd: Stop and disable nfsd services"
    #   ansible.builtin.service:
    #     name: "{{ item }}"
    #     enabled: false
    #     state: stopped
    #   loop: "{{ lp_nfsd_services }}"
    #   when: not lp_nfsd_enable | bool

# EOF

packages.yml

Synopsis: Manage packages.

Dynamic variables (4)

TBD

Debug (13)

TBD

Install packages automatically (41)

If enabled (52) and not empty (53) import install_package.yml (44) from the role vbotka.linux_lib (43). Flatten and filter unique items in the lists my_packages_auto (46). Set it to the mandatory variable ll_ipkg_list. Optionally, set other variables (47-50).

Install packages (56)

If not empty (66) TBD

Remove packages (69)

TBD

[tasks/packages.yml]

---
# linux_postinstall packages

- name: "Packages: Instantiate dynamic variables"
  tags:
    - lp_packages_debug
    - lp_packages_auto
  ansible.builtin.set_fact:
    my_packages_install: "{{ my_packages_install }}"
    my_packages_lists: "{{ my_packages_lists }}"
    my_packages_auto: "{{ my_packages_auto }}"

- name: "Packages: Debug (lp_packages_debug={{ lp_packages_debug }})"
  when: lp_packages_debug | bool
  tags: lp_packages_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_packages_auto: {{ lp_packages_auto }}
      lp_package_state: {{ lp_package_state }}
      lp_packages_autoremove: {{ lp_packages_autoremove | bool }}
      lp_packages_rescue_end_host: {{ lp_packages_rescue_end_host | bool }}

      lp_packages_selections_preinstall:
        {{ lp_packages_selections_preinstall | to_yaml(indent=2) | indent(2) }}
      lp_packages_install:
        {{ lp_packages_install | to_nice_yaml(indent=2) | indent(2) }}
      lp_packages_remove:
        {{ lp_packages_remove | to_nice_yaml(indent=2) | indent(2) }}
      lp_packages_selections_postinstall:
        {{ lp_packages_selections_postinstall | to_nice_yaml(indent=2) | indent(2) }}
      my_packages_install:
        {{ my_packages_install | to_yaml(indent=2) | indent(2) }}
      my_packages_lists:
        {{ my_packages_lists | to_yaml(indent=2) | indent(2) }}
      my_packages_auto:
        {{ my_packages_auto | to_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Packages: Auto install"
  when:
    - lp_packages_auto | bool
    - my_packages_auto | flatten | length > 0
  tags: lp_packages_auto
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml
  vars:
    ll_ipkg_list: "{{ my_packages_auto | flatten | unique }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_packages_debug | bool }}"

- name: "Packages: Install"
  when: lp_packages_install | length > 0
  tags: lp_packages_install
  vars:
    ll_ipkg_list: "{{ lp_packages_install }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_packages_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: Remove packages
  tags: lp_packages_remove
  block:

    - name: "Packages: Remove"
      ansible.builtin.package:
        name: "{{ item }}"
        state: "{{ lp_package_state_remove }}"
      loop: "{{ lp_packages_remove }}"
      register: result
      retries: "{{ lp_install_retries }}"
      delay: "{{ lp_install_delay }}"
      until: result is succeeded

    - name: "Packages: Debug result lp_packages_debug={{ lp_packages_debug }}"
      when: lp_packages_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

passwords.yml

Synopsis: Configure passwords

Description of the task.

[tasks/passwords.yml]

---
# linux_postinstall passwords

- name: "Passwords: Debug lp_passwords_debug={{ lp_passwords_debug }}"
  when: lp_passwords_debug | bool
  tags: lp_passwords_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_passwords_fail_gracefully: {{ lp_passwords_fail_gracefully }}
      lp_passwords_update_password: {{ lp_passwords_update_password }}
      lp_users:
      {% if lp_passwords_debug_classified | bool %}
        {{ lp_users | d([]) | to_nice_yaml(indent=2) | indent(2) }}
      {% else %}
      {% for user in lp_users | d([]) %}
        - userpass: ************
      {% for k, v in user.items() %}
      {% if k not in ['userpass'] %}
          {{ k }}: {{ v }}
      {% endif %}
      {% endfor %}
      {% endfor %}
      {% endif %}

      lp_passwordstore: {{ lp_passwordstore }}
      lp_passwordstore_install: {{ lp_passwordstore_install }}
      lp_passwordstore_debug: {{ lp_passwordstore_debug }}
      lp_passwordstore_backup: {{ lp_passwordstore_backup }}
      lp_passwordstore_create: {{ lp_passwordstore_create }}
      lp_passwordstore_length: {{ lp_passwordstore_length }}
      lp_passwordstore_nosymbols: {{ lp_passwordstore_nosymbols }}
      lp_passwordstore_overwrite: {{ lp_passwordstore_overwrite }}
      lp_passwordstore_passwordstore: {{ lp_passwordstore_passwordstore }}
      lp_passwordstore_returnall : {{ lp_passwordstore_returnall }}
      lp_passwordstore_subkey: {{ lp_passwordstore_subkey }}
      lp_passwordstore_idempotent_password_hash: {{ lp_passwordstore_idempotent_password_hash }}
      lp_passwordstore_packages:
        {{ lp_passwordstore_packages | to_nice_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: Passwordstore
  when: lp_passwordstore | bool
  tags: lp_passwords_passwordstore
  block:

    - name: "Passwords: Passwordstore: Install packages"
      ansible.builtin.package:
        name: "{{ item }}"
      loop: "{{ lp_passwordstore_packages + lp_gpg_packages + lp_gpg_packages_extra }}"
      delegate_to: localhost
      run_once: true
      when: lp_passwordstore_install | bool

    - name: "Passwords: Passwordstore: Retrieve, create, or update userpass"
      register: result
      vars:
        al_pws_debug: "{{ lp_passwordstore_debug }}"
        al_pws_backup: "{{ lp_passwordstore_backup }}"
        al_pws_create: "{{ lp_passwordstore_create }}"
        al_pws_length: "{{ lp_passwordstore_length }}"
        al_pws_nosymbols: "{{ lp_passwordstore_nosymbols }}"
        al_pws_overwrite: "{{ lp_passwordstore_overwrite }}"
        al_pws_passwordstore: "{{ lp_passwordstore_passwordstore }}"
        al_pws_returnall: "{{ lp_passwordstore_returnall }}"
        al_pws_subkey: "{{ lp_passwordstore_subkey }}"
        al_pws_idempotent_password_hash: "{{ lp_passwordstore_idempotent_password_hash }}"
        al_pws_query: "{{ lp_users }}"
      ansible.builtin.include_role:
        name: vbotka.ansible_lib
        tasks_from: al_pws_user_host.yml

    - name: "Passwords: Passwordstore: Create empty list my_passwords"
      ansible.builtin.set_fact:
        my_passwords: []
      no_log: true # no-log-password password should not be logged.

    - name: "Passwords: Passwordstore: Create my_passwords"
      ansible.builtin.set_fact:
        my_passwords: "{{ my_passwords +
                          [item | dict2items | rejectattr('key', 'equalto', 'userpass') | list |
                                  items2dict | combine({'update_password': lp_passwords_update_password})] }}"
      loop: "{{ al_pws_query_result }}"
      loop_control:
        label: "{{ item.name }}"
      no_log: true # no-log-password password should not be logged.

    - name: "Passwords: Passwordstore: Debug my_passwordsg lp_passwords_debug={{ lp_passwords_debug }}"
      when: lp_passwords_debug | bool
      ansible.builtin.debug:
        var: my_passwords

    - name: "Passwords:  Passwordstore: Include users"
      vars:
        lp_users: "{{ my_passwords }}"
      ansible.builtin.include_tasks:
        file: users.yml
        apply:
          tags: lp_passwords_passwordstore

  rescue:

    - name: "Passwords: Passwordstore: Debug fail lp_passwords_debug_classified={{ lp_passwords_debug_classified }}"
      when: lp_passwords_debug_classified | bool
      ansible.builtin.debug:
        var: result

    - name: "Passwords: Passwordstore: Fail"
      when: not lp_passwords_fail_gracefully | bool
      ansible.builtin.fail:
        msg: "[ERR] Passwordstore failed."

#  EOF

pm_utils.yml

Synopsis: Configure pm_utils

Description of the task.

[tasks/pm_utils.yml]

---
# linux_postinstall pm_utils

# TODO:
# 1) add variables: lp_pm_powerd, lp_pm_configd
# 2) add templates: pm-powerd.j2, pm-configd.j2
# 3) add cases: resume, thaw, suspend, hibernate
# 4) install pm_utils

- name: "Pm_utils: Configure /etc/pm/sleep.d"
  ansible.builtin.template:
    src: pm-sleepd.j2
    dest: /etc/pm/sleep.d/{{ item.value.file }}
    owner: root
    group: root
    mode: "0755"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_pm_sleepd | d({}) | dict2items | selectattr('value.file') }}"

# EOF

postfix.yml

Synopsis: Configure postfix

Description of the task.

[tasks/postfix.yml]

---
# linux_postinstall postfix

- name: "Postfix: Debug lp_postfix_debug={{ lp_postfix_debug }}"
  when: lp_postfix_debug | bool
  tags: lp_postfix_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_postfix_install: {{ lp_postfix_install }}
      lp_postfix_enable: {{ lp_postfix_enable }}
      lp_postfix_flush_handlers: {{ lp_postfix_flush_handlers }}
      lp_postfix_rescue_end_host: {{ lp_postfix_rescue_end_host }}
      lp_postfix_service: {{ lp_postfix_service }}
      lp_postfix_main_conf:
        {{ lp_postfix_main_conf | to_yaml(indent=2) | indent(2) }}
      lp_postfix_packages:
        {{ lp_postfix_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Postfix: Install packages"
  when: lp_postfix_install | bool
  tags: lp_postfix_packages
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml
  vars:
    ll_ipkg_list: "{{ lp_postfix_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_postfix_debug | bool }}"

- name: "Chrony: Configure, enable, start, or disable postfix"
  block:

    - name: "Postfix: Configure /etc/postfix/main.cf"
      tags: lp_postfix_conf
      notify: reload postfix
      ansible.builtin.lineinfile:
        dest: /etc/postfix/main.cf
        regexp: ^\s*{{ item.key }}\s*=\s*(.*)$
        line: "{{ item.key }} = {{ item.value }}"
        backup: "{{ lp_backup_conf }}"
        create: true
        mode: "0644"
      loop: "{{ lp_postfix_main_conf }}"
      loop_control:
        label: "{{ item.key }}: {{ item.value }}"

    - name: "Postfix: Service {{ state ~ ' and ' ~ enable }}"
      tags: lp_postfix_service
      register: result
      vars:
        enabled: "{{ lp_postfix_enable | bool | d(false) }}"
        state: "{{ lp_postfix_state | d(default_state) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_postfix_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Postfix: Debug service lp_postfix_debug={{ lp_postfix_debug }}"
      when: lp_postfix_debug | bool
      tags: lp_postfix_service
      ansible.builtin.debug:
        var: result

  rescue:

    - name: "Postfix: Print errors"
      ansible.builtin.debug:
        msg: |
          [ERR] task {{ ansible_failed_task.name }} failed. End host.
          ansible_failed_task:
            {{ ansible_failed_task | to_yaml(indent=2) | indent(2) }}
          ansible_failed_result:
            {{ ansible_failed_result | to_yaml(indent=2) | indent(2) }}

    - name: "Postfix: End host"
      when: lp_postfix_rescue_end_host | bool
      ansible.builtin.meta: end_host

    - name: "Postfix: Clear host errors"
      ansible.builtin.meta: clear_host_errors

- name: "Postfix: Flush handlers"
  when: lp_postfix_flush_handlers | bool
  ansible.builtin.meta: flush_handlers

# EOF

rc_local.yml

Synopsis: Configure rc_local

Description of the task.

[tasks/rc_local.yml]

---
# linux_postinstall rc_local

- name: "Rc_local: Debug lp_rc_local_debug={{ lp_rc_local_debug }}"
  when: lp_rc_local_debug | bool
  tags: lp_rc_local_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_rc_local_service: {{ lp_rc_local_service }}
      lp_rc_local_state: {{ lp_rc_local_state }}
      lp_rc_local_template: {{ lp_rc_local_template }}
      lp_rc_local_file: {{ lp_rc_local_file }}
      lp_rc_local_owner: {{ lp_rc_local_owner }}
      lp_rc_local_group: {{ lp_rc_local_group }}
      lp_rc_local_mode: {{ lp_rc_local_mode }}
      lp_rc_local_content:
        {{ lp_rc_local_content | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Rc_local: Manage service {{ lp_rc_local_service }}"
  tags: lp_rc_local_service
  ansible.builtin.service:
    name: "{{ lp_rc_local_service }}"
    state: "{{ lp_rc_local_state }}"

- name: "Rc_local: Create /etc/rc.local"
  tags: lp_rc_local_file
  notify: restart rc-local
  ansible.builtin.template:
    src: "{{ lp_rc_local_template }}"
    dest: "{{ lp_rc_local_file }}"
    owner: "{{ lp_rc_local_owner }}"
    group: "{{ lp_rc_local_group }}"
    mode: "{{ lp_rc_local_mode }}"
    backup: "{{ lp_backup_conf }}"

# EOF

reboot.yml

Synopsis: Configure reboot

Description of the task.

[tasks/reboot.yml]

---
# linux_postinstall reboot

- name: "Reboot Debug lp_reboot_debug={{ lp_reboot_debug }}"
  when: lp_reboot_debug | bool
  tags: lp_reboot_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_reboot_force: {{ lp_reboot_force }}
      lp_reboot_required_ignore: {{ lp_reboot_required_ignore }}
      lp_reboot_required_file: {{ lp_reboot_required_file }}
      lp_reboot_command: {{ lp_reboot_command }}
      lp_reboot_wait_connect_timeout: {{ lp_reboot_wait_connect_timeout }}
      lp_reboot_wait_sleep: {{ lp_reboot_wait_sleep }}
      lp_reboot_wait_delay: {{ lp_reboot_wait_delay }}
      lp_reboot_wait_timeout: {{ lp_reboot_wait_timeout }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Reboot: Debian test {{ lp_reboot_required_file }}"
  when: ansible_os_family == 'Debian'
  block:

    - name: "Reboot: Stat {{ lp_reboot_required_file }}"
      register: reboot_required_file_status
      ansible.builtin.stat:
        path: "{{ lp_reboot_required_file }}"

    - name: "Reboot: Set reboot_required"
      ansible.builtin.set_fact:
        reboot_required: "{{ reboot_required_file_status.exists | d(false) }}"

- name: "Reboot: RedHat test {{ lp_reboot_required_command }}"
  when: ansible_os_family == 'RedHat'
  block:

    - name: "Reboot: Run {{ lp_reboot_required_command }}"
      register: reboot_required_cmd_status
      ansible.builtin.command: # noqa: no-changed-when
        cmd: >
          {{ lp_reboot_required_command }}

    - name: "Reboot: Set reboot_required"
      ansible.builtin.set_fact:
        reboot_required: "{{ (reboot_required_cmd_status.rc != 0) | ternary(true, false) }}"

- name: "Reboot: Debug reboot_required lp_reboot_debug={{ lp_reboot_debug }}"
  when: lp_reboot_debug | bool
  ansible.builtin.debug:
    var: reboot_required

- name: "Reboot: Reboot and wait for connection"
  when:
    - reboot_required | d(false)
    - (not lp_reboot_required_ignore) or lp_reboot_force | bool
  ansible.builtin.reboot:
    connect_timeout: "{{ lp_reboot_wait_connect_timeout }}"
    post_reboot_delay: "{{ lp_reboot_wait_delay }}"
    reboot_timeout: "{{ lp_reboot_wait_timeout }}"

# - name: "Reboot: Reboot and wait for connection"
#   when: (reboot_required | d(false) and not lp_reboot_required_ignore) or lp_reboot_force
#   block:
#
#     - name: "reboot: Reboot"
#       shell: "{{ lp_reboot_command }}"
#       async: 1
#       poll: 0
#
#     - name: "reboot: Wait for connection"
#       wait_for_connection:
#         connect_timeout: "{{ lp_reboot_wait_connect_timeout }}"
#         sleep: "{{ lp_reboot_wait_sleep }}"
#         delay: "{{ lp_reboot_wait_delay }}"
#         timeout: "{{ lp_reboot_wait_timeout }}"

# EOF

repos.yml

Synopsis: Configure repos

Description of the task.

[tasks/repos.yml]

---
# linux_postinstall repos

- name: "Repos: Debug lp_repos_debug={{ lp_repos_debug }}"
  when: lp_repos_debug | bool
  tags: lp_repos_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_repos_keys:
        {{ lp_repos_keys | to_nice_yaml(indent=2) | indent(2) }}
      lp_repos:
        {{ lp_repos | to_nice_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: Manage repo signing keys
  tags: lp_repos_keys_manage
  block:

    - name: "Repos: Manage repo signing keys"
      ansible.builtin.apt_key:
        data: "{{ item.data | d(omit) }}"
        file: "{{ item.file | d(omit) }}"
        id: "{{ item.id | d(omit) }}"
        keyring: "{{ item.keyring | d(omit) }}"
        keyserver: "{{ item.keyserver | d(omit) }}"
        state: "{{ item.state | d(omit) }}"
        url: "{{ item.url | d(omit) }}"
        validate_certs: "{{ item.validate_certs | d(omit) }}"
      loop: "{{ lp_repos_keys }}"
      register: result
      retries: "{{ lp_install_retries }}"
      until: result is succeeded
      delay: "{{ lp_install_delay }}"

    - name: "Repos: Debug manage repo signing keys lp_repos_debug={{ lp_repos_debug }}"
      when: lp_repos_debug | bool
      ansible.builtin.debug:
        var: result

- name: Manage repositories
  tags: lp_repos_manage
  block:

    - name: "Repos: Manage repositories"
      register: result
      ansible.builtin.apt_repository:
        codename: "{{ item.codename | d(omit) }}"
        filename: "{{ item.filename | d(omit) }}"
        mode: "{{ item.mode | d(omit) }}"
        repo: "{{ item.repo | mandatory }}"
        state: "{{ item.state | d(omit) }}"
        update_cache: "{{ item.update_cache | d(omit) }}"
        validate_certs: "{{ item.validate_certs | d(omit) }}"
      loop: "{{ lp_repos }}"
      loop_control:
        label: "{{ item.repo }}"

    - name: "Repos: Debug manage repositories lp_repos_debug={{ lp_repos_debug }}"
      when: lp_repos_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

resolvconf.yml

Synopsis: Configure resolvconf

Description of the task.

[tasks/resolvconf.yml]

---
# linux_postinstall resolvconf

- name: "Resolvconf: Debug lp_resolvconf_debug={{ lp_resolvconf_debug }}"
  when: lp_resolvconf_debug | bool
  tags: lp_resolvconf_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_resolvconf_service: {{ lp_resolvconf_service }}
      lp_resolvconf_enable: {{ lp_resolvconf_enable }}
      lp_package_state: {{ lp_package_state }}
      lp_resolvconf_install: {{ lp_resolvconf_install }}
      lp_resolvconf_packages:
        {{ lp_resolvconf_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_resolvconf_conf_owner: {{ lp_resolvconf_conf_owner }}
      lp_resolvconf_conf_group: {{ lp_resolvconf_conf_group }}
      lp_resolvconf_conf_mode: {{ lp_resolvconf_conf_mode }}
      lp_resolvconf_conf:
        {{ lp_resolvconf_conf | to_nice_yaml(indent=2) | indent(2) }}
      lp_resolvconf_confd_head:
        {{ lp_resolvconf_confd_head | to_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Resolvconf: Install packages"
  when: lp_resolvconf_install | bool
  tags: lp_resolvconf_packages
  vars:
    ll_ipkg_list: "{{ lp_resolvconf_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_resolvconf_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Resolvconf: Configure lp_resolvconf_conf"
  tags: lp_resolvconf_confd_head
  notify: restart resolvconf
  ansible.builtin.template:
    src: "{{ item.src }}"
    dest: "{{ item.dest }}"
    owner: "{{ item.owner }}"
    group: "{{ item.group }}"
    mode: "{{ item.mode }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_resolvconf_conf }}"
  loop_control:
    label: "{{ item.dest }}"

- name: Service
  tags: lp_resolvconf_service
  block:

    - name: "Resolvconf: Service {{ state ~ ' and ' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_resolvconf_enable | bool | d(false) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        state: "{{ lp_resolvconf_state | d(default_state) }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_resolvconf_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Resolvconf: Debug service lp_resolvconf_debug={{ lp_resolvconf_debug }}"
      when: lp_resolvconf_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

service.yml

Synopsis: Manage services.

Debug (4)

TBD

Sanity (23)

TBD

Automatic management of listed services (74)

When not empty (75) iterate my_services_varnames (97) (See default s/main/service.yml). Skip when run_task (80) is not True.

Manual management of listed services (104)

When not empty (105) iterate lp_service in the included tasks (115). When auto (110) set the module (112) to ansible_service_mgr (OS native service manager found by the setup). TBC

Flush handlers (117)

Automatic management of listed services notifies ansible_service_mgr. See the tasks service-*.yml how manual management options notify handlers.

[tasks/service.yml]

---
# linux_postinstall service

- name: "Service: Debug lp_service_debug={{ lp_service_debug }}"
  when: lp_service_debug | bool
  tags: lp_service_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      ansible_service_mgr: {{ ansible_facts['service_mgr'] }}
      lp_service_sanity: {{ lp_service_sanity }}

      lp_service_module: {{ lp_service_module }}
      lp_service_module_valid: {{ lp_service_module_valid }}

      lp_service:
        {{ lp_service | to_nice_yaml(indent=2) | indent(2) }}
      lp_service_auto:
        {{ lp_service_auto | to_nice_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: Sanity
  when: lp_service_sanity | bool
  tags: lp_service_sanity
  block:

    - name: "Service: Get service facts"
      ansible.builtin.service_facts:

    - name: "Service: Debug my_services_* lp_service_debug2={{ lp_service_debug2 }}"
      when: lp_service_debug2 | bool
      vars:
        my_services_alias: "{{ lp_service_auto }}"
        msg: |-
          my_services_regex: {{ my_services_regex }}
          my_services_all: {{ my_services_all | to_yaml }}
          my_services_varnames:
            {{ my_services_varnames | to_nice_yaml(indent=2) | indent(2) }}
          my_services_names:
            {{ my_services_names | to_nice_yaml(indent=2) | indent(2) }}
          my_services_undef:
            {{ my_services_undef | to_nice_yaml(indent=2) | indent(2) }}
      ansible.builtin.debug:
        msg: "{{ '{}'.format(msg) }}"

    - name: "Service: Sanity lp_service_auto items are defined"
      when: lp_service_auto | length > 0
      vars:
        my_services_alias: "{{ lp_service_auto }}"
      ansible.builtin.assert:
        that: my_services_undef | length == 0
        fail_msg: "[ERR] Undefined services: {{ my_services_undef }}"
        success_msg: "[OK]  All service names in lp_service_auto are valid."
        quiet: "{{ lp_service_sanity_quiet }}"

    - name: "Service: Sanity lp_service names are defined"
      when: lp_service | length > 0
      vars:
        my_services_alias: "{{ lp_service | map(attribute='name') }}"
      ansible.builtin.assert:
        that: my_services_undef | length == 0
        fail_msg: "[ERR] Undefined services: {{ my_services_undef }}"
        success_msg: "[OK]  All service names in lp_service are valid."
        quiet: "{{ lp_service_sanity_quiet }}"

    - name: "Service: Sanity lp_service_module"
      ansible.builtin.assert:
        that: lp_service_module in lp_service_module_valid
        fail_msg: "[ERR] {{ lp_service_module }} not in {{ lp_service_module_valid }}"
        success_msg: "[OK]  {{ lp_service_module }} is valid value of lp_service_module."
        quiet: "{{ lp_service_sanity_quiet }}"

- name: Automatic management of services
  when: lp_service_auto | length > 0
  tags: lp_service_auto
  block:

    - name: "Service: Automatic management of services"
      when: run_task | bool
      register: result
      notify: reload {{ ansible_facts['service_mgr'] }} daemon
      vars:
        my_services_alias: "{{ lp_service_auto }}"
        vbase: "{{ item | reverse | replace('ecivres_', '', 1) | reverse }}"
        run_task: "{{ lookup('vars', vbase, default=false) }}"
        srv_name: "{{ lookup('vars', vbase ~ '_service', default=item) }}"
        srv_enbl: "{{ lookup('vars', vbase ~ '_enable', default=false) }}"
        use_modl: "{{ lookup('vars', vbase ~ '_module', default='auto') }}"
        srv_stat: "{{ lookup('vars', vbase ~ '_state', default=default_state) }}"
        default_state: "{{ srv_enbl | bool | ternary('started', 'stopped') }}"
      ansible.builtin.service:
        name: "{{ srv_name }}"
        state: "{{ srv_stat }}"
        enabled: "{{ srv_enbl | bool }}"
        use: "{{ use_modl }}"
      loop: "{{ my_services_varnames }}"
      loop_control:
        label: "{{ srv_name }} enabled={{ srv_enbl }} state={{ srv_stat }} use={{ use_modl }}"

    - name: "Service: Debug"
      ansible.builtin.include_tasks: fn/service-debug.yml

- name: Manual management of services
  when: lp_service | length > 0
  tags: lp_service_manual
  block:

    - name: "Service: Manual management set module auto"
      when: lp_service_module == 'auto'
      ansible.builtin.set_fact:
        lp_service_module: "{{ ansible_facts['service_mgr'] }}"

    - name: "Service: Include {{ lp_service_module }}"
      ansible.builtin.include_tasks: fn/service-{{ lp_service_module }}.yml

- name: "Service: Flush handlers"
  tags:
    - lp_service_auto
    - lp_service_manual
  ansible.builtin.meta: flush_handlers

# EOF

service-service.yml

Synopsis: Configure service-service

Description of the task.

[tasks/fn/service-service.yml]

---
# linux_postinstall function service-service

- name: "Service: Manual management of services"
  register: result
  notify: reload {{ ansible_facts['service_mgr'] }} daemon
  ansible.builtin.service:
    name: "{{ item.name }}"
    arguments: "{{ item.arguments | d(omit) }}"
    enabled: "{{ item.enabled | d(omit) }}"
    pattern: "{{ item.pattern | d(omit) }}"
    runlevel: "{{ item.runlevel | d(omit) }}"
    sleep: "{{ item.sleep | d(omit) }}"
    state: "{{ item.state | d(omit) }}"
    use: "{{ item.use | d(omit) }}"
  loop: "{{ lp_service }}"
  loop_control:
    label: >-
      {{ item.name }}
      enabled={{ item.enabled | d('UNDEFINED') }}
      state={{ item.state | d('UNDEFINED') }}
      use={{ item.use | d('UNDEFINED') }}

- name: "Service: Debug Manual management full results lp_service_debug2={{ lp_service_debug2 }}"
  when: lp_service_debug2 | d(false) | bool
  ansible.builtin.debug:
    var: result

- name: "Service: Debug Manual management results lp_service_debug2={{ lp_service_debug2 }}"
  when: lp_service_debug2 | d(false) | bool
  ansible.builtin.debug:
    msg: |
      {% for i in result.results %}
      # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      changed: {{ i.changed }}
      name: {{ i.name | d('UNDEFINED') }}
      enabled: {{ i.enabled | d('UNDEFINED') }}
      state: {{ i.state | d('UNDEFINED') }}
      msg: {{ i.msg | d('UNDEFINED') }}

      invocation:
        {{ i.invocation.module_args | to_nice_yaml(indent=2) | indent(2) }}
      item:
        {{ i.item | to_nice_yaml(indent=2) | indent(2) }}
      {% endfor %}

# EOF

service-systemd.yml

Synopsis: Configure service-systemd

Description of the task.

[tasks/fn/service-systemd.yml]

---
# linux_postinstall function service-systemd

# https://docs.ansible.com/ansible/latest/collections/ansible/builtin/systemd_service_module.html#notes
# Quoting from Notes: The order of execution when having multiple
# properties is to first enable/disable, then mask/unmask and then
# deal with service state. It has been reported that systemctl can
# behave differently depending on the order of operations if you do
# the same manually.

- name: Service systemd
  module_defaults:
    ansible.builtin.systemd:
      name: "{{ item.name | d(omit) }}"
      daemon_reexec: "{{ item.daemon_reexec | d(omit) }}"
      daemon_reload: "{{ item.daemon_reload | d(omit) }}"
      enabled: "{{ item.enabled | d(omit) }}"
      force: "{{ item.force | d(omit) }}"
      masked: "{{ item.masked | d(omit) }}"
      no_block: "{{ item.no_block | d(omit) }}"
      scope: "{{ item.scope | d(omit) }}"
      state: "{{ item.state | d(omit) }}"
  vars:
    _enabld: "{{ lp_service | selectattr('enabled', 'defined') | community.general.remove_keys(target=['masked', 'state']) }}"
    _masked: "{{ lp_service | selectattr('masked', 'defined') | community.general.remove_keys(target=['state']) }}"
    enabled: "{{ item.enabled | d('UNDEFINED') }}"
    masked: "{{ item.masked | d('UNDEFINED') }}"
    state: "{{ item.state | d('UNDEFINED') }}"
  block:

    - name: "Service:systemd: enable/disable"
      register: result
      notify: reload systemd daemon
      ansible.builtin.systemd:
      loop: "{{ _enabld }}"
      loop_control:
        label: "{{ item.name }} enabled={{ enabled }}"

    - name: "Service:systemd: Debug"
      when: _enabld | length > 0
      ansible.builtin.include_tasks: fn/service-debug.yml

    - name: "Service:systemd: Flush handlers"
      when: _enabld | length > 0
      ansible.builtin.meta: flush_handlers

    - name: "Service:systemd: mask/unmask"
      register: result
      notify: reload systemd daemon
      ansible.builtin.systemd:
      loop: "{{ _masked }}"
      loop_control:
        label: "{{ item.name }} enabled={{ enabled }} masked={{ masked }}"

    - name: "Service:systemd: Debug"
      when: _masked | length > 0
      ansible.builtin.include_tasks: fn/service-debug.yml

    - name: "Service:systemd: Flush handlers"
      when: _masked | length > 0
      ansible.builtin.meta: flush_handlers

    - name: "Service:systemd: all"
      register: result
      notify: reload systemd daemon
      ansible.builtin.systemd:
      loop: "{{ lp_service }}"
      loop_control:
        label: "{{ item.name }} enabled={{ enabled }} masked={{ masked }} state={{ state }}"

    - name: "Service:systemd: Debug"
      when: lp_service | length > 0
      ansible.builtin.include_tasks: fn/service-debug.yml

# EOF

service-sysvinit.yml

Synopsis: Configure service-sysvinit

Description of the task.

[tasks/fn/service-sysvinit.yml]

---
# linux_postinstall function service-sysvinit

- name: Service:sysvinit debug
  ansible.builtin.debug:
    msg: "[WARNING] Not implemented yet. End host."

- name: Service:sysvinit meta
  ansible.builtin.meta: end_host

# EOF

service-debug.yml

Synopsis: Configure service-debug

Description of the task.

[tasks/fn/service-debug.yml]

---
# linux_postinstall function service-debug

- name: "Service: Debug management full results lp_service_debug2={{ lp_service_debug2 }}"
  when: lp_service_debug2 | d(false) | bool
  ansible.builtin.debug:
    var: result

- name: "Service: Debug management selected results lp_service_debug2={{ lp_service_debug2 }}"
  when: lp_service_debug2 | d(false) | bool
  ansible.builtin.debug:
    msg: |
      {% for i in result.results %}
      # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      changed: {{ i.changed }}
      item:
        {{ i.item | to_nice_yaml(indent=2) | indent(2) }}
      {% if i.skipped | d(false) %}
      skip_reason: {{ i.skip_reason }}
      {% else %}
      name: {{ i.name | d('UNDEFINED') }}
      enabled: {{ i.enabled | d('UNDEFINED') }}
      state: {{ i.state | d('UNDEFINED') }}
      msg: {{ i.msg | d('UNDEFINED') }}
      invocation:
        {{ i.invocation.module_args | to_nice_yaml(indent=2) | indent(2) }}
      {% endif %}
      {% endfor %}

# EOF

smart.yml

Synopsis: Configure smart

Description of the task.

[tasks/smart.yml]

---
# linux_postinstall smart

- name: "Smart: Debug lp_smart_debug={{ lp_smart_debug }}"
  when: lp_smart_debug | bool
  tags: lp_smart_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_smart_install: {{ lp_smart_install }}
      lp_smart_packages:
        {{ lp_smart_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Smart: Install packages"
  when: lp_smart_install | bool
  tags: lp_smart_packages
  vars:
    ll_ipkg_list: "{{ lp_smart_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_smart_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: Configure lp_smart_conf_file
  tags: lp_smart_conf
  notify: reload smart
  block:

    - name: "Smart: Do not scan for devices. Configure {{ lp_smart_conf_file }}"
      when: not lp_smart_devicescan | bool
      ansible.builtin.lineinfile:
        state: absent
        dest: "{{ lp_smart_conf_file }}"
        regexp: ^\s*DEVICESCAN\s*(.*)$
        owner: "{{ lp_smart_conf_owner }}"
        group: "{{ lp_smart_conf_group }}"
        mode: "{{ lp_smart_conf_mode }}"
        backup: "{{ lp_backup_conf }}"
        create: true

    - name: "Smart: Configure devices in {{ lp_smart_conf_file }}"
      ansible.builtin.lineinfile:
        dest: "{{ lp_smart_conf_file }}"
        regexp: "{{ item.regexp }}"
        line: "{{ item.line }}"
        owner: "{{ lp_smart_conf_owner }}"
        group: "{{ lp_smart_conf_group }}"
        mode: "{{ lp_smart_conf_mode }}"
        backup: "{{ lp_backup_conf }}"
        create: true
      loop: "{{ lp_smart_devices }}"
      loop_control:
        label: "{{ item.line }}"

- name: Service
  tags: lp_smart_service
  block:

    - name: "Smart: Service {{ state ~ ' and ' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_smart_enable | bool | d(false) }}"
        state: "{{ lp_smart_state | d(default_state) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_smart_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Smart: Debug service lp_smart_debug={{ lp_smart_debug }}"
      when: lp_smart_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

snap.yml

Synopsis: Configure snap

Description of the task.

[tasks/snap.yml]

---
# linux_postinstall snap

- name: "Snap: Debug"
  ansible.builtin.debug:
    msg: Not implemented yet.

# [TODO]
#
# https://snapcraft.io/docs/getting-started
# https://www.osnews.com/story/131714/disabling-snaps-in-ubuntu-20-04/
# https://www.kevin-custer.com/blog/disabling-snaps-in-ubuntu-20-04/
# https://askubuntu.com/questions/1204571/chromium-without-snap

# EOF

speechd.yml

Synopsis: Configure speechd

Description of the task.

[tasks/speechd.yml]

---
# linux_postinstall speechd

- name: "Speechd: Debug lp_speechd_debug={{ lp_speechd_debug }}"
  when: lp_speechd_debug | bool
  ansible.builtin.debug:
    msg: "lp_speechd_enable: {{ lp_speechd_enable }}"

- name: Service speechd
  tags: lp_speechd_service
  block:

    - name: "Speechd: Service {{ state ~ ' and ' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_speechd_enable | bool | d(false) }}"
        state: "{{ lp_speechd_state | d(default_state) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_speechd_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Speechd: Debug service lp_speechd_debug={{ lp_speechd_debug }}"
      when: lp_speechd_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

sshd.yml

Synopsis: Configure sshd

Description of the task.

[tasks/sshd.yml]

---
# linux_postinstall sshd

- name: "Sshd: Debug lp_sshd_debug={{ lp_sshd_debug }}"
  when: lp_sshd_debug | bool
  tags: lp_sshd_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_sshd_enable: {{ lp_sshd_enable }}
      lp_sshd_config_remove_duplicates: {{ lp_sshd_config_remove_duplicates }}
      lp_sshd_config:
        {{ lp_sshd_config | to_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: Configure /etc/ssh/sshd_config
  tags: lp_sshd_config
  notify: reload sshd
  block:

    - name: "Sshd: Remove duplicate parameters from /etc/ssh/sshd_config"
      when: lp_sshd_config_remove_duplicates | bool
      ansible.builtin.replace:
        dest: /etc/ssh/sshd_config
        after: ^\s*{{ item.key }}(?!\S)
        regexp: ^\s*{{ item.key }}(?!\S).*$
        backup: "{{ lp_backup_conf }}"
        validate: "{{ lp_sshd_path }} -t -f %s"
      loop: "{{ lp_sshd_config }}"
      loop_control:
        label: "{{ item.key }}"

    - name: "Sshd: Configure /etc/ssh/sshd_config"
      ansible.builtin.lineinfile:
        dest: /etc/ssh/sshd_config
        regexp: ^\s*{{ item.key }}(?!\S).*$
        line: "{{ item.key }} {{ item.value }}"
        backup: "{{ lp_backup_conf }}"
        validate: "{{ lp_sshd_path }} -t -f %s"
      loop: "{{ lp_sshd_config }}"
      loop_control:
        label: "{{ item.key }}: {{ item.value }}"

- name: Service
  tags: lp_sshd_service
  block:

    - name: "Sshd: Service {{ state ~ ' and ' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_sshd_enable | bool | d(false) }}"
        state: "{{ lp_sshd_state | d(default_state) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_sshd_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Sshd: Debug service lp_sshd_debug={{ lp_sshd_debug }}"
      when: lp_sshd_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

ssh.yml

Synopsis: Configure ssh

Description of the task.

[tasks/ssh.yml]

---
# linux_postinstall ssh

- name: "Ssh: Debug lp_ssh_debug={{ lp_ssh_debug }}"
  when: lp_ssh_debug | bool
  tags: lp_ssh_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_ssh_config:
        {{ lp_ssh_config | to_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Ssh: Configure /etc/ssh/ssh_config"
  tags: lp_ssh_conf
  ansible.builtin.template:
    src: ssh_config.j2
    dest: /etc/ssh/ssh_config
    backup: "{{ lp_backup_conf }}"
    mode: "0644"

# EOF

sudoers.yml

Synopsis: Configure sudoers

Description of the task.

[tasks/sudoers.yml]

---
# linux_postinstall sudoers

- name: "Sudoers: Debug lp_sudoers_debug={{ lp_sudoers_debug }}"
  when: lp_sudoers_debug | bool
  tags: lp_sudoers_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_sudoers_conf:
        {{ lp_sudoers_conf | to_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Sudoers: Configure /etc/sudoers"
  tags: lp_sudoers_conf
  ansible.builtin.lineinfile:
    path: /etc/sudoers
    line: "{{ item.line }}"
    state: "{{ item.state | d('present') }}"
    backup: "{{ lp_backup_conf }}"
    create: true
    mode: "0440"
  loop: "{{ lp_sudoers_conf }}"

- name: "Sudoers: Configure /etc/sudoers.d/01"
  tags: lp_sudoers_dconf
  ansible.builtin.lineinfile:
    path: /etc/sudoers.d/01
    line: "{{ item }}"
    owner: "{{ lp_sudoers_owner }}"
    group: "{{ lp_sudoers_group }}"
    mode: "{{ lp_sudoers_mode }}"
    backup: "{{ lp_backup_conf }}"
    create: true
  loop: "{{ lp_sudoers_01 }}"

# EOF

swap.yml

Synopsis: Configure swap

Description of the task.

[tasks/swap.yml]

---
# linux_postinstall swap

- name: "Swap: Debug lp_swap_debug={{ lp_swap_debug }}"
  when: lp_swap_debug | bool
  tags: lp_swap_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_swap: {{ lp_swap }}
      lp_swap_enable: {{ lp_swap_enable }}
      lp_swap_sanity: {{ lp_swap_sanity }}
      lp_swap_flush_handlers: {{ lp_swap_flush_handlers }}
      lp_swap_rescue_end_host: {{ lp_swap_rescue_end_host }}
      lp_swap_file: {{ lp_swap_file | d("UNDEFINED") }}
      lp_swap_size: {{ lp_swap_size | d("UNDEFINED") }}
      lp_swap_stsize: {{ lp_swap_stsize | d("UNDEFINED") }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: Sanity
  when: lp_swap_sanity | bool
  tags: lp_swap_sanity
  block:

    - name: "Swap: sanity: Defined lp_swap_file"
      ansible.builtin.assert:
        that: lp_swap_file is defined
        fail_msg: "[ERR] Variable lp_swap_file must be defined."

    - name: "Swap: sanity: Defined lp_swap_size and lp_swap_stsize"
      when: lp_swap_enable | bool
      ansible.builtin.assert:
        that: lp_swap_size is defined and lp_swap_stsize is defined
        fail_msg: "[ERR] Variables lp_swap_size and lp_swap_stsize must be defined."

- name: Create or change lp_swap_file
  tags: lp_swap_swapfile
  block:

    - name: "Swap: Create swapfile {{ lp_swap_file }}"
      ansible.builtin.shell:
        cmd: >
          sh -c
          'if [ ! -e {{ lp_swap_file }} ];
          then printf "create";
          fi'
      register: command_result
      changed_when: command_result.stdout == 'create'
      notify: create and mount swap file

    - name: "Swap: Change swapfile {{ lp_swap_file }}"
      ansible.builtin.shell:
        cmd: >
          sh -c
          'if [ -e {{ lp_swap_file }} ] &&
          [ "`stat --format '%s' {{ lp_swap_file }}`" -ne "{{ lp_swap_stsize }}" ];
          then printf "change";
          fi'
      register: command_result
      changed_when: command_result.stdout == 'change'
      notify: change and mount swap file

  rescue:

    - name: "Swap: Print errors"
      ansible.builtin.debug:
        msg: |
          [ERR] task {{ ansible_failed_task.name }} failed. End host.
          ansible_failed_task:
            {{ ansible_failed_task | to_yaml(indent=2) | indent(2) }}
          ansible_failed_result:
            {{ ansible_failed_result | to_yaml(indent=2) | indent(2) }}

    - name: "Swap: End host"
      when: lp_swap_rescue_end_host | bool
      ansible.builtin.meta: end_host

- name: Create or remove swap entry in /etc/fstab
  tags: lp_swap_fstab
  block:

    - name: "Swap: Create swap entry in /etc/fstab"
      when: lp_swap_enable | bool
      ansible.posix.mount:
        path: none
        src: "{{ lp_swap_file }}"
        fstype: swap
        opts: sw
        passno: "0"
        dump: "0"
        state: present
        backup: "{{ lp_backup_conf }}"

    - name: "Swap: Remove swap entry from /etc/fstab"
      when: not lp_swap_enable | bool
      notify: remove swap file
      ansible.posix.mount:
        path: none
        src: "{{ lp_swap_file }}"
        fstype: swap
        opts: sw
        passno: "0"
        dump: "0"
        state: absent
        backup: "{{ lp_backup_conf }}"

  rescue:

    - name: "Swap: Print errors"
      ansible.builtin.debug:
        msg: |
          [ERR] task {{ ansible_failed_task.name }} failed. End host.
          ansible_failed_task:
            {{ ansible_failed_task | to_yaml(indent=2) | indent(2) }}
          ansible_failed_result:
            {{ ansible_failed_result | to_yaml(indent=2) | indent(2) }}

    - name: "Swap: End host"
      when: lp_swap_rescue_end_host | bool
      ansible.builtin.meta: end_host

- name: "Swap: Flush handlers"
  when: lp_swap_flush_handlers | bool
  ansible.builtin.meta: flush_handlers

# EOF

sysctl.yml

Synopsis: Configure sysctl

Description of the task.

[tasks/sysctl.yml]

---
# linux_postinstall sysctl

- name: "Sysctl: Debug lp_sysctl_debug={{ lp_sysctl_debug }}"
  when: lp_sysctl_debug | bool
  tags: lp_sysctl_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_sysctl_owner: {{ lp_sysctl_owner }}
      lp_sysctl_group: {{ lp_sysctl_group }}
      lp_sysctl_mode: {{ lp_sysctl_mode }}
      lp_sysctl_no_extra_spaces: {{ lp_sysctl_no_extra_spaces }}
      lp_sysctl_vars:
        {{ lp_sysctl_vars | to_yaml(indent=2) | indent(2) }}
      lp_sysctld_root: {{ lp_sysctld_root }}
      lp_sysctld_template: {{ lp_sysctld_template }}
      lp_sysctld_conf:
        {{ lp_sysctld_conf | to_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Sysctl: Configure /etc/sysctl.conf"
  notify: load sysctl settings
  tags: lp_sysctl_conf
  ansible.builtin.lineinfile:
    dest: /etc/sysctl.conf
    create: true
    mode: "0644"
    regexp: ^\s*{{ item.var }}\s*=(.*)$
    line: "{{ item.var }}{{ lp_sysctl_extra_space }}={{ lp_sysctl_extra_space }}{{ item.value }}"
    state: "{{ item.state | d(omit) }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_sysctl_vars }}"
  loop_control:
    label: "{{ item.var }}: {{ item.value }} {{ item.state | d('present') }}"

- name: "Sysctl: Configure files in {{ lp_sysctld_root }}"
  notify: load sysctl system
  tags: lp_sysctld_conf
  ansible.builtin.template:
    src: "{{ lp_sysctld_template }}"
    dest: "{{ lp_sysctld_root }}/{{ item.file }}"
    owner: "{{ item.owner | d(lp_sysctl_owner) }}"
    group: "{{ item.group | d(lp_sysctl_group) }}"
    mode: "{{ item.mode | d(lp_sysctl_mode) }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_sysctld_conf }}"
  loop_control:
    label: "{{ item.file }}"

# EOF

systemd.yml

Synopsis: Configure systemd.

Set my_services (4)

Iterate lp_systemd_unit (24) and create dictionary my_services. It will be used by handlers to decide if and how to reload or restart services

my_services:
  <name>.<type | d(lp_systemd_unit_type)>:
    state: <control.state | d('started')>
    restart_or_reload: <control.restart_or_reload | d('reload')>
...

Debug (28)

To see the values of the variables run the playbook with options -t lp_systemd_debug -e lp_systemd_debug=True (29).

Packages (54)

Install packages when enabled (55).

Configure systemd (67)

Use community.general.ini_file (72) to configure files in loop (83). Register lp_systemd_conf_changes (82) and notify handler reload systemd conf (72).

lp_systemd_conf:
  <path>:
    owner: <owner | d(lp_systemd_owner)>
    group: <group | d(lp_systemd_group)>
    mode: <mode | d(lp_systemd_mode)>
    reload_service: <service to be reloaded or restarted by handler>
    conf:
      - {section: <section>, key: <option>, val: <value>}
  ...

Create units (105)

Use `` ansible.builtin.template`` (112) to create units in the loop (120) when state == 'create' (110). Register lp_systemd_unit_create_changes (119) and notify handler reload systemd units (111).

lp_systemd_unit:
  - name: <name of the service>
    type: <type of the service | d(lp_systemd_unit_type)>
    path: <directory of the units | d(lp_systemd_unit_dir)>
    owner: <owner | d(lp_systemd_owner)>
    group: <group | d(lp_systemd_group)>
    mode: <mode | d(lp_systemd_mode)>
    state: <'create' or 'absent' | d('noop')>
  ...

Remove units (129)

<TBD>

Control units (148)

lp_systemd_unit:
  - name: <name of the service>
    type: <type of the service | d(lp_systemd_unit_type)>
    control:
      daemon_reexec: <daemon_reexec | d(omit)>
      daemon_reload: <daemon_reload | d(omit)>
      enabled: <enabled | d(systemd_units_enabled)>
      force: <force | d(omit)>
      masked: <masked | d(omit)>
      no_block: <no_block | d(omit)>
      scope: <scope | d(omit)>
      state: <state | d(omit)>

See also

• Description of Parameters Ansible module systemd

<TBD>

[tasks/systemd.yml]

---
# linux_postinstall systemd

- name: Set my_services
  tags:
    - lp_systemd_debug
    - lp_systemd_packages
    - lp_systemd_conf
  block:

    - name: "Systemd: Create empty my_services"
      ansible.builtin.set_fact:
        my_services: {}

    - name: "Systemd: Set my_services"
      vars:
        my_name: "{{ item.name }}.{{ item.type | d(lp_systemd_unit_type) }}"
        my_state: "{{ item.control.state | d('started') }}"
        my_restart_or_reload: "{{ item.control.restart_or_reload | d('reloaded') }}"
      ansible.builtin.set_fact:
        my_services: "{{ my_services |
                         combine({my_name: {'state': my_state,
                                            'restart_or_reload': my_restart_or_reload}}) }}"
      loop: "{{ lp_systemd_unit }}"
      loop_control:
        label: "{{ my_name }}"

- name: "Systemd: Debug lp_systemd_debug={{ lp_systemd_debug }}"
  when: lp_systemd_debug | bool
  tags: lp_systemd_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_systemd_install: {{ lp_systemd_install }}
      lp_systemd_packages:
        {{ lp_systemd_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_systemd_dir: {{ lp_systemd_dir }}
      lp_systemd_owner: {{ lp_systemd_owner }}
      lp_systemd_group: {{ lp_systemd_group }}
      lp_systemd_mode: {{ lp_systemd_mode }}
      lp_systemd_conf_no_extra_spaces: {{ lp_systemd_conf_no_extra_spaces }}
      lp_systemd_conf:
        {{ lp_systemd_conf | to_yaml(indent=2) | indent(2) }}
      lp_systemd_unit_dir: {{ lp_systemd_unit_dir }}
      lp_systemd_unit_type: {{ lp_systemd_unit_type }}
      lp_systemd_unit:
        {{ lp_systemd_unit | to_nice_yaml(indent=2) | indent(2) }}
      my_services:
        {{ my_services | to_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Systemd: Install packages"
  when: lp_systemd_install | bool
  tags: lp_systemd_packages
  vars:
    ll_ipkg_list: "{{ lp_systemd_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_systemd_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: Configure systemd
  tags: lp_systemd_conf
  block:

    - name: "Systemd: Configure systemd"
      register: lp_systemd_conf_changes
      notify: reload systemd conf
      community.general.ini_file:
        path: "{{ item.0.key }}"
        section: "{{ item.1.section }}"
        option: "{{ item.1.key }}"
        value: "{{ item.1.val }}"
        owner: "{{ item.0.value.owner | d(lp_systemd_owner) }}"
        group: "{{ item.0.value.group | d(lp_systemd_group) }}"
        mode: "{{ item.0.value.mode | d(lp_systemd_mode) }}"
        no_extra_spaces: "{{ lp_systemd_conf_no_extra_spaces }}"
        backup: "{{ lp_backup_conf }}"
      loop: "{{ lp_systemd_conf | dict2items | subelements('value.conf') }}"
      loop_control:
        label: "{{ item.0.key }} {{ item.1.section }} {{ item.1.key }} {{ item.1.val }}"

    - name: "Systemd: Debug conf results lp_systemd_debug={{ lp_systemd_debug }}"
      when: lp_systemd_debug | bool
      ansible.builtin.debug:
        msg: "{{ lp_systemd_conf_changes.results }}"

    - name: "Systemd: Debug loop conf results lp_systemd_debug={{ lp_systemd_debug }}"
      when: lp_systemd_debug | bool
      vars:
        my_service: "{{ item.item.0.value.reload_service }}"
        my_state: "{{ my_services[my_service].state | d('started') }}"
        my_restart_or_reload: "{{ my_services[my_service].restart_or_reload | d('reloaded') }}"
      ansible.builtin.debug:
        msg: "{{ my_service }} {{ my_state }} {{ my_restart_or_reload }}"
      loop: "{{ lp_systemd_conf_changes.results | d([]) }}"
      loop_control:
        label: "{{ item.path | d('NA') }}" # 'lp_systemd: false' complains "no attribute 'path'"

- name: Create units
  tags: lp_systemd_unit_create
  block:

    - name: "Systemd: Create units"
      when: item.state | d('noop') == 'create'
      register: lp_systemd_unit_create_changes
      notify: reload systemd units
      ansible.builtin.template:
        src: systemd-unit.j2
        dest: "{{ item.path | d(lp_systemd_unit_dir) }}/{{ item.name }}.{{ item.type | d(lp_systemd_unit_type) }}"
        owner: "{{ item.owner | d(lp_systemd_owner) }}"
        group: "{{ item.group | d(lp_systemd_group) }}"
        mode: "{{ item.mode | d(lp_systemd_mode) }}"
        backup: "{{ lp_backup_conf }}"
      loop: "{{ lp_systemd_unit }}"
      loop_control:
        label: "{{ item.name }}.{{ item.type | d(lp_systemd_unit_type) }}"

    - name: "Systemd: Debug unit create results lp_systemd_debug={{ lp_systemd_debug }}"
      when: lp_systemd_debug | bool
      ansible.builtin.debug:
        var: lp_systemd_unit_create_changes

- name: Remove units
  tags: lp_systemd_unit_remove
  block:

    - name: "Systemd: Remove units"
      when: item.state | d('noop') == 'absent'
      register: lp_systemd_unit_remove_changes
      ansible.builtin.file:
        state: absent
        path: "{{ item.path | d(lp_systemd_unit_dir) }}/{{ item.name }}.{{ item.type | d(lp_systemd_unit_type) }}"
      loop: "{{ lp_systemd_unit }}"
      loop_control:
        label: "{{ item.name }}.{{ item.type | d(lp_systemd_unit_type) }}"

    - name: "Systemd: Debug unit remove results lp_systemd_debug={{ lp_systemd_debug }}"
      when: lp_systemd_debug | bool
      ansible.builtin.debug:
        var: lp_systemd_unit_remove_changes

- name: Control units
  tags: lp_systemd_unit_control
  block:

    - name: "Systemd: Control units"
      when:
        - item.control | d([]) | length > 0
        - not (item.name | regex_search('^(.*)@\.\w+$'))
      register: lp_systemd_unit_control_changes
      ansible.builtin.systemd:
        name: "{{ item.name }}.{{ item.type | d(lp_systemd_unit_type) }}"
        daemon_reexec: "{{ item.control.daemon_reexec | d(omit) }}"
        daemon_reload: "{{ item.control.daemon_reload | d(omit) }}"
        enabled: "{{ item.control.enabled | d(omit) }}"
        force: "{{ item.control.force | d(omit) }}"
        masked: "{{ item.control.masked | d(omit) }}"
        no_block: "{{ item.control.no_block | d(omit) }}"
        scope: "{{ item.control.scope | d(omit) }}"
        state: "{{ item.control.state | d(omit) }}"
      loop: "{{ lp_systemd_unit }}"
      loop_control:
        label: "{{ item.name }}.{{ item.type | d(lp_systemd_unit_type) }}"

    - name: "Systemd: Debug unit control results lp_systemd_debug={{ lp_systemd_debug }}"
      when: lp_systemd_debug | bool
      ansible.builtin.debug:
        var: lp_systemd_unit_control_changes

# EOF

timesyncd.yml

Synopsis: Configure timesyncd

Description of the task.

[tasks/timesyncd.yml]

---
# linux_postinstall timesyncd

- name: "Timesyncd: Debug lp_timesyncd_debug={{ lp_timesyncd_debug }}"
  when: lp_timesyncd_debug | bool
  tags: lp_timesyncd_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      ansible_distribution: {{ ansible_facts['distribution'] }}
      ansible_distribution_version: {{ ansible_facts['distribution_version'] }}
      ansible_distribution_release: {{ ansible_facts['distribution_release'] }}

      lp_backup_conf: {{ lp_backup_conf }}

      lp_timesyncd_install: {{ lp_timesyncd_install }}
      lp_timesyncd_enable: {{ lp_timesyncd_enable }}
      lp_timesyncd_service: {{ lp_timesyncd_service }}
      lp_timesyncd_sanity: {{ lp_timesyncd_sanity }}
      lp_timesyncd_service_exists_fatal: {{ lp_timesyncd_service_exists_fatal }}
      lp_timesyncd_rescue_end_host {{ lp_timesyncd_rescue_end_host }}
      lp_timesyncd_flush_handlers: {{ lp_timesyncd_flush_handlers }}
      lp_timesyncd_conf_file: {{ lp_timesyncd_conf_file }}
      lp_timesyncd_conf_file_orig: {{ lp_timesyncd_conf_file_orig }}
      lp_timesyncd_conf_template: {{ lp_timesyncd_conf_template }}
      lp_timesyncd_ntp: {{ lp_timesyncd_ntp }}
      lp_timesyncd_fallbackntp: {{ lp_timesyncd_fallbackntp }}
      lp_timesyncd_rootdistancemaxsec: {{ lp_timesyncd_rootdistancemaxsec }}
      lp_timesyncd_pollintervalminsec: {{ lp_timesyncd_pollintervalminsec }}
      lp_timesyncd_pollintervalmaxsec: {{ lp_timesyncd_pollintervalmaxsec }}
      lp_timesyncd_connectionretrysec: {{ lp_timesyncd_connectionretrysec }}
      lp_timesyncd_saveintervalsec: {{ lp_timesyncd_saveintervalsec }}
      lp_timesyncd_packages:
        {{ lp_timesyncd_packages | to_nice_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: Sanity
  when: lp_timesyncd_sanity | bool
  tags: lp_timesyncd_sanity
  block:

    - name: "Timesyncd: sanity: Assert chrony and timesyncd packages mutually exclusive."
      ansible.builtin.assert:
        that: not (lp_chrony_install | bool and lp_timesyncd_install | bool)
        fail_msg: >
          [ERR] Packages for chrony and timesyncd are mutually exclusive.

    - name: "Timesyncd: sanity: Assert chrony and timesyncd services mutually exclusive."
      ansible.builtin.assert:
        that: not (lp_chrony_enable | bool and lp_timesyncd_enable | bool)
        fail_msg: >
          [ERR] Services {{ lp_chrony_service }} and {{ lp_timesyncd_service }}
          are mutually exclusive.

    - name: "Timesyncd: sanity: Get package facts"
      ansible.builtin.package_facts:

    - name: "Timesyncd: sanity: Assert installed lp_timesyncd_packages in ansible_check_mode"
      when: lp_timesyncd_install | bool
      vars:
        missing: "{{ lp_timesyncd_packages | difference(ansible_facts.packages) }}"
      ansible.builtin.assert:
        that: missing | length == 0
        fail_msg: >
          [ERR] Packages must be installed before running --check
          Missing packages: {{ missing }}

- name: "Timesyncd: Install packages"
  when: lp_timesyncd_install | bool
  tags: lp_timesyncd_packages
  vars:
    ll_ipkg_list: "{{ lp_timesyncd_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_timesyncd_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: Set lp_timesyncd_service_exists/found
  block:

    - name: "Timesyncd: Get Service facts"
      ansible.builtin.service_facts:

    - name: "Timesyncd: Set lp_timesyncd_service_exists/found={{ exists ~ '/' ~ found }}"
      vars:
        service: "{{ lp_timesyncd_service | splitext | first }}.service"
        exists: "{{ service in ansible_facts.services }}"
        found: "{{ ansible_facts.services[service]['status'] | d('not-found') != 'not-found' }}"
      ansible.builtin.set_fact:
        lp_timesyncd_service_exists: "{{ exists }}"
        lp_timesyncd_service_found: "{{ found }}"

    - name: "Timesyncd: Debug lp_timesyncd_service lp_timesyncd_debug={{ lp_timesyncd_debug }}"
      when: lp_timesyncd_debug | bool
      vars:
        service: "{{ lp_timesyncd_service | splitext | first }}.service"
      ansible.builtin.debug:
        msg: |
          lp_timesyncd_service_exists: {{ lp_timesyncd_service_exists }}
          lp_timesyncd_service_found: {{ lp_timesyncd_service_found }}
          {% if lp_timesyncd_service_exists %}
          {{ service }}:
            {{ ansible_facts.services[service] | to_nice_yaml(indent=2) | indent(2) }}
          {% endif %}

    - name: "Timesyncd: Assert exists and found {{ lp_timesyncd_service }}"
      when: lp_timesyncd_service_exists_fatal | bool
      ansible.builtin.assert:
        that:
          - lp_timesyncd_service_exists
          - lp_timesyncd_service_found
        fail_msg: "[ERR] Service {{ lp_timesyncd_service }} must exists and be found."

- name: Configure timesyncd
  tags: lp_timesyncd_conf
  block:

    - name: "Timesyncd: Keep original {{ lp_timesyncd_conf_file }}"
      when: lp_timesyncd_conf_file_orig | bool
      ansible.builtin.copy:
        src: "{{ lp_timesyncd_conf_file }}"
        dest: "{{ lp_timesyncd_conf_file }}.orig"
        mode: "0644"
        remote_src: true
        force: false

    - name: "Timesyncd: Configure {{ lp_timesyncd_conf_file }}"
      notify: restart timesyncd
      ansible.builtin.template:
        src: "{{ lp_timesyncd_conf_template }}"
        dest: "{{ lp_timesyncd_conf_file }}"
        owner: root
        group: root
        mode: "0644"
        backup: "{{ lp_backup_conf }}"

  rescue:

    - name: "Timesyncd: Print errors"
      ansible.builtin.debug:
        msg: |
          [ERR] task {{ ansible_failed_task.name }} failed. End host.
          ansible_failed_task:
            {{ ansible_failed_task | to_yaml(indent=2) | indent(2) }}
          ansible_failed_result:
            {{ ansible_failed_result | to_yaml(indent=2) | indent(2) }}

    - name: "Timesyncd: End host"
      when: lp_timesyncd_rescue_end_host | bool
      ansible.builtin.meta: end_host

    - name: "Timesyncd: Clear host errors"
      ansible.builtin.meta: clear_host_errors

- name: Service timesyncd
  when: lp_timesyncd_service_found
  tags: lp_timesyncd_service
  block:

    - name: "Timesyncd: Set service state/status {{ state ~ '/' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_timesyncd_enable | bool | d(false) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        state: "{{ lp_timesyncd_state | d(default_state) }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_timesyncd_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Timesyncd: Debug set state/status result lp_timesyncd_debug2={{ lp_timesyncd_debug2 | d(false) | bool }}"
      when: lp_timesyncd_debug2 | d(false) | bool
      ansible.builtin.debug:
        var: result

  rescue:

    - name: "Timesyncd: Print errors"
      ansible.builtin.debug:
        msg: |
          [ERR] task {{ ansible_failed_task.name }} failed. End host.
          ansible_failed_task:
            {{ ansible_failed_task | to_yaml(indent=2) | indent(2) }}
          ansible_failed_result:
            {{ ansible_failed_result | to_yaml(indent=2) | indent(2) }}

    - name: "Timesyncd: End host"
      when: lp_timesyncd_rescue_end_host | bool
      ansible.builtin.meta: end_host

    - name: "Timesyncd: Clear host errors"
      ansible.builtin.meta: clear_host_errors

- name: "Timesyncd: Flush handlers"
  when: lp_timesyncd_flush_handlers | bool
  tags: lp_timesyncd_flush_handlers
  ansible.builtin.meta: flush_handlers

# Notes:

# chrony and timesyncd are mutually exclusive
# -------------------------------------------
# To configure timesyncd without installation disable the service and
# disable crashing on missing service
# lp_timesyncd: true
# lp_timesyncd_enable: false
# lp_timesyncd_service_exists_fatal: false

# CentOS
# ------
# * systemd compiled without timesyncd service in CentOS 7 ?
# * use ntpd or chrony only ?
# https://unix.stackexchange.com/questions/286708/
# centos-7-2-minimal-time-synchronization-timedated-and-or-ntpd-chrony
# https://www.freedesktop.org/wiki/Software/systemd/timedated/

# EOF

timezone.yml

Synopsis: Configure timezone

Description of the task.

[tasks/timezone.yml]

---
# linux_postinstall timezone

- name: "Timezone: Debug lp_timezone_debug={{ lp_timezone_debug }}"
  when: lp_timezone_debug | bool
  tags: lp_timezone_debug
  ansible.builtin.debug:
    msg: "lp_timezone_zoneinfo: {{ lp_timezone_zoneinfo }}"

- name: "Timezone: Set timezone {{ lp_timezone_zoneinfo }}"
  tags: lp_timezone_set
  community.general.timezone:
    name: "{{ lp_timezone_zoneinfo | d('UTC') }}"

# EOF

tlp.yml

Synopsis: Configure tlp

Description of the task.

[tasks/tlp.yml]

---
# linux_postinstall tlp

- name: "Tlp: Debug lp_tlp_debug={{ lp_tlp_debug }}"
  when: lp_tlp_debug | bool
  tags: lp_tlp_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_tlp_enable: {{ lp_tlp_enable }}
      lp_tlp_install: {{ lp_tlp_install }}
      lp_tlp_packages:
        {{ lp_tlp_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_tlp_thinkpad: {{ lp_tlp_thinkpad }}
      lp_tlp_packages_tp:
        {{ lp_tlp_packages_tp | to_nice_yaml(indent=2) | indent(2) }}
      lp_tlp_config_file: {{ lp_tlp_config_file }}
      lp_tlp_config:
        {{ lp_tlp_config | to_nice_yaml(indent=2) | indent(2) }}
      lp_tlp_services:
        {{ lp_tlp_services | to_nice_yaml(indent=2) | indent(2) }}
      lp_tlp_restart_service: {{ lp_tlp_restart_service }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: Install packages
  tags: lp_tlp_packages
  block:

    - name: "Tlp: Install packages"
      when: lp_tlp_install | bool
      vars:
        ll_ipkg_list: "{{ lp_tlp_packages }}"
        ll_ipkg_state: "{{ lp_package_state }}"
        ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
        ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
        ll_debug: "{{ lp_tlp_debug | bool }}"
      ansible.builtin.import_role:
        name: vbotka.linux_lib
        tasks_from: install_package.yml

    - name: "Tlp: Install packages for ThinkPad"
      when: lp_tlp_thinkpad | bool
      vars:
        ll_ipkg_list: "{{ lp_tlp_packages_tp }}"
        ll_ipkg_state: "{{ lp_package_state }}"
        ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
        ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
        ll_debug: "{{ lp_tlp_debug | bool }}"
      ansible.builtin.import_role:
        name: vbotka.linux_lib
        tasks_from: install_package.yml

- name: "Tlp: Configure {{ lp_tlp_config_file }}"
  tags: lp_tlp_conf
  notify: restart tlp
  ansible.builtin.lineinfile:
    dest: "{{ lp_tlp_config_file }}"
    regexp: ^\s*{{ item.key }}\s*=\s*(.*)$
    line: "{{ item.key }}={{ item.value }}"
    create: true
    mode: "0644"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_tlp_config }}"
  loop_control:
    label: "{{ item.key }}: {{ item.value }}"

- name: "Tlp: Services start/stop and enable/disable"
  tags: lp_tlp_service
  vars:
    srv_name: "{{ lookup('vars', 'lp_' ~ item ~ '_service', default=item) }}"
    srv_enbl: "{{ lookup('vars', 'lp_' ~ item ~ '_enable', default=false) }}"
    srv_stat: "{{ lookup('vars', 'lp_' ~ item ~ '_state', default=default_stat) }}"
    default_stat: "{{ srv_enbl | bool | ternary('started', 'stopped') }}"
  ansible.builtin.service:
    name: "{{ srv_name }}"
    state: "{{ srv_stat }}"
    enabled: "{{ srv_enbl }}"
  loop: "{{ lp_tlp_services }}"
  loop_control:
    label: "{{ srv_name }} state: {{ srv_stat }} enabled: {{ srv_enbl }}"

# EOF

udev.yml

Synopsis: Configure udev

Description of the task.

[tasks/udev.yml]

---
# linux_postinstall udev

- name: "Udev: Debug lp_udev_debug={{ lp_udev_debug }}"
  when: lp_udev_debug | bool
  tags: lp_udev_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      ansible_distribution: {{ ansible_facts['distribution'] }}
      ansible_distribution_version: {{ ansible_facts['distribution_version'] }}
      ansible_distribution_release: {{ ansible_facts['distribution_release'] }}

      lp_backup_conf: {{ lp_backup_conf }}

      lp_udev_debug2: {{ lp_udev_debug2 | bool }}
      lp_udev_enable: {{ lp_udev_enable }}
      lp_udev_module: {{ lp_udev_module }}
      lp_udev_service: {{ lp_udev_service }}
      lp_udev_path: {{ lp_udev_path }}
      lp_udev_conf_file: {{ lp_udev_conf_file }}
      lp_udev_conf:
        {{ lp_udev_conf | to_yaml(indent=2) | indent(2) }}
      lp_udev_rules_dir: {{ lp_udev_rules_dir }}
      lp_udev_rules_template: {{ lp_udev_rules_template }}
      lp_udev_rules:
        {{ lp_udev_rules | to_yaml(indent=2) | indent(2) }}
      >>> Deprecated - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      lp_udev_persistent_net_template: {{ lp_udev_persistent_net_template }}
      lp_udev_persistent_net_rules_file: {{ lp_udev_persistent_net_rules_file }}
      lp_udev_persistent_net_rules:
        {{ lp_udev_persistent_net_rules | to_nice_yaml(indent=2) | indent(2) }}
      lp_udev_hci_name_rules_file: {{ lp_udev_hci_name_rules_file }}
      lp_udev_hci_name_rules:
        {{ lp_udev_hci_name_rules | to_nice_yaml(indent=2) | indent(2) }}
      lp_udev_hci_run_rules_file: {{ lp_udev_hci_run_rules_file }}
      lp_udev_hci_run_rules:
        {{ lp_udev_hci_run_rules | to_nice_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Udev: Configure {{ lp_udev_conf_file }}"
  tags: lp_udev_conf
  notify: update initrd
  ansible.builtin.lineinfile:
    dest: "{{ lp_udev_conf_file }}"
    regexp: ^\s*{{ item.key }}\s*=(.*)$
    line: "{{ item.key }}={{ item.val }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_udev_conf }}"

- name: "Udev: Configure {{ lp_udev_rules_dir }}"
  tags: lp_udev_rules
  notify: reload udev
  ansible.builtin.template:
    src: "{{ lp_udev_rules_template }}"
    dest: "{{ lp_udev_rules_dir }}/{{ item.key }}"
    owner: root
    group: root
    mode: "0644"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_udev_rules | dict2items }}"
  loop_control:
    label: "{{ item.key }}"

  # > > > Deprecated, use lp_udev_rules instead - - - - - - - - - - - - - - - - - -

- name: Configure legacy templates
  notify: reload udev
  block:

    - name: "Udev: Configure {{ lp_udev_rules_dir ~ '/' ~ lp_udev_persistent_net_rules_file }}"
      tags: lp_udev_persistentnet
      ansible.builtin.template:
        src: "{{ lp_udev_persistent_net_template }}"
        dest: "{{ lp_udev_rules_dir }}/{{ lp_udev_persistent_net_rules_file }}"
        owner: root
        group: root
        mode: "0644"
        backup: "{{ lp_backup_conf }}"
      loop: "{{ lp_udev_persistent_net_rules }}"

    - name: "Udev: Configure {{ lp_udev_rules_dir ~ '/' ~ lp_udev_hci_name_rules_file }}"
      tags: lp_udev_hciname
      ansible.builtin.template:
        src: hci-name.rules.j2
        dest: "{{ lp_udev_rules_dir }}/{{ lp_udev_hci_name_rules_file }}"
        owner: root
        group: root
        mode: "0644"
        backup: "{{ lp_backup_conf }}"
      loop: "{{ lp_udev_hci_name_rules }}"

    - name: "Udev: Configure {{ lp_udev_rules_dir ~ '/' ~ lp_udev_hci_run_rules_file }}"
      tags: lp_udev_hcirun
      ansible.builtin.template:
        src: hci-run.rules.j2
        dest: "{{ lp_udev_rules_dir }}/{{ lp_udev_hci_run_rules_file }}"
        owner: root
        group: root
        mode: "0644"
        backup: "{{ lp_backup_conf }}"
      loop: "{{ lp_udev_hci_run_rules }}"

  # - - - - - - - - - - - - - - - - - - Deprecated, use lp_udev_rules instead < < <

- name: Debug ansible_facts.services
  when: lp_udev_debug2 | bool
  block:

    - name: "Udev: Get ansible_facts.services"
      ansible.builtin.service_facts:

    - name: "Udev: Debug ansible_facts.services *udev* lp_udev_debug2={{ lp_udev_debug2 }}"
      vars:
        udev_service: "{{ ansible_facts.services | dict2items | selectattr('key', 'search', 'udev') | items2dict }}"
      ansible.builtin.debug:
        var: udev_service

# The module ansible.builtin.service is not idempotent when the
# parameter enabled is True for udev.service. udev.service is alias to
# systemd-udevd.service. systemd-udevd.service is static (see man
# systemctl; unit file command is-enabled).
# See: systemd and service modules don't check is-enabled stdout values
# https://github.com/ansible/ansible/issues/28247

- name: Start and enable udev
  when: lp_udev_enable | bool
  tags: lp_udev_service
  block:

    - name: "Udev: Start and enable udev (service)"
      when: lp_udev_module == 'service'
      register: result_service
      ansible.builtin.service:
        name: "{{ lp_udev_service }}"
        state: started

    - name: "Udev: Start and enable udev (systemd)"
      when: lp_udev_module == 'systemd'
      register: result_systemd
      ansible.builtin.systemd_service:
        name: "{{ lp_udev_service }}"
        state: started

    - name: "Udev: Start and enable udev (sysvinit)"
      when: lp_udev_module == 'sysvinit'
      register: result_sysvinit
      ansible.builtin.sysvinit:
        name: "{{ lp_udev_service }}"
        state: started
        enabled: true

    - name: "Udev: Debug result lp_udev_debug2={{ lp_udev_debug2 }}"
      when: lp_udev_debug2 | bool
      ansible.builtin.debug:
        msg: "{{ lookup('vars', 'result_' ~ lp_udev_module) }}"

- name: Stop and disable udev
  when: not lp_udev_enable | bool
  tags: lp_udev_service
  block:

    - name: "Udev: Stop and disable udev"
      register: result
      ansible.builtin.service:
        name: "{{ lp_udev_service }}"
        state: stopped
        enabled: false

    - name: "Udev: Debug result lp_udev_debug2={{ lp_udev_debug2 }}"
      when: lp_udev_debug2 | bool
      ansible.builtin.debug:
        var: result

# EOF

ufw.yml

Synopsis: Configure ufw

Description of the task.

[tasks/ufw.yml]

---
# linux_postinstall ufw

# Notes
#
# 1.Aliases of parameters in ufw module not implemented in task
#   "Configure ufw".
# 2.It's not necessary to reload ufw after configuration changed.
#   The module ufw automatically updates the rules.
# 3.Best practice: First time 'lp_ufw_reset: true'; configure and enable
#   ufs (configuration item {state: 'enabled'} reloads firewall and
#   enables firewall on boot); 'lp_ufw_enable: true' start and enable ufw
#   service.
# 4.Configuration on the fly: configure and enable ufs.
# 5.The last configuration item should be {state: 'enabled'}.
# 6.ufw is not starting on boot despite ENABLED=yes in /etc/ufw/ufw.conf
#   See: How do I get ufw to start on boot?
#   https://askubuntu.com/questions/1040539/how-do-i-get-ufw-to-start-on-boot
# 7.See: man ufw.

- name: "Ufw: Debug lp_ufw_debug={{ lp_ufw_debug }}"
  when: lp_ufw_debug | bool
  tags: lp_ufw_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_ufw_install: {{ lp_ufw_install }}
      lp_ufw_enable: {{ lp_ufw_enable }}
      lp_ufw_reset: {{ lp_ufw_reset }}
      lp_ufw_reload: {{ lp_ufw_reload }}
      lp_ufw_packages:
        {{ lp_ufw_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_ufw_default:
        {{ lp_ufw_default | to_yaml(indent=2) | indent(2) }}
      lp_ufw_sysctl:
        {{ lp_ufw_sysctl | to_yaml(indent=2) | indent(2) }}
      lp_ufw_blocks:
        {{ lp_ufw_blocks | to_nice_yaml(indent=2) | indent(2) }}
      lp_ufw_conf:
        {{ lp_ufw_conf | to_yaml(indent=2) | indent(2) }}
      lp_ufw_service_conf:
        {{ lp_ufw_service_conf | to_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Ufw: Install packages"
  when: lp_ufw_install | bool
  tags: lp_ufw_packages
  vars:
    ll_ipkg_list: "{{ lp_ufw_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_ufw_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Ufw: Disable and reset firewall to installation defaults"
  when: lp_ufw_reset | bool
  tags: lp_ufw_reset
  community.general.ufw:
    state: reset

- name: "Ufw: Reload firewall"
  when: lp_ufw_reload | bool
  tags: lp_ufw_reload
  community.general.ufw:
    state: reloaded

- name: "Ufw: Configure /etc/default/ufw"
  tags: lp_ufw_default
  notify: reload ufw
  ansible.builtin.lineinfile:
    path: /etc/default/ufw
    regexp: ^\s*{{ item.key }}\s*=(.*)$
    line: "{{ item.key }}={{ item.val }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_ufw_default }}"
  loop_control:
    label: "{{ item.key }}: {{ item.val }}"

- name: "Ufw: Configure /etc/ufw/sysctl.conf"
  tags: lp_ufw_sysctl
  notify: reload ufw
  ansible.builtin.lineinfile:
    path: /etc/ufw/sysctl.conf
    regexp: ^\s*{{ item.key }}\s*=(.*)$
    line: "{{ item.key }}={{ item.val }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_ufw_sysctl }}"
  loop_control:
    label: "{{ item.key }}: {{ item.val }}"

- name: "Ufw: Configure blocks"
  tags: lp_ufw_blocks
  notify: reload ufw
  ansible.builtin.blockinfile:
    path: /etc/ufw/{{ item.0.key }}
    marker: "# {mark} ANSIBLE MANAGED BLOCK {{ item.1.mark }}"
    block: "{{ item.1.block }}"
    insertbefore: "{{ item.1.insertbefore | d(omit) }}"
    insertafter: "{{ item.1.insertafter | d(omit) }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_ufw_blocks | dict2items | subelements('value') }}"
  loop_control:
    label: "{{ item.0.key }} {{ item.1.mark }}"

- name: "Ufw: Configure ufw"
  tags: lp_ufw_conf
  community.general.ufw:
    comment: "{{ item.comment | d(omit) }}"
    default: "{{ item.default | d(omit) }}"
    delete: "{{ item.delete | d(omit) }}"
    direction: "{{ item.direction | d(omit) }}"
    from_ip: "{{ item.from_ip | d(omit) }}"
    from_port: "{{ item.from_port | d(omit) }}"
    insert: "{{ item.insert | d(omit) }}"
    insert_relative_to: "{{ item.insert_relative_to | d(omit) }}"
    interface: "{{ item.interface | d(omit) }}"
    log: "{{ item.log | d(omit) }}"
    logging: "{{ item.logging | d(omit) }}"
    name: "{{ item.name | d(omit) }}"
    proto: "{{ item.proto | d(omit) }}"
    route: "{{ item.route | d(omit) }}"
    rule: "{{ item.rule | d(omit) }}"
    state: "{{ item.state | d(omit) }}"
    to_ip: "{{ item.to_ip | d(omit) }}"
    to_port: "{{ item.to_port | d(omit) }}"
  loop: "{{ lp_ufw_conf }}"
  loop_control:
    label: "{{ item.comment | d('no comment') }}"

- name: "Ufw: Configure service"
  tags: lp_ufw_service_conf
  notify: "{{ item.0.handlers | d(omit) }}"
  community.general.ini_file:
    path: "{{ item.0.path }}"
    owner: "{{ item.0.owner | d(omit) }}"
    group: "{{ item.0.group | d(omit) }}"
    mode: "{{ item.0.mode | d(omit) }}"
    create: "{{ item.0.create | d(omit) }}"
    no_extra_spaces: "{{ item.0.no_extra_spaces | d(omit) }}"
    section: "{{ item.1.section }}"
    state: "{{ item.1.state | d(omit) }}"
    option: "{{ item.1.option | d(omit) }}"
    value: "{{ item.1.value | d(omit) }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_ufw_service_conf | subelements('ini', {'skip_missing': True}) }}"
  loop_control:
    label: >
      {{ item.0.path }}
      {{ item.1.section | d('none') }}
      {{ item.1.option | d('none') }}
      {{ item.1.value | d('none') }}
      {{ item.1.state | d('none') }}

- name: Service
  tags: lp_ufw_service
  block:

    - name: "Ufw: Service {{ state ~ ' and ' ~ enable }}"
      register: result
      vars:
        enabled: "{{ lp_ufw_enable | bool | d(false) }}"
        state: "{{ lp_ufw_state | d(default_state) }}"
        default_state: "{{ enabled | ternary('started', 'stopped') }}"
        enable: "{{ enabled | ternary('enabled', 'disabled') }}"
      ansible.builtin.service:
        name: "{{ lp_ufw_service }}"
        state: "{{ state }}"
        enabled: "{{ enabled }}"

    - name: "Ufw: Debug service lp_ufw_debug={{ lp_ufw_debug }}"
      when: lp_ufw_debug | bool
      ansible.builtin.debug:
        var: result

# EOF

users.yml

Synopsis: Configure users

Description of the task.

[tasks/users.yml]

---
# linux_postinstall users

- name: "Users: Debug lp_users_debug={{ lp_users_debug }}"
  when: lp_users_debug | bool
  tags: lp_users_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_users_nolog: {{ lp_users_nolog }}
      lp_users:
        {{ lp_users | to_nice_yaml(indent=2) | indent(2) }}
      lp_users_groups:
        {{ lp_users_groups | to_nice_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Users: Manage user accounts"
  tags: lp_users_accounts
  no_log: "{{ lp_users_nolog | bool }}"
  ansible.builtin.user:
    name: "{{ item.name }}"
    authorization: "{{ item.authorization | d(omit) }}"
    comment: "{{ item.comment | d(omit) }}"
    create_home: "{{ item.create_home | d(omit) }}"
    expires: "{{ item.expires | d(omit) }}"
    force: "{{ item.force | d(omit) }}"
    generate_ssh_key: "{{ item.generate_ssh_key | d(omit) }}"
    group: "{{ item.group | d(omit) }}"
    hidden: "{{ item.hidden | d(omit) }}"
    home: "{{ item.home | d(omit) }}"
    local: "{{ item.local | d(omit) }}"
    login_class: "{{ item.login_class | d(omit) }}"
    move_home: "{{ item.move_home | d(omit) }}"
    non_unique: "{{ item.non_unique | d(omit) }}"
    password: "{{ item.password | d(omit) }}"
    password_lock: "{{ item.password_lock | d(omit) }}"
    profile: "{{ item.profile | d(omit) }}"
    remove: "{{ item.remove | d(omit) }}"
    role: "{{ item.role | d(omit) }}"
    seuser: "{{  item.seuser | d(omit) }}"
    shell: "{{ item.shell | d(omit) }}"
    skeleton: "{{ item.skeleton | d(omit) }}"
    ssh_key_bits: "{{ item.ssh_key_bits | d(omit) }}"
    ssh_key_comment: "{{ item.ssh_key_comment | d(omit) }}"
    ssh_key_file: "{{ item.ssh_key_file | d(omit) }}"
    ssh_key_passphrase: "{{ item.ssh_key_passphrase | d(omit) }}"
    ssh_key_type: "{{ item.ssh_key_type | d(omit) }}"
    state: "{{ item.state | d(omit) }}"
    system: "{{ item.system | d(omit) }}"
    uid: "{{ item.uid | d(omit) }}"
    update_password: "{{ item.update_password | d(omit) }}"
  loop: "{{ lp_users }}"
  loop_control:
    label: "{{ item.name }}"

- name: "Users: Add users to additional groups"
  tags: lp_users_groups
  ansible.builtin.user:
    name: "{{ item.name }}"
    groups: "{{ item.groups }}"
    append: "{{ item.append | d(true) }}"
  loop: "{{ lp_users_groups }}"
  loop_control:
    label: "{{ item.name }}: {{ item.groups }}"

#  EOF

vars_firstfound.yml

Synopsis: Configure vars_firstfound

Description of the task.

[tasks/vars_firstfound.yml]

---
# linux_postinstall vars_firstfound

- name: "Vars_firstfound: Include defaults for {{ label }}"
  ansible.builtin.include_vars: "{{ file }}"
  # register: result
  vars:
    label: "{{ [ansible_distribution_release, ansible_distribution, ansible_os_family] | join(',') }}"
    file: "{{ lookup('first_found', params) }}"
    params:
      skip: "{{ lp_vars_distro_firstfound_skip | bool }}"
      files:
        - "{{ ansible_facts['distribution'] }}-{{ ansible_facts['distribution_release'] }}.yml"
        - "{{ ansible_facts['distribution'] }}.yml"
        - "{{ ansible_facts['os_family'] }}.yml"
        - default.yml
        - defaults.yml
      paths:
        - "{{ role_path }}/vars/defaults"

# Note: skip doesn't work with first_found lookup #43833
# https://github.com/ansible/ansible/issues/43833
# workaround: Create empty defaults.yml

# - name: "vars_firstfound: Debug include default vars from"
#   ansible.builtin.debug:
#     var: result.ansible_included_var_files
#   when: lp_debug | bool

- name: "Vars_firstfound: Include custom vars for {{ label }}"
  # register: result
  ansible.builtin.include_vars: "{{ file }}"
  vars:
    label: "{{ [ansible_distribution_release, ansible_distribution, ansible_os_family] | join(',') }}"
    file: "{{ lookup('first_found', params) }}"
    params:
      skip: "{{ lp_vars_distro_firstfound_skip | bool }}"
      files:
        - "{{ ansible_facts['distribution'] }}-{{ ansible_facts['distribution_release'] }}.yml"
        - "{{ ansible_facts['distribution'] }}.yml"
        - "{{ ansible_facts['os_family'] }}.yml"
        - default.yml
        - defaults.yml
      paths:
        - "{{ role_path }}/vars"

# Note: skip doesn't work with first_found lookup #43833
# https://github.com/ansible/ansible/issues/43833
# workaround: Create empty defaults.yml

# - name: "vars_firstfound: Debug include custom vars from"
#   ansible.builtin.debug:
#     var: result.ansible_included_var_files
#   when: lp_debug|bool

# EOF

vars_incremental.yml

Synopsis: Configure vars_incremental

Description of the task.

[tasks/vars_incremental.yml]

---
# linux_postinstall vars_incremental

- name: "Vars_incemental: Include default vars"
  when: item is exists
  register: result
  vars:
    my_path: "{{ role_path }}/vars/defaults.incr"
  ansible.builtin.include_vars: "{{ item }}"
  loop:
    - "{{ my_path }}/defaults.yml"
    - "{{ my_path }}/default.yml"
    - "{{ my_path }}/{{ ansible_facts['os_family'] }}.yml"
    - "{{ my_path }}/{{ ansible_facts['distribution'] }}.yml"
    - "{{ my_path }}/{{ ansible_facts['distribution'] }}-{{ ansible_facts['distribution_release'] }}.yml"

- name: "Vars_incemental: Debug include default vars"
  when: lp_debug2 | d(false) | bool
  ansible.builtin.debug:
    var: result

- name: "Vars_incemental: Include custom vars"
  when: item is exists
  register: result
  vars:
    my_path: "{{ role_path }}/vars"
  ansible.builtin.include_vars: "{{ item }}"
  loop:
    - "{{ my_path }}/defaults.yml"
    - "{{ my_path }}/default.yml"
    - "{{ my_path }}/{{ ansible_facts['os_family'] }}.yml"
    - "{{ my_path }}/{{ ansible_facts['distribution'] }}.yml"
    - "{{ my_path }}/{{ ansible_facts['distribution'] }}-{{ ansible_facts['distribution_release'] }}.yml"

- name: "Vars_incemental: Debug include custom vars"
  when: lp_debug2 | d(false) | bool
  ansible.builtin.debug:
    var: result

# EOF

vars.yml

Synopsis: Configure vars

Description of the task.

[tasks/vars.yml]

---
# linux_postinstall vars

- name: "Vars: Include firstfound default vars"
  when: lp_vars_distro == 'firstfound'
  ansible.builtin.include_tasks: vars_firstfound.yml

- name: "Vars: Include incremental default vars"
  when: lp_vars_distro == 'incremental'
  ansible.builtin.include_tasks: vars_incremental.yml

- name: "Vars: Include firstfound default vars for various flavors"
  when: lp_flavors_enable | bool
  ansible.builtin.include_tasks: sub/vars_flavors.yml

# TODO "vars: Include incremental default vars for various flavors"

# EOF

virtualbox.yml

Synopsis: Configure virtualbox

Description of the task.

[tasks/virtualbox.yml]

---
# linux_postinstall virtualbox

- name: "Virtualbox: Debug lp_virtualbox_debug={{ lp_virtualbox_debug }}"
  when: lp_virtualbox_debug | bool
  tags: lp_virtualbox_debug
  vars:
    msg: |-
      ansible_lsb.description: {{ ansible_lsb.codename }}
      lp_virtualbox: {{ lp_virtualbox }}
      lp_virtualbox_ignore_errors: {{ lp_virtualbox_ignore_errors }}
      lp_virtualbox_keys: {{ lp_virtualbox_keys }}
      lp_virtualbox_repos: {{ lp_virtualbox_repos }}
      lp_virtualbox_packages:
        {{ lp_virtualbox_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_virtualbox_services:
        {{ lp_virtualbox_services | to_nice_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

# TODO: assert lp_virtualbox_modules are loaded
#       when: lp_virtualbox | bool

- name: "Virtualbox: Add signing key of VirtualBox"
  tags: lp_virtualbox_keys
  ansible.builtin.apt_key:
    url: "{{ item }}"
    state: present
  loop: "{{ lp_virtualbox_keys }}"
  register: result
  retries: "{{ lp_install_retries }}"
  until: result is succeeded
  delay: "{{ lp_install_delay }}"
  ignore_errors: "{{ lp_virtualbox_ignore_errors }}" # noqa ignore-errors

- name: "Virtualbox: Add repository of VirtualBox"
  tags: lp_virtualbox_repos
  ansible.builtin.apt_repository:
    repo: "{{ item }}"
    state: present
  loop: "{{ lp_virtualbox_repos }}"
  ignore_errors: "{{ lp_virtualbox_ignore_errors }}" # noqa ignore-errors

- name: "Virtualbox: Install VirtualBox packages"
  when: lp_virtualbox_install | bool
  tags: lp_virtualbox_packages
  vars:
    ll_ipkg_list: "{{ lp_virtualbox_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_virtualboxool_debug | bool }}"
  ignore_errors: "{{ lp_virtualbox_ignore_errors }}" # noqa ignore-errors
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Virtualbox: Services start/stop and enable/disable"
  tags: lp_virtualbox_service
  vars:
    srv_name: "{{ lookup('vars', 'lp_' ~ item ~ '_service', default=item) }}"
    srv_enbl: "{{ lookup('vars', 'lp_' ~ item ~ '_enable', default=false) }}"
    srv_stat: "{{ lookup('vars', 'lp_' ~ item ~ '_state', default=default_stat) }}"
    default_stat: "{{ srv_enbl | bool | ternary('started', 'stopped') }}"
  ansible.builtin.service:
    name: "{{ srv_name }}"
    state: "{{ srv_stat }}"
    enabled: "{{ srv_enbl }}"
  loop: "{{ lp_virtualbox_services }}"
  loop_control:
    label: "{{ srv_name }} state: {{ srv_stat }} enabled: {{ srv_enbl }}"

# EOF

wpagui.yml

Synopsis: Configure wpagui

Description of the task.

[tasks/wpagui.yml]

---
# linux_postinstall wpa_gui

# Note: Disable NetworkManager before installing wpagui
#
# Example:
#
# lp_nm: true
# lp_nm_install: false
# lp_nm_enable: false
# lp_nm_conf:
#     - {key: managed, val: 'false'}
# lp_nm_mask: true

- name: "Wpagui: Debug lp_wpagui_debug={{ lp_wpagui_debug }}"
  when: lp_wpagui_debug | bool
  tags: lp_wpagui_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_wpagui_install: {{ lp_wpagui_install }}
      lp_wpagui_packages:
        {{ lp_wpagui_packages | to_nice_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Wpagui: Install packages"
  when: lp_wpagui_install | bool
  tags: lp_wpagui_packages
  vars:
    ll_ipkg_list: "{{ lp_wpagui_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_wpagui_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

# EOF

wpasupplicant.yml

Synopsis: Configure wpasupplicant

Description of the task.

[tasks/wpasupplicant.yml]

---
# linux_postinstall wpasupplicant

- name: "Wpasupplicant: Debug lp_wpasupplicant_debug={{ lp_wpasupplicant_debug }}"
  when: lp_wpasupplicant_debug | bool
  tags: lp_wpasupplicant_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      ansible_distribution: {{ ansible_facts['distribution'] }}
      ansible_distribution_version: {{ ansible_facts['distribution_version'] }}
      ansible_distribution_release: {{ ansible_facts['distribution_release'] }}

      lp_backup_conf: {{ lp_backup_conf }}
      lp_package_state: {{ lp_package_state }}

      lp_wpasupplicant_install: {{ lp_wpasupplicant_install }}
      lp_wpasupplicant_packages:
        {{ lp_wpasupplicant_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_wpasupplicant_bin: {{ lp_wpasupplicant_bin }}
      lp_wpasupplicant_conf_only: {{ lp_wpasupplicant_conf_only }}
      lp_wpasupplicant_conf_dir: {{ lp_wpasupplicant_conf_dir }}
      lp_wpasupplicant_conf_template: {{ lp_wpasupplicant_conf_template }}
      lp_wpasupplicant_conf_owner: {{ lp_wpasupplicant_conf_owner }}
      lp_wpasupplicant_conf_group: {{ lp_wpasupplicant_conf_group }}
      lp_wpasupplicant_conf_mode: {{ lp_wpasupplicant_conf_mode }}
      lp_wpasupplicant_conf_ctrl_interface: {{ lp_wpasupplicant_conf_ctrl_interface }}
      lp_wpasupplicant_conf_global:
        {{ lp_wpasupplicant_conf_global | to_yaml(indent=2) | indent(2) }}
      lp_wpa_action_script: {{ lp_wpa_action_script }}
      lp_wpa_action_script_dir: {{ lp_wpa_action_script_dir }}
      lp_wpa_action_script_dir_owner: {{ lp_wpa_action_script_dir_owner }}
      lp_wpa_action_script_dir_group: {{ lp_wpa_action_script_dir_group }}
      lp_wpa_action_script_dir_mode: {{ lp_wpa_action_script_dir_mode }}
      lp_wpa_action_script_file: {{ lp_wpa_action_script_file }}
      lp_wpa_action_script_owner: {{ lp_wpa_action_script_owner }}
      lp_wpa_action_script_group: {{ lp_wpa_action_script_group }}
      lp_wpa_action_script_mode: {{ lp_wpa_action_script_mode }}
      lp_wpa_action_script_dhclient: {{ lp_wpa_action_script_dhclient }}
      lp_wpa_action_script_pidfile: {{ lp_wpa_action_script_pidfile }}
      lp_wpa_action_script_options_connect: {{ lp_wpa_action_script_options_connect }}
      lp_wpa_action_script_options_disconnect: {{ lp_wpa_action_script_options_disconnect }}
      lp_wpa_action_script_logfile: {{ lp_wpa_action_script_logfile }}

      lp_wpasupplicant_service_conf:
        {{ lp_wpasupplicant_service_conf | to_nice_yaml(indent=2) | indent(2) }}
      lp_wpasupplicant_debug_classified: {{ lp_wpasupplicant_debug_classified }}
      {% if lp_wpasupplicant_debug_classified | bool %}
      lp_wpasupplicant_conf:
        {{ lp_wpasupplicant_conf | to_yaml(indent=2) | indent(2) }}
      {% endif %}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Wpasupplicant: Install packages"
  when: lp_wpasupplicant_install | bool
  tags: lp_wpasupplicant_packages
  vars:
    ll_ipkg_list: "{{ lp_wpasupplicant_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_wpasupplicant_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: Action script for wpa_cli
  when: lp_wpa_action_script | bool
  block:

    - name: "Wpasupplicant: Create dir {{ lp_wpa_action_script_dir }}"
      tags: lp_wpa_action_script_dir
      ansible.builtin.file:
        state: directory
        path: "{{ lp_wpa_action_script_dir }}"
        owner: "{{ lp_wpa_action_script_dir_owner }}"
        group: "{{ lp_wpa_action_script_dir_group }}"
        mode: "{{ lp_wpa_action_script_dir_mode }}"

    - name: "Wpasupplicant: Create script {{ lp_wpa_action_script_file }}"
      tags: lp_wpa_action_script
      ansible.builtin.template:
        src: wpa_action.sh.j2
        dest: "{{ lp_wpa_action_script_file }}"
        owner: "{{ lp_wpa_action_script_owner }}"
        group: "{{ lp_wpa_action_script_group }}"
        mode: "{{ lp_wpa_action_script_mode }}"
        backup: "{{ lp_backup_conf }}"

- name: Configuration wpa_supplicant.conf
  tags: lp_wpasupplicant_conf
  block:

    - name: "Wpasupplicant: Create wpasupplicant configuration lp_wpasupplicant_debug_classified={{ lp_wpasupplicant_debug_classified }}"
      register: lp_wpasupplicant_conf_changes
      notify: reconfigure wpa_supplicant
      no_log: "{{ not lp_wpasupplicant_debug_classified | bool }}"
      vars:
        my_filename: "{{ lp_wpasupplicant_conf_file[item.type | d('default')] }}"
      ansible.builtin.template:
        src: "{{ lp_wpasupplicant_conf_template }}"
        dest: "{{ lp_wpasupplicant_conf_dir }}/{{ my_filename }}"
        owner: "{{ lp_wpasupplicant_conf_owner }}"
        group: "{{ lp_wpasupplicant_conf_group }}"
        mode: "{{ lp_wpasupplicant_conf_mode }}"
        backup: "{{ lp_backup_conf }}"
      loop: "{{ lp_wpasupplicant_conf }}"
      loop_control:
        label: "{{ my_filename }}"

    - name: "Wpasupplicant: Debug: Create wpasupplicant configuration lp_wpasupplicant_debug_classified={{ lp_wpasupplicant_debug_classified }}"
      when: lp_wpasupplicant_debug_classified | bool
      ansible.builtin.debug:
        var: lp_wpasupplicant_conf_changes

- name: Configure wpa_supplicant services
  tags: lp_wpasupplicant_service_conf
  block:

    - name: "Wpasupplicant: Configure wpa_supplicant services"
      register: lp_wpasupplicant_service_conf_changes
      notify: "{{ item.0.handlers | d(omit) }}" # TODO: see handlers
      community.general.ini_file:
        path: "{{ item.0.path }}/{{ item.0.service }}"
        owner: "{{ item.0.owner | d(omit) }}"
        group: "{{ item.0.group | d(omit) }}"
        mode: "{{ item.0.mode | d(omit) }}"
        create: "{{ item.0.create | d(omit) }}"
        no_extra_spaces: "{{ item.0.no_extra_spaces | d(omit) }}"
        section: "{{ item.1.section }}"
        state: "{{ item.1.state | d(omit) }}"
        option: "{{ item.1.option | d(omit) }}"
        value: "{{ item.1.value | d(omit) }}"
        backup: "{{ lp_backup_conf }}"
      loop: "{{ lp_wpasupplicant_service_conf | subelements('ini', {'skip_missing': True}) }}"
      loop_control:
        label: "{{ item.0.path }}/{{ item.0.service }}"

    - name: "Wpasupplicant: Debug: Configure wpasupplicant services lp_wpasupplicant_debug={{ lp_wpasupplicant_debug }}"
      when: lp_wpasupplicant_debug | bool
      ansible.builtin.debug:
        var: lp_wpasupplicant_service_conf_changes

- name: Service
  tags: lp_wpasupplicant_service
  block:

    - name: "Wpasupplicant: Manage wpa_supplicant services"
      register: lp_wpasupplicant_service_changes
      vars:
        my_service: "{{ lp_wpasupplicant_service[item.type | d('default')] }}"
      ansible.builtin.service:
        name: "{{ my_service }}"
        state: "{{ item.state | d('started') }}"
        enabled: "{{ item.enabled | d(true) }}"
        arguments: "{{ item.arguments | d(omit) }}"
        pattern: "{{ item.pattern | d(omit) }}"
        runlevel: "{{ item.runlevel | d(omit) }}"
        sleep: "{{ item.sleep | d(omit) }}"
        use: "{{ item.use | d(omit) }}"
      loop: "{{ lp_wpasupplicant_conf }}"
      loop_control:
        label: "{{ my_service }}"

    - name: "Wpasupplicant: Debug: Manage wpa_supplicant services lp_wpasupplicant_debug_classified={{ lp_wpasupplicant_debug_classified }}"
      when: lp_wpasupplicant_debug_classified | bool
      ansible.builtin.debug:
        var: lp_wpasupplicant_service_changes

# EOF

xen.yml

Synopsis: Configure xen

Description of the task.

[tasks/xen.yml]

---
# linux_postinstall xen

- name: "Xen: Debug lp_xen_debug={{ lp_xen_debug }}"
  when: lp_xen_debug | bool
  tags: lp_xen_debug
  vars:
    msg: |-
      ansible_os_family: {{ ansible_facts['os_family'] }}
      lp_xen_packages:
        {{ lp_xen_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_xen_dom0_mem:
        {{ lp_xen_dom0_mem | to_nice_yaml(indent=2) | indent(2) }}
      lp_xen_default_grub_conf:
        {{ lp_xen_default_grub_conf | to_nice_yaml(indent=2) | indent(2) }}
      lp_xen_global:
        {{ lp_xen_global | to_nice_yaml(indent=2) | indent(2) }}
      lp_backup_conf: {{ lp_backup_conf }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Xen: Install packages"
  when: lp_xen_install | bool
  tags: lp_xen_packages
  vars:
    ll_ipkg_list: "{{ lp_xen_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_xen_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Xen: Configure /etc/default/grub"
  tags: lp_xen_default_grub
  notify: update grub
  ansible.builtin.lineinfile:
    dest: /etc/default/grub
    regexp: ^\s*{{ item.key }}\s*=\s*(.*)$
    line: "{{ item.key }}={{ item.value }}"
    backup: "{{ lp_backup_conf }}"
  loop: "{{ lp_xen_default_grub_conf }}"
  loop_control:
    label: "{{ item.key }}: {{ item.value }}"

- name: "Xen: Configure /etc/xen/xl.conf"
  tags: lp_xen_global
  ansible.builtin.lineinfile:
    dest: /etc/xen/xl.conf
    regexp: ^\s*{{ item.var }}\s*=\s*(.*)$
    line: "{{ item.var }}={{ item.value }}"
    backup: "{{ lp_backup_conf }}"
    create: true
    mode: "0644"
  loop: "{{ lp_xen_global }}"
  loop_control:
    label: "{{ item.var }}: {{ item.value }}"

# EOF

xorg.yml

Synopsis: Configure xorg

Description of the task.

[tasks/xorg.yml]

---
# linux_postinstall xorg

- name: "Xorg: Debug lp_xorg_debug={{ lp_xorg_debug }}"
  when: lp_xorg_debug | bool
  tags: lp_xorg_debug
  vars:
    msg: |-
      lp_xorg_conf:
        {{ lp_xorg_conf | to_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Xorg: Configure {{ lp_xorg_conf_dir }}"
  tags: lp_xorg_conf
  ansible.builtin.template:
    src: xorg.conf.j2
    dest: "{{ lp_xorg_conf_dir }}/{{ item.file }}"
    backup: "{{ lp_backup_conf }}"
    mode: "0644"
  loop: "{{ lp_xorg_conf }}"
  loop_control:
    label: "{{ item.file }}"

# EOF

zeitgeist.yml

Synopsis: Configure zeitgeist

Description of the task.

[tasks/zeitgeist.yml]

---
# linux_postinstall zeitgeist

- name: Remove zeitgeist
  when: not lp_zeitgeist_install | bool
  block:

    - name: "Zeitgeist: Remove zeitgeist"
      ansible.builtin.apt:
        state: absent
        name: zeitgeist
        purge: true

    - name: "Zeitgeist: Remove zeitgeist-*"
      ansible.builtin.apt:
        state: absent
        name: zeitgeist-*
        purge: true

# - name: Disable zeitgeist
#   ansible.builtin.service:
#     name: zeitgeist
#     state: stopped
#     enabled: no
#   when: not lp_zeitgeist
# "Could not find the requested service zeitgeist"

# for i in zeitgeist-fts zeitgeist; do
# systemctl --user disable $i;
# systemctl --user stop $i;
# systemctl --user mask $i;
# done

# EOF

zfs.yml

Synopsis: Configure zfs

Description of the task.

[tasks/zfs.yml]

---
# linux_postinstall zfs

- name: "Zfs: Debug lp_zfs_debug={{ lp_zfs_debug }}"
  when: lp_zfs_debug | bool
  tags: lp_zfs_debug
  vars:
    msg: |-
      lp_zfs_install: {{ lp_zfs_install }}
      lp_zfs_packages:
        {{ lp_zfs_packages | to_nice_yaml(indent=2) | indent(2) }}
      lp_zfs_services:
        {{ lp_zfs_services | d([]) | to_yaml(indent=2) | indent(2) }}
      lp_zfs_manage:
        {{ lp_zfs_manage | to_yaml(indent=2) | indent(2) }}
      lp_zfs_mountpoints:
        {{ lp_zfs_mountpoints | to_yaml(indent=2) | indent(2) }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Zfs: Install packages"
  when: lp_zfs_install | bool
  tags: lp_zfs_packages
  vars:
    ll_ipkg_list: "{{ lp_zfs_packages }}"
    ll_ipkg_state: "{{ lp_package_state }}"
    ll_ipkg_autoremove: "{{ lp_packages_autoremove | bool }}"
    ll_ipkg_rescue_end_host: "{{ lp_packages_rescue_end_host | bool }}"
    ll_debug: "{{ lp_zfs_debug | bool }}"
  ansible.builtin.import_role:
    name: vbotka.linux_lib
    tasks_from: install_package.yml

- name: "Zfs: Manage zfs services"
  tags: lp_zfs_services
  vars:
    srv_enbl: "{{ item.enabled | d(true) }}"
    srv_stat: "{{ item.state | d(default_stat) }}"
    default_stat: "{{ srv_enbl | bool | ternary('started', 'stopped') }}"
  ansible.builtin.service:
    name: "{{ item.name }}"
    enabled: "{{ srv_enbl }}"
    state: "{{ srv_stat }}"
  loop: "{{ lp_zfs_services | d([]) }}"
  loop_control:
    label: "{{ item.name }} enabled: {{ srv_enbl }} state: {{ srv_stat }}"

- name: "Zfs: Manage zfs"
  tags: lp_zfs_manage
  community.general.zfs:
    name: "{{ item.name }}"
    state: "{{ item.state }}"
    origin: "{{ item.origin | d(omit) }}"
    extra_zfs_properties: "{{ item.extra_zfs_properties | d(omit) }}"
  loop: "{{ lp_zfs_manage }}"
  loop_control:
    label: "{{ item.name }}"

- name: "Zfs: Set mode and ownership of zfs mountpoints"
  tags: lp_zfs_mountpoints
  ansible.builtin.file:
    state: directory
    path: "{{ item.mountpoint }}"
    owner: "{{ item.owner | d(omit) }}"
    group: "{{ item.group | d(omit) }}"
    mode: "{{ item.mode | d(omit) }}"
  loop: "{{ lp_zfs_mountpoints }}"
  loop_control:
    label: "{{ item.mountpoint }}"

# EOF

vars_flavors.yml

Synopsis: Configure vars_flavors

Description of the task.

[tasks/sub/vars_flavors.yml]

---
# linux_postinstall vars: vars_flavors

# Create dir lp_flavors_dir. Loop lp_flavors and get stat of
# release_file(s). If release_file exists include tasks specific to this
# flavor.

- name: "Sub: vars_flavors: Debug lp_debug={{ lp_debug }}"
  when: lp_debug | bool
  vars:
    msg: |-
      lp_flavors_dir [{{ lp_flavors_dir }}]
      lp_flavors_dir_owner [{{ lp_flavors_dir_owner }}]
      lp_flavors_dir_group [{{ lp_flavors_dir_group }}]
      lp_flavors_dir_mode [{{ lp_flavors_dir_mode }}]
      lp_flavors
      {{ lp_flavors | to_nice_yaml }}
  ansible.builtin.debug:
    msg: "{{ '{}'.format(msg) }}"

- name: "Sub: vars_flavors: Create {{ lp_flavors_dir }}"
  delegate_to: localhost
  run_once: true
  ansible.builtin.file:
    state: directory
    path: "{{ lp_flavors_dir }}"
    owner: "{{ lp_flavors_dir_owner }}"
    group: "{{ lp_flavors_dir_group }}"
    mode: "{{ lp_flavors_dir_mode }}"

- name: "Sub: vars_flavors: Detect flavor"
  register: result
  ansible.builtin.stat:
    path: "{{ item.value.release_file }}"
  loop: "{{ lp_flavors | dict2items }}"

- name: "Sub: vars_flavors: Debug result lp_debug={{ lp_debug }}"
  when: lp_debug | bool
  ansible.builtin.debug:
    msg: "{{ result.results | json_query('[?stat.exists].item') }}"

- name: "Sub: vars_flavors: Include tasks for flavor"
  ansible.builtin.include_tasks: "{{ 'sub/vars_flavors-' ~ outer_item.key ~ '.yml' }}"
  loop: "{{ result.results | json_query('[?stat.exists].item') }}"
  loop_control:
    loop_var: outer_item

# EOF

vars_flavors_common.yml

Synopsis: Configure vars_flavors_common

Description of the task.

[tasks/sub/vars_flavors_common.yml]

---
# linux_postinstall vars: vars-flavors-common

# Fetch my_release_file from the remote host and store the file in
# lp_flavors_dir. Read release_attr from the fetched file and include
# vars that correspond the flavor, release and HW.

- name: Set my_release_file
  block:

    - name: "Sub: vars-flavors-common: Set my_release_file"
      ansible.builtin.set_fact:
        my_release_file: "{{ outer_item.value.release_file }}"

    - name: "Sub: vars-flavors-common: Debug my_release_file lp_debug={{ lp_debug }}"
      when: lp_debug | bool
      ansible.builtin.debug:
        var: my_release_file

- name: Set my_flavor
  block:

    - name: "Sub: vars-flavors-common: Set my_flavor"
      ansible.builtin.set_fact:
        my_flavor: "{{ outer_item.key }}"

    - name: "Sub: vars-flavors-common: Debug my_flavor lp_debug={{ lp_debug }}"
      when: lp_debug | bool
      ansible.builtin.debug:
        var: my_flavor

- name: Set my_release_file_fetch
  block:

    - name: "Sub: vars-flavors-common: Set my_release_file_fetch"
      ansible.builtin.set_fact:
        my_release_file_fetch: "{{ lp_flavors_dir ~ '/' ~ inventory_hostname ~ '-' ~ my_flavor }}"

    - name: "Sub: vars-flavors-common: Fetch {{ my_release_file ~ ' to ' ~ my_release_file_fetch }}"
      ansible.builtin.fetch:
        flat: true
        src: "{{ my_release_file }}"
        dest: "{{ my_release_file_fetch }}"

- name: Set my_release_keys
  block:

    - name: "Sub: vars-flavors-common: Clear my_release_keys"
      ansible.builtin.set_fact:
        my_release_keys: []

    - name: "Sub: vars-flavors-common: Set my_release_keys"
      ansible.builtin.set_fact:
        my_release_keys: "{{ my_release_keys | d([]) + [item.split('=').0 | trim] }}"
      loop: "{{ lookup('file', my_release_file_fetch).splitlines() }}"
      when: item is match('^(\s*[a-zA-Z0-9_]+\s*)=(.*)$')

    - name: "Sub: vars-flavors-common: Debug my_release_keys lp_debug={{ lp_debug }}"
      when: lp_debug | bool
      ansible.builtin.debug:
        var: my_release_keys

- name: Set my_release_dict
  block:

    - name: "Sub: vars-flavors-common: Clear my_release_dict"
      ansible.builtin.set_fact:
        my_release_dict: {}

    - name: "Sub: vars-flavors-common: Set my_release_dict attributes"
      ansible.builtin.set_fact:
        my_release_dict: "{{ my_release_dict |
                             combine({item: lookup('ansible.builtin.ini',
                                                   item,
                                                   'type=properties',
                                                   'file=' ~ my_release_file_fetch)}) }}"
      loop: "{{ my_release_keys }}"

    - name: "Sub: vars-flavors-common: Debug my_release_dict"
      when: lp_debug | bool
      ansible.builtin.debug:
        var: my_release_dict

- name: Set my_release
  block:

    - name: "Sub: vars-flavors-common: Add flavor to my_release"
      ansible.builtin.set_fact:
        my_release: "{{ my_release | d({}) | combine({my_flavor: my_release_dict}) }}"

    - name: "Sub: vars-flavors-common: Debug my_release lp_debug={{ lp_debug }}"
      when: lp_debug | bool
      ansible.builtin.debug:
        var: my_release

- name: Set my_labels
  block:

    - name: "Sub: vars-flavors-common: Set my_labels"
      ansible.builtin.set_fact:
        my_labels: "{{ lp_flavors[my_flavor].file_labels | map('extract', my_release[my_flavor]) | list }}"

    - name: "Sub: vars-flavors-common: Debug my_labels lp_debug={{ lp_debug }}"
      when: lp_debug | bool
      ansible.builtin.debug:
        var: my_labels

- name: "Sub: vars-flavors-common: Include defaults for flavor {{ [my_labels.1, my_labels.0, my_flavor] | join(',') }}"
  vars:
    file: "{{ lookup('first_found', params) }}"
    params:
      skip: "{{ lp_vars_distro_firstfound_skip | bool }}"
      files:
        - "{{ my_flavor }}_{{ my_labels.0 }}_{{ my_labels.1 }}.yml"
        - "{{ my_flavor }}_{{ my_labels.0 }}.yml"
        - "{{ my_flavor }}.yml"
        - default.yml
        - defaults.yml
      paths:
        - "{{ role_path }}/vars/flavors"
  ansible.builtin.include_vars: "{{ file }}"

# Note: skip doesn't work with first_found lookup #43833
# https://github.com/ansible/ansible/issues/43833
# workaround: Create empty defaults.yml

# EOF