394 lines
13 KiB
Python
394 lines
13 KiB
Python
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright: (c) 2019, Hetzner Cloud GmbH <info@hetzner-cloud.de>
|
|
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
|
|
|
|
from __future__ import absolute_import, division, print_function
|
|
|
|
__metaclass__ = type
|
|
|
|
ANSIBLE_METADATA = {
|
|
"metadata_version": "1.1",
|
|
"status": ["preview"],
|
|
"supported_by": "community",
|
|
}
|
|
|
|
DOCUMENTATION = """
|
|
---
|
|
module: hcloud_server
|
|
|
|
short_description: Create and manage cloud servers on the Hetzner Cloud.
|
|
|
|
version_added: "2.8"
|
|
|
|
description:
|
|
- Create, update and manage cloud servers on the Hetzner Cloud.
|
|
|
|
author:
|
|
- Lukas Kaemmerling (@lkaemmerling)
|
|
|
|
options:
|
|
id:
|
|
description:
|
|
- The ID of the Hetzner Cloud server to manage.
|
|
- Only required if no server I(name) is given
|
|
type: int
|
|
name:
|
|
description:
|
|
- The Name of the Hetzner Cloud server to manage.
|
|
- Only required if no server I(id) is given or a server does not exists.
|
|
type: str
|
|
server_type:
|
|
description:
|
|
- The Server Type of the Hetzner Cloud server to manage.
|
|
- Required if server does not exists.
|
|
type: str
|
|
ssh_keys:
|
|
description:
|
|
- List of SSH Keys Names
|
|
type: list
|
|
volumes:
|
|
description:
|
|
- List of Volumes IDs that should be attached to the server on server creation.
|
|
type: list
|
|
image:
|
|
description:
|
|
- Image the server should be created from.
|
|
- Required if server does not exists.
|
|
type: str
|
|
location:
|
|
description:
|
|
- Location of Server.
|
|
- Required if no I(datacenter) is given and server does not exists.
|
|
type: str
|
|
datacenter:
|
|
description:
|
|
- Datacenter of Server.
|
|
- Required of no I(location) is given and server does not exists.
|
|
type: str
|
|
backups:
|
|
description:
|
|
- Enable or disable Backups for the given Server.
|
|
type: bool
|
|
default: no
|
|
upgrade_disk:
|
|
description:
|
|
- Resize the disk size, when resizing a server.
|
|
- If you want to downgrade the server later, this value should be False.
|
|
type: bool
|
|
default: no
|
|
force_upgrade:
|
|
description:
|
|
- Force the upgrade of the server.
|
|
- Power off the server if it is running on upgrade.
|
|
type: bool
|
|
default: no
|
|
user_data:
|
|
description:
|
|
- User Data to be passed to the server on creation.
|
|
- Only used if server does not exists.
|
|
type: str
|
|
labels:
|
|
description:
|
|
- User-defined labels (key-value pairs).
|
|
type: dict
|
|
state:
|
|
description:
|
|
- State of the server.
|
|
default: present
|
|
choices: [ absent, present, restarted, started, stopped ]
|
|
type: str
|
|
extends_documentation_fragment: hcloud
|
|
"""
|
|
|
|
EXAMPLES = """
|
|
- name: Create a basic server
|
|
hcloud_server:
|
|
name: my-server
|
|
server_type: cx11
|
|
image: ubuntu-18.04
|
|
state: present
|
|
|
|
- name: Create a basic server with ssh key
|
|
hcloud_server:
|
|
name: my-server
|
|
server_type: cx11
|
|
image: ubuntu-18.04
|
|
location: fsn1
|
|
ssh_keys:
|
|
- my-ssh-key
|
|
state: present
|
|
|
|
- name: Resize an existing server
|
|
hcloud_server:
|
|
name: my-server
|
|
server_type: cx21
|
|
keep_disk: yes
|
|
state: present
|
|
|
|
- name: Ensure the server is absent (remove if needed)
|
|
hcloud_server:
|
|
name: my-server
|
|
state: absent
|
|
|
|
- name: Ensure the server is started
|
|
hcloud_server:
|
|
name: my-server
|
|
state: started
|
|
|
|
- name: Ensure the server is stopped
|
|
hcloud_server:
|
|
name: my-server
|
|
state: stopped
|
|
|
|
- name: Ensure the server is restarted
|
|
hcloud_server:
|
|
name: my-server
|
|
state: restarted
|
|
"""
|
|
|
|
RETURN = """
|
|
hcloud_server:
|
|
description: The server instance
|
|
returned: Always
|
|
type: dict
|
|
sample: {
|
|
"backup_window": null,
|
|
"datacenter": "nbg1-dc3",
|
|
"id": 1937415,
|
|
"image": "ubuntu-18.04",
|
|
"ipv4_address": "116.203.104.109",
|
|
"ipv6": "2a01:4f8:1c1c:c140::/64",
|
|
"labels": {},
|
|
"location": "nbg1",
|
|
"name": "mein-server-2",
|
|
"rescue_enabled": false,
|
|
"server_type": "cx11",
|
|
"status": "running"
|
|
}
|
|
"""
|
|
|
|
from ansible.module_utils.basic import AnsibleModule
|
|
from ansible.module_utils._text import to_native
|
|
from ansible.module_utils.hcloud import Hcloud
|
|
|
|
try:
|
|
from hcloud.volumes.domain import Volume
|
|
from hcloud.ssh_keys.domain import SSHKey
|
|
from hcloud.servers.domain import Server
|
|
from hcloud import APIException
|
|
except ImportError:
|
|
pass
|
|
|
|
|
|
class AnsibleHcloudServer(Hcloud):
|
|
def __init__(self, module):
|
|
Hcloud.__init__(self, module, "hcloud_server")
|
|
self.hcloud_server = None
|
|
|
|
def _prepare_result(self):
|
|
return {
|
|
"id": to_native(self.hcloud_server.id),
|
|
"name": to_native(self.hcloud_server.name),
|
|
"ipv4_address": to_native(self.hcloud_server.public_net.ipv4.ip),
|
|
"ipv6": to_native(self.hcloud_server.public_net.ipv6.ip),
|
|
"image": to_native(self.hcloud_server.image.name),
|
|
"server_type": to_native(self.hcloud_server.server_type.name),
|
|
"datacenter": to_native(self.hcloud_server.datacenter.name),
|
|
"location": to_native(self.hcloud_server.datacenter.location.name),
|
|
"rescue_enabled": self.hcloud_server.rescue_enabled,
|
|
"backup_window": to_native(self.hcloud_server.backup_window),
|
|
"labels": self.hcloud_server.labels,
|
|
"status": to_native(self.hcloud_server.status),
|
|
}
|
|
|
|
def _get_server(self):
|
|
try:
|
|
if self.module.params.get("id") is not None:
|
|
self.hcloud_server = self.client.servers.get_by_id(
|
|
self.module.params.get("id")
|
|
)
|
|
else:
|
|
self.hcloud_server = self.client.servers.get_by_name(
|
|
self.module.params.get("name")
|
|
)
|
|
except APIException as e:
|
|
self.module.fail_json(msg=e.message)
|
|
|
|
def _create_server(self):
|
|
|
|
self.module.fail_on_missing_params(
|
|
required_params=["name", "server_type", "image"]
|
|
)
|
|
params = {
|
|
"name": self.module.params.get("name"),
|
|
"server_type": self.client.server_types.get_by_name(
|
|
self.module.params.get("server_type")
|
|
),
|
|
"image": self.client.images.get_by_name(self.module.params.get("image")),
|
|
"user_data": self.module.params.get("user_data"),
|
|
"labels": self.module.params.get("labels"),
|
|
}
|
|
|
|
if self.module.params.get("ssh_keys") is not None:
|
|
params["ssh_keys"] = [
|
|
SSHKey(name=ssh_key_name)
|
|
for ssh_key_name in self.module.params.get("ssh_keys")
|
|
]
|
|
|
|
if self.module.params.get("volumes") is not None:
|
|
params["volumes"] = [
|
|
Volume(id=volume_id) for volume_id in self.module.params.get("volumes")
|
|
]
|
|
|
|
if self.module.params.get("location") is None and self.module.params.get("datacenter") is None:
|
|
# When not given, the API will choose the location.
|
|
params["location"] = None
|
|
params["datacenter"] = None
|
|
elif self.module.params.get("location") is not None and self.module.params.get("datacenter") is None:
|
|
params["location"] = self.client.locations.get_by_name(
|
|
self.module.params.get("location")
|
|
)
|
|
elif self.module.params.get("location") is None and self.module.params.get("datacenter") is not None:
|
|
params["datacenter"] = self.client.datacenters.get_by_name(
|
|
self.module.params.get("datacenter")
|
|
)
|
|
|
|
if not self.module.check_mode:
|
|
resp = self.client.servers.create(**params)
|
|
self.result["root_password"] = resp.root_password
|
|
resp.action.wait_until_finished()
|
|
[action.wait_until_finished() for action in resp.next_actions]
|
|
self._mark_as_changed()
|
|
self._get_server()
|
|
|
|
def _update_server(self):
|
|
if self.module.params.get("backups") and self.hcloud_server.backup_window is None:
|
|
if not self.module.check_mode:
|
|
self.hcloud_server.enable_backup().wait_until_finished()
|
|
self._mark_as_changed()
|
|
elif not self.module.params.get("backups") and self.hcloud_server.backup_window is not None:
|
|
if not self.module.check_mode:
|
|
self.hcloud_server.disable_backup().wait_until_finished()
|
|
self._mark_as_changed()
|
|
|
|
labels = self.module.params.get("labels")
|
|
if labels is not None and labels != self.hcloud_server.labels:
|
|
if not self.module.check_mode:
|
|
self.hcloud_server.update(labels=labels)
|
|
self._mark_as_changed()
|
|
|
|
server_type = self.module.params.get("server_type")
|
|
if server_type is not None and self.hcloud_server.server_type.name != server_type:
|
|
previous_server_status = self.hcloud_server.status
|
|
state = self.module.params.get("state")
|
|
if previous_server_status == Server.STATUS_RUNNING:
|
|
if not self.module.check_mode:
|
|
if self.module.params.get("force_upgrade") or state == "stopped":
|
|
self.stop_server() # Only stopped server can be upgraded
|
|
else:
|
|
self.module.warn(
|
|
"You can not upgrade a running instance %s. You need to stop the instance or use force_upgrade=yes."
|
|
% self.hcloud_server.name
|
|
)
|
|
timeout = 100
|
|
if self.module.params.get("upgrade_disk"):
|
|
timeout = (
|
|
500
|
|
) # When we upgrade the disk too the resize progress takes some more time.
|
|
if not self.module.check_mode:
|
|
self.hcloud_server.change_type(
|
|
server_type=self.client.server_types.get_by_name(server_type),
|
|
upgrade_disk=self.module.params.get("upgrade_disk"),
|
|
).wait_until_finished(timeout)
|
|
if state == "present" and previous_server_status == Server.STATUS_RUNNING or state == "started":
|
|
self.start_server()
|
|
|
|
self._mark_as_changed()
|
|
self._get_server()
|
|
|
|
def start_server(self):
|
|
if self.hcloud_server.status != Server.STATUS_RUNNING:
|
|
if not self.module.check_mode:
|
|
self.client.servers.power_on(self.hcloud_server).wait_until_finished()
|
|
self._mark_as_changed()
|
|
self._get_server()
|
|
|
|
def stop_server(self):
|
|
if self.hcloud_server.status != Server.STATUS_OFF:
|
|
if not self.module.check_mode:
|
|
self.client.servers.power_off(self.hcloud_server).wait_until_finished()
|
|
self._mark_as_changed()
|
|
self._get_server()
|
|
|
|
def present_server(self):
|
|
self._get_server()
|
|
if self.hcloud_server is None:
|
|
self._create_server()
|
|
else:
|
|
self._update_server()
|
|
|
|
def delete_server(self):
|
|
self._get_server()
|
|
if self.hcloud_server is not None:
|
|
if not self.module.check_mode:
|
|
self.client.servers.delete(self.hcloud_server).wait_until_finished()
|
|
self._mark_as_changed()
|
|
self.hcloud_server = None
|
|
|
|
@staticmethod
|
|
def define_module():
|
|
return AnsibleModule(
|
|
argument_spec=dict(
|
|
id={"type": "int"},
|
|
name={"type": "str"},
|
|
image={"type": "str"},
|
|
server_type={"type": "str"},
|
|
location={"type": "str"},
|
|
datacenter={"type": "str"},
|
|
user_data={"type": "str"},
|
|
ssh_keys={"type": "list"},
|
|
volumes={"type": "list"},
|
|
labels={"type": "dict"},
|
|
backups={"type": "bool", "default": False},
|
|
upgrade_disk={"type": "bool", "default": False},
|
|
force_upgrade={"type": "bool", "default": False},
|
|
state={
|
|
"choices": ["absent", "present", "restarted", "started", "stopped"],
|
|
"default": "present",
|
|
},
|
|
**Hcloud.base_module_arguments()
|
|
),
|
|
required_one_of=[['id', 'name']],
|
|
mutually_exclusive=[["location", "datacenter"]],
|
|
supports_check_mode=True,
|
|
)
|
|
|
|
|
|
def main():
|
|
module = AnsibleHcloudServer.define_module()
|
|
|
|
hcloud = AnsibleHcloudServer(module)
|
|
state = module.params.get("state")
|
|
if state == "absent":
|
|
hcloud.delete_server()
|
|
elif state == "present":
|
|
hcloud.present_server()
|
|
elif state == "started":
|
|
hcloud.present_server()
|
|
hcloud.start_server()
|
|
elif state == "stopped":
|
|
hcloud.present_server()
|
|
hcloud.stop_server()
|
|
elif state == "restarted":
|
|
hcloud.present_server()
|
|
hcloud.stop_server()
|
|
hcloud.start_server()
|
|
|
|
module.exit_json(**hcloud.get_result())
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|