path: root/ansible/build_yardstick_image.yml

# Copyright (c) 2017 Intel Corporation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
---
- hosts: localhost

  vars:
    boot_modes:
      'amd64': disk1
      'arm64': uefi1
    boot_mode: "{{ boot_modes[YARD_IMG_ARCH] }}"
    image_filename: "{{ release }}-server-cloudimg-{{ YARD_IMG_ARCH }}-{{ boot_mode }}.img"
    image_path: "{{ release }}/current/{{ image_filename }}"
    host: "{{ lookup('env', 'HOST')|default('cloud-images.ubuntu.com', true)}}"
    image_url: "{{ lookup('env', 'IMAGE_URL')|default('https://' ~ host ~ '/' ~ image_path, true) }}"
    image_dest: "{{ workspace }}/{{ image_filename }}"
    sha256sums_path: "{{ release }}/current/SHA256SUMS"
    sha256sums_filename: "{{ sha256sums_path|basename }}"
    sha256sums_url: "{{ lookup('env', 'SHA256SUMS_URL')|default('https://' ~ host ~ '/' ~ sha256sums_path, true) }}"

    mountdir: "{{ lookup('env', 'mountdir')|default('/mnt/yardstick', true) }}"
    workspace: "{{ lookup('env', 'workspace')|default('/tmp/workspace/yardstick', true) }}"
    imgfile: "{{ workspace }}/yardstick-image.img"
    raw_imgfile_basename: "yardstick-{{ release }}-server.raw"
    raw_imgfile: "{{ workspace }}/{{ raw_imgfile_basename }}"
  environment:
    PATH: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/root/bin
  tasks:
    - group_by:
        key: image_builder

    - package: name=parted state=present

  # cleanup non-lxd
    - name: unmount all old mount points
      mount:
        name: "{{ item }}"
        state: unmounted
      with_items:
        # order matters
        - "{{ mountdir }}/proc"
        - "{{ mountdir }}"
        - "/mnt/{{ release }}"

    - name: kpartx -dv to delete all image partition device nodes
      command: kpartx -dv "{{ raw_imgfile }}"
      ignore_errors: true

    - name: delete {{ raw_imgfile }}
      file:
        path: "{{ raw_imgfile }}"
        state: absent

    # common
    - name: remove {{ mountdir }}
      file:
        path: "{{ mountdir }}"
        state: absent

    # download-common

    - name: remove {{ workspace }}
      file:
        path: "{{ workspace }}"
        state: directory

    - name: "fetch {{ image_url }} and verify "
      fetch_url_and_verify:
        url: "{{ image_url }}"
        sha256url: "{{ sha256sums_url }}"
        dest: "{{ image_dest }}"

#    - get_url:
#        url: "{{ sha256sums_url }}"
#        force: yes
#        dest: "{{ workspace }}/{{ sha256sums_filename }}"

    # must use wget to workaround ubuntu cloud SSL certs checking failures
#    - command: "curl -sS -o {{ workspace }}/{{ sha256sums_filename }} {{ sha256sums_url }}"


#    - command: cat "{{ workspace }}/{{ sha256sums_filename }}"
#      register: sha256sum_file
#
#    - set_fact:
#        image_sha256: "{{ sha256sum_file.stdout|regex_search('^([a-f0-9]+).*' ~ img ~ '$', '\\1', multiline=True) }}"

#    - get_url:
#        url: "{{ image_url }}"
#        force: yes
#        dest: "{{ workspace }}/{{ image_filename }}"
#        checksum: "sha256:{{ image_sha256 }}"
#        register: fetch_image_status
#        timeout: 300
#        retries: 2
#        until: fetch_image_status|succeeded

#    - name: "Fetch {{ image_url }}"
#    - command: "curl -sS -o {{ workspace }}/{{ image_filename }} {{ image_url }}"
#      register: fetch_image_status
#      timeout: 300
#      retries: 2
#      until: fetch_image_status|succeeded

#    - name: Verify sha256sum of downloaded image
#    - command: "sha256sum -c --ignore-missing {{ workspace }}/{{ sha256sums_filename }}"

#    - name: create loop devices
#      command: "mknod -m 660 /dev/loop{{ item }} b 7 {{ item }}"
#      args:
#        creates: "/dev/loop{{ item }}"
#      with_seq:
#        -

    # download non-lxd

    - name: convert image to raw
      command: "qemu-img convert {{ image_dest }} {{ raw_imgfile }}"


    # setup non-lxd

