ansible/test/integration/targets/k8s/tasks/waiter.yml

- name: ensure that there are actually some nodes
  k8s_facts:
    kind: Node
  register: nodes

- block:
    - set_fact:
        wait_namespace: wait
    - name: ensure namespace exists
      k8s:
        definition:
          apiVersion: v1
          kind: Namespace
          metadata:
            name: "{{ wait_namespace }}"

    - name: add a simple pod
      k8s:
        definition:
          apiVersion: v1
          kind: Pod
          metadata:
            name: "{{ wait_pod_name }}"
            namespace: "{{ wait_namespace }}"
          spec: "{{ wait_pod_spec }}"
        wait: yes
      vars:
        wait_pod_name: wait-pod
        wait_pod_image: alpine:3.8
        wait_pod_command:
          - sleep
          - "10000"
      register: wait_pod
      ignore_errors: yes

    - name: assert that pod creation succeeded
      assert:
        that:
          - wait_pod is successful

    - name: add a daemonset
      k8s:
        definition:
          apiVersion: extensions/v1beta1
          kind: DaemonSet
          metadata:
            name: wait-daemonset
            namespace: "{{ wait_namespace }}"
          spec:
            selector:
              matchLabels:
                app: "{{ wait_pod_name }}"
            template: "{{ wait_pod_template }}"
        wait: yes
        wait_timeout: 180
      vars:
        wait_pod_name: wait-ds
        wait_pod_image: gcr.io/kuar-demo/kuard-amd64:1
      register: ds

    - name: check that daemonset wait worked
      assert:
        that:
          - ds.result.status.currentNumberScheduled == ds.result.status.desiredNumberScheduled

    - name: update a daemonset in check_mode
      k8s:
        definition:
          apiVersion: extensions/v1beta1
          kind: DaemonSet
          metadata:
            name: wait-daemonset
            namespace: "{{ wait_namespace }}"
          spec:
            selector:
              matchLabels:
                app: "{{ wait_pod_name }}"
            updateStrategy:
              type: RollingUpdate
            template: "{{ wait_pod_template }}"
        wait: yes
        wait_timeout: 180
      vars:
        wait_pod_name: wait-ds
        wait_pod_image: gcr.io/kuar-demo/kuard-amd64:2
      register: update_ds_check_mode

    - name: check that check_mode returned changed
      assert:
        that:
          - update_ds_check_mode is changed

    - name: update a daemonset
      k8s:
        definition:
          apiVersion: extensions/v1beta1
          kind: DaemonSet
          metadata:
            name: wait-daemonset
            namespace: "{{ wait_namespace }}"
          spec:
            selector:
              matchLabels:
                app: "{{ wait_pod_name }}"
            updateStrategy:
              type: RollingUpdate
            template: "{{ wait_pod_template }}"
        wait: yes
        wait_timeout: 180
      vars:
        wait_pod_name: wait-ds
        wait_pod_image: gcr.io/kuar-demo/kuard-amd64:2
      register: ds

    - name: get updated pods
      k8s_facts:
        api_version: v1
        kind: Pod
        namespace: "{{ wait_namespace }}"
        label_selectors:
          - app=wait-ds
      register: updated_ds_pods

    - name: check that daemonset wait worked
      assert:
        that:
          - ds.result.status.currentNumberScheduled == ds.result.status.desiredNumberScheduled
          - updated_ds_pods.resources[0].spec.containers[0].image.endswith(":2")

    - name: add a crashing pod
      k8s:
        definition:
          apiVersion: v1
          kind: Pod
          metadata:
            name: "{{ wait_pod_name }}"
            namespace: "{{ wait_namespace }}"
          spec: "{{ wait_pod_spec }}"
        wait: yes
        wait_timeout: 30
      vars:
        wait_pod_name: wait-crash-pod
        wait_pod_image: alpine:3.8
        wait_pod_command:
          - /bin/false
      register: crash_pod
      ignore_errors: yes

    - name: check that task failed
      assert:
        that:
          - crash_pod is failed

    - name: use a non-existent image
      k8s:
        definition:
          apiVersion: v1
          kind: Pod
          metadata:
            name: "{{ wait_pod_name }}"
            namespace: "{{ wait_namespace }}"
          spec: "{{ wait_pod_spec }}"
        wait: yes
        wait_timeout: 30
      vars:
        wait_pod_name: wait-no-image-pod
        wait_pod_image: i_made_this_up:and_this_too
      register: no_image_pod
      ignore_errors: yes

    - name: check that task failed
      assert:
        that:
          - no_image_pod is failed

    - name: add a deployment
      k8s:
        definition:
          apiVersion: extensions/v1beta1
          kind: Deployment
          metadata:
            name: wait-deploy
            namespace: "{{ wait_namespace }}"
          spec:
            replicas: 3
            selector:
              matchLabels:
                app: "{{ wait_pod_name }}"
            template: "{{ wait_pod_template }}"
        wait: yes
      vars:
        wait_pod_name: wait-deploy
        wait_pod_image: gcr.io/kuar-demo/kuard-amd64:1
        wait_pod_ports:
          - containerPort: 8080
            name: http
            protocol: TCP

      register: deploy

    - name: check that deployment wait worked
      assert:
        that:
          - deploy.result.status.availableReplicas == deploy.result.status.replicas

    - name: update a deployment
      k8s:
        definition:
          apiVersion: extensions/v1beta1
          kind: Deployment
          metadata:
            name: wait-deploy
            namespace: "{{ wait_namespace }}"
          spec:
            replicas: 3
            selector:
              matchLabels:
                app: "{{ wait_pod_name }}"
            template: "{{ wait_pod_template }}"
        wait: yes
      vars:
        wait_pod_name: wait-deploy
        wait_pod_image: gcr.io/kuar-demo/kuard-amd64:2
        wait_pod_ports:
          - containerPort: 8080
            name: http
            protocol: TCP
      register: update_deploy

    - name: get updated pods
      k8s_facts:
        api_version: v1
        kind: Pod
        namespace: "{{ wait_namespace }}"
        label_selectors:
          - app=wait-deploy
      register: updated_deploy_pods

    - name: check that deployment wait worked
      assert:
        that:
          - deploy.result.status.availableReplicas == deploy.result.status.replicas
          - updated_deploy_pods.resources[0].spec.containers[0].image.endswith(":2")

    - name: pause a deployment
      k8s:
        definition:
          apiVersion: extensions/v1beta1
          kind: Deployment
          metadata:
            name: wait-deploy
            namespace: "{{ wait_namespace }}"
          spec:
            paused: True
        wait: yes
        wait_condition:
          type: Progressing
          status: Unknown
          reason: DeploymentPaused
      register: pause_deploy

    - name: check that paused deployment wait worked
      assert:
        that:
          - condition.reason == "DeploymentPaused"
          - condition.status == "Unknown"
      vars:
        condition: '{{ pause_deploy.result.status.conditions | selectattr("type", "Progressing")).0 }}'

    - name: add a service based on the deployment
      k8s:
        definition:
          apiVersion: v1
          kind: Service
          metadata:
            name: wait-svc
            namespace: "{{ wait_namespace }}"
          spec:
            selector:
              app: "{{ wait_pod_name }}"
            ports:
              - port: 8080
                targetPort: 8080
                protocol: TCP
        wait: yes
      vars:
        wait_pod_name: wait-deploy
      register: service

    - name: assert that waiting for service works
      assert:
        that:
          - service is successful

    - name: add a crashing deployment
      k8s:
        definition:
          apiVersion: extensions/v1beta1
          kind: Deployment
          metadata:
            name: wait-crash-deploy
            namespace: "{{ wait_namespace }}"
          spec:
            replicas: 3
            selector:
              matchLabels:
                app: "{{ wait_pod_name }}"
            template: "{{ wait_pod_template }}"
        wait: yes
      vars:
        wait_pod_name: wait-crash-deploy
        wait_pod_image: alpine:3.8
        wait_pod_command:
          - /bin/false
      register: wait_crash_deploy
      ignore_errors: yes

    - name: check that task failed
      assert:
        that:
          - wait_crash_deploy is failed

    - name: remove Pod with very short timeout
      k8s:
        api_version: v1
        kind: Pod
        name: wait-pod
        namespace: "{{ wait_namespace }}"
        state: absent
        wait: yes
        wait_timeout: 5
      ignore_errors: yes
      register: short_wait_remove_pod

    - name: check that task failed
      assert:
        that:
          - short_wait_remove_pod is failed

  always:
    - name: remove namespace
      k8s:
        kind: Namespace
        name: "{{ wait_namespace }}"
        state: absent

  when: (nodes.resources | length) > 0