ansible-workstation/roles/base/tasks/archinstall/partition.yaml

---
- name: Partition | get details about rootfs disks
  community.general.parted:
    device: "{{ item }}"
    unit: MiB
  register: base_root_disks_info
  loop: "{{ base_root_disks | list }}"

- name: Partition | calculate maximum usable disk space
  ansible.builtin.set_fact:
    base_root_usable_mib: "{{ (base_root_disks_info.results | map(attribute='disk.size') | min | int) - 1 }}"

- name: Partition | calculate disk utilization percentage
  ansible.builtin.set_fact:
    base_root_usable_mib: "{{ base_root_usable_mib | int - ((base_root_usable_mib | float) * (0.01 * (base_root_free_percent | float))) | round(method='floor') |
      int }}"

- name: Partition | calculate zroot ZFS pool size
  ansible.builtin.set_fact:
    base_root_zpool_mib: "{{ base_root_usable_mib | int - fixed_size_partitions | int }}"
  vars:
    fixed_size_partitions: "{{ base_root_swap_mib | int + base_root_efi_mib | int }}"
#
- name: Partition | calculate partition layouts
  ansible.builtin.set_fact:
    partition_ranges: >-
      {{
      (partition_ranges|d([])) + [{
        'begin': partitions[:(loop_index|int)] | map(attribute='size_mib') | map('int') | sum(),
        'end': partitions[:(loop_index|int+1)] | map(attribute='size_mib') | map('int') | sum(),
        }]
      }}
  with_sequence: start=0 end="{{ partitions | length - 1 }}"
  vars:
    loop_index: "{{ item }}"
    partitions:
      - name: efi
        size_mib: "{{ base_root_efi_mib }}"
      - name: root
        size_mib: "{{ base_root_zpool_mib }}"
      - name: swap
        size_mib: "{{ base_root_swap_mib }}"

- name: Partition | initialize partitioning facts
  ansible.builtin.set_fact:
    base_efi_partitions: []
    base_root_partitions: []
    base_swap_partitions: []

- name: Partition | ensure efi is not mounted
  ansible.posix.mount:
    path: /mnt/boot/efi
    state: unmounted

#### efi/boot
- name: Partition | create EFI boot partition
  become: true
  vars:
    part_index: 0
  community.general.parted:
    label: gpt
    unit: MiB
    name: EFI Boot
    device: "{{ item.disk.dev }}"
    number: "{{ part_index + 1 }}"
    flags: [boot, esp]
    part_start: "{{ [partition_ranges[part_index].begin, 1] | max }}MiB"
    part_end: "{{ partition_ranges[part_index].end }}MiB"
    state: present
    fs_type: fat32
  loop: "{{ base_root_disks_info.results }}"
  register: parted_create

- name: Partition | collect EFI boot partition devices
  ansible.builtin.shell: "lsblk -r --noheadings -o PATH {{ item }} | sort"
  register: lsblk
  loop: "{{ parted_create.results | map(attribute='disk.dev') }}"
  changed_when: false

- name: Store EFI partition devices
  ansible.builtin.set_fact:
    base_efi_partitions: >-
      {{ base_efi_partitions|d([]) + [
          item[part_index+1]
        ]
      }}
  loop: "{{ lsblk.results | map(attribute='stdout_lines') | sort }}"
  vars:
    part_index: 0
  changed_when: false

#### zroot zfs pool
- name: Partition | create root ZFS pool partition
  become: true
  vars:
    part_index: 1
  community.general.parted:
    label: gpt
    unit: MiB
    name: ArchLinux ZFS Root
    device: "{{ item.disk.dev }}"
    number: "{{ part_index + 1 }}"
    part_start: "{{ partition_ranges[part_index].begin }}MiB"
    part_end: "{{ partition_ranges[part_index].end }}MiB"
    state: present
  loop: "{{ parted_create.results }}"
  register: parted_create

- name: Partition | collect root ZFS pool partition devices
  ansible.builtin.shell: "lsblk -r --noheadings -o PATH {{ item }} | sort"
  register: lsblk
  loop: "{{ parted_create.results | map(attribute='disk.dev') }}"
  changed_when: false

- name: Partition | store root ZFS pool partition devices
  ansible.builtin.set_fact:
    base_root_partitions: >-
      {{ base_root_partitions|d([]) + [
          item[part_index+1]
        ]
      }}
  loop: "{{ lsblk.results | map(attribute='stdout_lines') | sort }}"
  vars:
    part_index: 1
  changed_when: false

#### swap partitions
- name: Partition | create swap partition
  become: true
  vars:
    part_index: 2
  community.general.parted:
    label: gpt
    unit: MiB
    device: "{{ item.disk.dev }}"
    number: "{{ part_index + 1 }}"
    part_start: "{{ partition_ranges[part_index].begin }}MiB"
    part_end: "{{ partition_ranges[part_index].end }}MiB"
    state: present
    fs_type: linux-swap
  loop: "{{ parted_create.results }}"
  register: parted_create
  when: base_root_swap_mib is defined and base_root_swap_mib|int > 0

- name: Partition | Collect swap partition devices
  ansible.builtin.shell: "set -o pipefail; lsblk -r --noheadings -o PATH {{ item }} | sort"
  register: lsblk
  loop: "{{ parted_create.results | map(attribute='disk.dev') }}"
  when: base_root_swap_mib is defined and base_root_swap_mib|int > 0
  changed_when: false

- name: Partition | Store swap partition devices
  ansible.builtin.set_fact:
    base_swap_partitions: >-
      {{ base_swap_partitions|d([]) + [
          item[part_index+1]
        ]
      }}
  loop: "{{ lsblk.results | map(attribute='stdout_lines') | sort }}"
  vars:
    part_index: 2
  when: base_root_swap_mib is defined and base_root_swap_mib|int > 0
  changed_when: false

- name: Partition | Analyze resulting partition layouts
  community.general.parted:
    unit: MiB
    device: "{{ item }}"
  register: base_root_disks_info
  loop: "{{ base_root_disks | list }}"

- name: Partition | Collect disk device identifiers
  ansible.builtin.shell: "set -o pipefail; for x in /dev/disk/by-id/*; do echo $x $(realpath $x); done"
  register: disk_realpaths
  changed_when: false

- name: Partition | Collect disk device identifiers into a base_partitions_by_id dictionary
  ansible.builtin.set_fact:
    base_partitions_by_id: >-
      {{
        dict(
          disk_realpaths.stdout_lines
          | map('split', ' ')
          | map('list')
        )
      }}