Initialise bootstrapping of repository

Missing tests but most of the copy/pasta is done.

molecule_hetzner/cookiecutter/scenario/driver/hetznercloud/cookiecutter.json

@@ -0,0 +1,5 @@
+{
+    "molecule_directory": "molecule",
+    "role_name": "OVERRIDDEN",
+    "scenario_name": "OVERRIDDEN"
+}

molecule_hetzner/cookiecutter/scenario/driver/hetznercloud/{{cookiecutter.molecule_directory}}/{{cookiecutter.scenario_name}}/INSTALL.rst

@@ -0,0 +1,23 @@
+***************************************
+Hetzner Cloud driver installation guide
+***************************************
+
+Requirements
+============
+
+* Ansible >= 2.8
+* ``HCLOUD_TOKEN`` exposed in your environment
+
+Install
+=======
+
+Please refer to the `Virtual environment`_ documentation for installation best
+practices. If not using a virtual environment, please consider passing the
+widely recommended `'--user' flag`_ when invoking ``pip``.
+
+.. _Virtual environment: https://virtualenv.pypa.io/en/latest/
+.. _'--user' flag: https://packaging.python.org/tutorials/installing-packages/#installing-to-the-user-site
+
+.. code-block:: bash
+
+    $ pip install 'molecule[hetznercloud]'

molecule_hetzner/cookiecutter/scenario/driver/hetznercloud/{{cookiecutter.molecule_directory}}/{{cookiecutter.scenario_name}}/create.yml

@@ -0,0 +1,90 @@
+---
+{% raw -%}
+- name: Create
+  hosts: localhost
+  connection: local
+  gather_facts: false
+  no_log: "{{ molecule_no_log }}"
+  vars:
+    ssh_port: 22
+    ssh_user: root
+    ssh_path: "{{ lookup('env', 'MOLECULE_EPHEMERAL_DIRECTORY') }}/ssh_key"
+  tasks:
+    - name: Create SSH key
+      user:
+        name: "{{ lookup('env', 'USER') }}"
+        generate_ssh_key: true
+        ssh_key_file: "{{ ssh_path }}"
+        force: true
+      register: generated_ssh_key
+
+    - name: Register the SSH key name
+      set_fact:
+        ssh_key_name: "molecule-generated-{{ 12345 | random | to_uuid }}"
+
+    - name: Register SSH key for test instance(s)
+      hcloud_ssh_key:
+        name: "{{ ssh_key_name }}"
+        public_key: "{{ generated_ssh_key.ssh_public_key }}"
+        state: present
+
+    - name: Create molecule instance(s)
+      hcloud_server:
+        name: "{{ item.name }}"
+        server_type: "{{ item.server_type }}"
+        ssh_keys:
+          - "{{ ssh_key_name }}"
+        volumes: "{{ item.volumes | default(omit) }}"
+        image: "{{ item.image }}"
+        location: "{{ item.location | default(omit) }}"
+        datacenter: "{{ item.datacenter | default(omit) }}"
+        user_data: "{{ item.user_data | default(omit) }}"
+        api_token: "{{ lookup('env', 'HCLOUD_TOKEN') }}"
+        state: present
+      register: server
+      with_items: "{{ molecule_yml.platforms }}"
+      async: 7200
+      poll: 0
+
+    - name: Wait for instance(s) creation to complete
+      async_status:
+        jid: "{{ item.ansible_job_id }}"
+      register: hetzner_jobs
+      until: hetzner_jobs.finished
+      retries: 300
+      with_items: "{{ server.results }}"
+
+    # Mandatory configuration for Molecule to function.
+
+    - name: Populate instance config dict
+      set_fact:
+        instance_conf_dict: {
+          'instance': "{{ item.hcloud_server.name }}",
+          'ssh_key_name': "{{ ssh_key_name }}",
+          'address': "{{ item.hcloud_server.ipv4_address }}",
+          'user': "{{ ssh_user }}",
+          'port': "{{ ssh_port }}",
+          'identity_file': "{{ ssh_path }}", }
+      with_items: "{{ hetzner_jobs.results }}"
+      register: instance_config_dict
+      when: server.changed | bool
+
+    - name: Convert instance config dict to a list
+      set_fact:
+        instance_conf: "{{ instance_config_dict.results | map(attribute='ansible_facts.instance_conf_dict') | list }}"
+      when: server.changed | bool
+
+    - name: Dump instance config
+      copy:
+        content: "{{ instance_conf | to_json | from_json | molecule_to_yaml | molecule_header }}"
+        dest: "{{ molecule_instance_config }}"
+      when: server.changed | bool
+
+    - name: Wait for SSH
+      wait_for:
+        port: "{{ ssh_port }}"
+        host: "{{ item.address }}"
+        search_regex: SSH
+        delay: 10
+      with_items: "{{ lookup('file', molecule_instance_config) | molecule_from_yaml }}"
+{%- endraw %}