#     - shell: echo -e "d\\nn\\np\\n1\\n\\n\\nw" | parted -l "{{ raw_imgfile }}"
#    - parted:
#        device: "{{ raw_imgfile }}"
#        number: 1
#        state: present

    - name: create mknod devices in chroot
      command: "mknod -m 0660 /dev/loop{{ item }} b 7 {{ item }}"
      args:
        creates: "/dev/loop{{ item }}"
      with_sequence: start=0 end=9
      tags: mknod_devices

#    - command: losetup --show --partscan --find "{{ raw_imgfile }}"
#      register: loop_device_res
#
#    - debug:
#        var: loop_device_res
#        verbosity: 2
#
#    - set_fact:
#        loop_device: "{{ loop_device_res.stdout.strip() }}"
#
#    - wait_for:
#        path: "{{ loop_device }}"
#        state: present
#
#    - command: losetup
#    - command: dmsetup ls

    - name: find first partition device
#      command: kpartx -l "{{ loop_device }}"
      command: kpartx -l "{{ raw_imgfile }}"
      register: kpartx_res

    - set_fact:
        image_first_partition: "{{ kpartx_res.stdout_lines[0].split()[0] }}"

    - set_fact:
        # assume / is the first partition
        image_first_partition_device: "/dev/mapper/{{ image_first_partition }}"

    - name: use kpartx to create device nodes for the raw image loop device
      # operate on the loop device to avoid /dev namespace missing devices
#      command: kpartx -avs "{{ loop_device }}"
      command: kpartx -avs "{{ raw_imgfile }}"

    - name: parted dump raw image
#      command: parted "{{ loop_device }}" print
      command: parted "{{ raw_imgfile }}" print
      register: parted_res

    - debug:
        var: parted_res
        verbosity: 2

    - name: use blkid to find filesystem type of first partition device
      command: blkid -o value -s TYPE {{ image_first_partition_device }}
      register: blkid_res

    - set_fact:
        image_fs_type: "{{ blkid_res.stdout.strip() }}"

    - name: make tmp disposable fstab
      command: mktemp fake_fstab.XXXXXXXXXX
      register: mktemp_res

    - set_fact:
        fake_fstab: "{{ mktemp_res.stdout.strip() }}"

    - name: mount first parition on image device
      mount:
        src: "{{ image_first_partition_device }}"
        name: "{{ mountdir }}"
        # fstype is required
        fstype: "{{ image_fs_type }}"
        #fstab: "{{ fake_fstab }}"
        state: mounted

    - name: mount chroot /proc
      mount:
        src: none
        name: "{{ mountdir }}/proc"
        fstype: proc
        #fstab: "{{ fake_fstab }}"
        state: mounted

    - name: if arm copy qemu-aarch64-static into chroot
      copy:
        src: /usr/bin/qemu-aarch64-static
        dest: "{{ mountdir }}/usr/bin"
      when: 'YARD_IMG_ARCH == "arm64"'


    # setup lxd
#    - file: "path={{ mountdir }} state=directory"
#
#    - unarchive:
#        src: "{{ image_filename }}"
#        dest: "{{ mountdir }}"
#        remote_src: yes

    # end setup lxd

    # modify

    - name: create ubuntu policy-rc.d workaround
      copy:
        content: "{{ '#!/bin/sh\nexit 101\n' }}"
        dest: "{{ mountdir }}/usr/sbin/policy-rc.d"
        mode: 0755
      when: "target_os == 'Ubuntu'"

    - name: set img_modify_playbook
      set_fact:
        img_modify_playbook: ubuntu_server_cloudimg_modify.yml

    - debug:
        var: img_modify_playbook
        verbosity: 2

    - name: add chroot as host
      add_host:
        name: "{{ mountdir }}"
        groups: chroot_image,image_builder
        connection: chroot
        ansible_python_interpreter: /usr/bin/python3
        # set this host variable here
        nameserver_ip: "{{ ansible_dns.nameservers[0] }}"

- name: include {{ img_modify_playbook }}
  include: "{{ img_modify_playbook }}"

- name: run post build tasks
  include: post_build_yardstick_image.yml