molecule_hetzner/cookiecutter/scenario/driver/hetznercloud/{{cookiecutter.molecule_directory}}/{{cookiecutter.scenario_name}}/destroy.yml

@@ -0,0 +1,59 @@
+---
+{% raw -%}
+- name: Destroy
+  hosts: localhost
+  connection: local
+  gather_facts: false
+  no_log: "{{ molecule_no_log }}"
+  tasks:
+    - name: Populate the instance config
+      block:
+        - name: Populate instance config from file
+          set_fact:
+            instance_conf: "{{ lookup('file', molecule_instance_config) | molecule_from_yaml }}"
+            skip_instances: false
+      rescue:
+        - name: Populate instance config when file missing
+          set_fact:
+            instance_conf: {}
+            skip_instances: true
+
+    - name: Destroy molecule instance(s)
+      hcloud_server:
+        name: "{{ item.instance }}"
+        api_token: "{{ lookup('env', 'HCLOUD_TOKEN') }}"
+        state: absent
+      register: server
+      with_items: "{{ instance_conf }}"
+      when: not skip_instances
+      async: 7200
+      poll: 0
+
+    - name: Wait for instance(s) deletion to complete
+      async_status:
+        jid: "{{ item.ansible_job_id }}"
+      register: hetzner_jobs
+      until: hetzner_jobs.finished
+      retries: 300
+      with_items: "{{ server.results }}"
+
+    - name: Remove registered SSH key
+      hcloud_ssh_key:
+        name: "{{ instance_conf[0].ssh_key_name }}"
+        state: absent
+      when:
+        - not skip_instances
+        - instance_conf  # must contain at least one instance
+
+    # Mandatory configuration for Molecule to function.
+
+    - name: Populate instance config
+      set_fact:
+        instance_conf: {}
+
+    - name: Dump instance config
+      copy:
+        content: "{{ instance_conf | molecule_to_yaml | molecule_header }}"
+        dest: "{{ molecule_instance_config }}"
+      when: server.changed | bool
+{%- endraw %}

molecule_hetzner/cookiecutter/scenario/driver/hetznercloud/{{cookiecutter.molecule_directory}}/{{cookiecutter.scenario_name}}/playbook.yml

@@ -0,0 +1,7 @@
+---
+- name: Converge
+  hosts: all
+  tasks:
+    - name: "Include {{ cookiecutter.role_name }}"
+      include_role:
+        name: "{{ cookiecutter.role_name }}"

molecule_hetzner/cookiecutter/scenario/driver/hetznercloud/{{cookiecutter.molecule_directory}}/{{cookiecutter.scenario_name}}/prepare.yml

@@ -0,0 +1,11 @@
+---
+{% raw -%}
+- name: Prepare
+  hosts: all
+  gather_facts: false
+  tasks:
+    - name: Install python for Ansible
+      raw: test -e /usr/bin/python || (apt -y update && apt install -y python-minimal python-zipstream)
+      become: true
+      changed_when: false
+{%- endraw %}

molecule_hetzner/hetznercloud.py

@@ -0,0 +1,174 @@
+#  Copyright (c) 2019 Red Hat, Inc.
+#
+#  Permission is hereby granted, free of charge, to any person obtaining a copy
+#  of this software and associated documentation files (the "Software"), to
+#  deal in the Software without restriction, including without limitation the
+#  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+#  sell copies of the Software, and to permit persons to whom the Software is
+#  furnished to do so, subject to the following conditions:
+#
+#  The above copyright notice and this permission notice shall be included in
+#  all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+#  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+#  DEALINGS IN THE SOFTWARE.
+
+import os
+
+from molecule import logger, util
+from molecule.api import Driver
+from molecule.util import lru_cache
+from molecule.util import sysexit_with_message
+
+log = logger.get_logger(__name__)
+
+
+class HetznerCloud(Driver):
+    """
+    The class responsible for managing `Hetzner Cloud`_ instances.
+    `Hetzner Cloud`_ is **not** the default driver used in Molecule.
+
+    Molecule leverages Ansible's `hcloud_server module`_, by mapping variables
+    from ``molecule.yml`` into ``create.yml`` and ``destroy.yml``.
+
+    .. important::
+
+        The ``hcloud_server`` module is only available in Ansible >= 2.8.
+
+    .. _`hcloud_server module`: https://docs.ansible.com/ansible/devel/modules/hcloud_server_module.html#hcloud-server-module
+
+    .. code-block:: yaml
+
+        driver:
+          name: hetznercloud
+        platforms:
+          - name: instance
+            server_type: cx11
+            image: debian-9
+
+    .. code-block:: bash
+
+        $ pip install 'molecule[hetznercloud]'
+
+    Change the options passed to the ssh client.
+
+    .. code-block:: yaml
+
+        driver:
+          name: hetznercloud
+          ssh_connection_options:
+            - '-o ControlPath=~/.ansible/cp/%r@%h-%p'
+
+    .. important::
+
+        The Hetzner Cloud driver implementation uses the Parmiko transport
+        provided by Ansible to avoid issues of connection hanging and
+        indefinite polling as experienced with the default OpenSSh based
+        transport.
+
+    .. important::
+
+        Molecule does not merge lists, when overriding the developer must
+        provide all options.
+
+    Provide the files Molecule will preserve upon each subcommand execution.
+
+    .. code-block:: yaml
+
+        driver:
+          name: hetznercloud
+          safe_files:
+            - foo
+    """  # noqa
+
+    def __init__(self, config=None):
+        super(HetznerCloud, self).__init__(config)
+        self._name = 'hetznercloud'
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = value
+
+    @property
+    def login_cmd_template(self):
+        connection_options = ' '.join(self.ssh_connection_options)
+
+        return (
+            'ssh {{address}} '
+            '-l {{user}} '
+            '-p {{port}} '
+            '-i {{identity_file}} '
+            '{}'
+        ).format(connection_options)
+
+    @property
+    def default_safe_files(self):
+        return [self.instance_config]
+
+    @property
+    def default_ssh_connection_options(self):
+        return self._get_ssh_connection_options()
+
+    def login_options(self, instance_name):
+        d = {'instance': instance_name}
+
+        return util.merge_dicts(d, self._get_instance_config(instance_name))
+
+    def ansible_connection_options(self, instance_name):
+        try:
+            d = self._get_instance_config(instance_name)
+
+            return {
+                'ansible_user': d['user'],
+                'ansible_host': d['address'],
+                'ansible_port': d['port'],
+                'ansible_private_key_file': d['identity_file'],
+                'connection': 'ssh',
+                'ansible_ssh_common_args': ' '.join(self.ssh_connection_options),
+            }
+        except StopIteration:
+            return {}
+        except IOError:
+            # Instance has yet to be provisioned , therefore the
+            # instance_config is not on disk.
+            return {}
+
+    def _get_instance_config(self, instance_name):
+        instance_config_dict = util.safe_load_file(self._config.driver.instance_config)
+
+        return next(
+            item for item in instance_config_dict if item['instance'] == instance_name
+        )
+
+    @lru_cache()
+    def sanity_checks(self):
+        """Hetzner Cloud driver sanity checks."""
+
+        log.info("Sanity checks: '{}'".format(self._name))
+
+        try:
+            import hcloud  # noqa
+        except ImportError:
+            msg = (
+                'Missing Hetzner Cloud driver dependency. Please '
+                "install via 'molecule[hetznercloud]' or refer to "
+                'your INSTALL.rst driver documentation file'
+            )
+            sysexit_with_message(msg)
+
+        if 'HCLOUD_TOKEN' not in os.environ:
+            msg = (
+                'Missing Hetzner Cloud API token. Please expose '
+                'the HCLOUD_TOKEN environment variable with your '
+                'account API token value'
+            )
+            sysexit_with_message(msg)