def startstop_machine(module, client, state):
"""
Starts or Stops a virtual machine.
module : AnsibleModule object
client: authenticated ionos-cloud object.
Returns:
True when the servers process the action successfully, false otherwise.
"""
if not isinstance(module.params.get('instance_ids'),
list) or len(module.params.get('instance_ids')) < 1:
module.fail_json(
msg=
'instance_ids should be a list of virtual machine ids or names, aborting'
)
datacenter = module.params.get('datacenter')
instance_ids = module.params.get('instance_ids')
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
server_server = ionoscloud.ServerApi(api_client=client)
# Locate UUID for datacenter if referenced by name.
datacenter_list = datacenter_server.datacenters_get(depth=2)
datacenter_id = _get_datacenter_id(datacenter_list, datacenter)
if not datacenter_id:
module.fail_json(msg='Virtual data center \'%s\' not found.' %
str(datacenter))
# Prefetch server list for later comparison.
server_list = server_server.datacenters_servers_get(
datacenter_id=datacenter_id, depth=2)
matched_instances = []
for instance in instance_ids:
# Locate UUID of server if referenced by name.
server_id = _get_server_id(server_list, instance)
if server_id:
if module.check_mode:
module.exit_json(changed=True)
server = _get_instance(server_list, server_id)
state = server.properties.vm_state
changed, server = _startstop_machine(module, client, datacenter_id,
server_id, state)
if changed:
matched_instances.append(server)
if len(matched_instances) == 0:
changed = False
else:
changed = True
return {
'action': state,
'changed': changed,
'failed': False,
'machines': [m.to_dict() for m in matched_instances]
}
def create_datacenter(module, client):
"""
Creates a Datacenter
This will create a new Datacenter in the specified location.
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
The datacenter ID if a new datacenter was created.
"""
name = module.params.get('name')
location = module.params.get('location')
description = module.params.get('description')
wait = module.params.get('wait')
wait_timeout = int(module.params.get('wait_timeout'))
datacenter_server = ionoscloud.DataCenterApi(client)
datacenters = datacenter_server.datacenters_get(depth=2)
for dc in datacenters.items:
if name == dc.properties.name and location == dc.properties.location:
return {
'changed': False,
'failed': False,
'action': 'create',
'datacenter': dc.to_dict()
}
datacenter_properties = DatacenterProperties(name=name,
description=description,
location=location)
datacenter = Datacenter(properties=datacenter_properties)
try:
response = datacenter_server.datacenters_post_with_http_info(
datacenter=datacenter)
(datacenter_response, _, headers) = response
if wait:
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id,
timeout=wait_timeout)
results = {
'changed': True,
'failed': False,
'action': 'create',
'datacenter': datacenter_response.to_dict()
}
return results
except ApiException as e:
module.fail_json(msg="failed to create the new datacenter: %s" %
to_native(e))
def delete_firewall_rule(module, client):
"""
Removes a firewall rule
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
True if the firewall rule was removed, false otherwise
"""
datacenter = module.params.get('datacenter')
server = module.params.get('server')
nic = module.params.get('nic')
name = module.params.get('name')
datacenter_server = ionoscloud.DataCenterApi(client)
server_server = ionoscloud.ServerApi(client)
nic_server = ionoscloud.NicApi(client)
# Locate UUID for virtual datacenter
datacenter_list = datacenter_server.datacenters_get(depth=2)
datacenter_id = _get_resource_id(datacenter_list, datacenter, module,
"Datacenter")
# Locate UUID for server
server_list = server_server.datacenters_servers_get(
datacenter_id=datacenter_id, depth=2)
server_id = _get_resource_id(server_list, server, module, "Server")
# Locate UUID for NIC
nic_list = nic_server.datacenters_servers_nics_get(
datacenter_id=datacenter_id, server_id=server_id, depth=2)
nic_id = _get_resource_id(nic_list, nic, module, "NIC")
# Locate UUID for firewall rule
firewall_rule_list = nic_server.datacenters_servers_nics_firewallrules_get(
datacenter_id=datacenter_id,
server_id=server_id,
nic_id=nic_id,
depth=2)
firewall_rule_id = _get_resource(firewall_rule_list, name)
if not firewall_rule_id:
module.exit_json(changed=False)
if module.check_mode:
module.exit_json(changed=True)
try:
nic_server.datacenters_servers_nics_firewallrules_delete(
datacenter_id=datacenter_id,
server_id=server_id,
nic_id=nic_id,
firewallrule_id=firewall_rule_id)
return {'changed': True, 'action': 'delete', 'id': firewall_rule_id}
except Exception as e:
module.fail_json(msg="failed to remove the firewall rule: %s" %
to_native(e))
def update_lan(module, client):
"""
Updates a LAN.
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
The LAN instance
"""
datacenter = module.params.get('datacenter')
name = module.params.get('name')
public = module.params.get('public')
ip_failover = module.params.get('ip_failover')
pcc_id = module.params.get('pcc_id')
wait = module.params.get('wait')
wait_timeout = module.params.get('wait_timeout')
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
lan_server = ionoscloud.LanApi(api_client=client)
# Locate UUID for virtual datacenter
datacenter_list = datacenter_server.datacenters_get(depth=2)
datacenter_id = _get_resource_id(datacenter_list, datacenter, module, "Data center")
# Prefetch a list of LANs.
lan_list = lan_server.datacenters_lans_get(datacenter_id, depth=2)
lan_id = _get_resource_id(lan_list, name, module, "LAN")
if module.check_mode:
module.exit_json(changed=True)
try:
if ip_failover:
for elem in ip_failover:
elem['nicUuid'] = elem.pop('nic_uuid')
lan_properties = LanProperties(name=name, ip_failover=ip_failover, pcc=pcc_id, public=public)
lan = Lan(properties=lan_properties)
response = lan_server.datacenters_lans_put_with_http_info(datacenter_id=datacenter_id, lan_id=lan_id, lan=lan)
(lan_response, _, headers) = response
if wait:
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id, timeout=wait_timeout)
return {
'failed': False,
'changed': True,
'action': 'update',
'lan': lan_response.to_dict()
}
except Exception as e:
module.fail_json(msg="failed to update the LAN: %s" % to_native(e))
def update_datacenter(module, client):
"""
Updates a Datacenter.
This will update a datacenter.
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
True if a new datacenter was updated, false otherwise
"""
name = module.params.get('name')
description = module.params.get('description')
datacenter_id = module.params.get('id')
wait = module.params.get('wait')
datacenter_server = ionoscloud.DataCenterApi(client)
if description is None:
return {'action': 'update', 'changed': False}
changed = False
response = None
if datacenter_id:
datacenter = Datacenter(properties={
'name': name,
'description': description
})
response = _update_datacenter(module, datacenter_server, client,
datacenter_id, datacenter, wait)
changed = response['changed']
else:
datacenters = datacenter_server.datacenters_get(depth=2)
for d in datacenters.items:
vdc = datacenter_server.datacenters_find_by_id(d.id)
if name == vdc.properties.name:
datacenter = Datacenter(properties={
'name': name,
'description': description
})
response = _update_datacenter(module, datacenter_server,
client, datacenter_id,
datacenter, wait)
changed = response['changed']
if not changed:
module.fail_json(
msg="failed to update the datacenter: The resource does not exist")
return {
'changed': changed,
'action': 'update',
'failed': response['failed'],
'datacenter': response['datacenter']
}
def restore_snapshot(module, client):
"""
Restores a snapshot.
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
True if the snapshot started restoring, false otherwise
"""
datacenter = module.params.get('datacenter')
volume = module.params.get('volume')
name = module.params.get('name')
wait = module.params.get('wait')
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
volume_server = ionoscloud.VolumeApi(api_client=client)
snapshot_server = ionoscloud.SnapshotApi(api_client=client)
# Locate UUID for virtual datacenter
datacenter_list = datacenter_server.datacenters_get(depth=2)
datacenter_id = _get_resource_id(datacenter_list, datacenter, module,
"Data center")
# Locate UUID for volume
volume_list = volume_server.datacenters_volumes_get(
datacenter_id=datacenter_id, depth=2)
volume_id = _get_resource_id(volume_list, volume, module, "Volume")
# Locate UUID for snapshot
snapshot_list = snapshot_server.snapshots_get(depth=2)
snapshot_id = _get_resource_id(snapshot_list, name, module, "Snapshot")
if module.check_mode:
module.exit_json(changed=True)
try:
response = volume_server.datacenters_volumes_restore_snapshot_post_with_http_info(
datacenter_id=datacenter_id,
volume_id=volume_id,
snapshot_id=snapshot_id)
(snapshot_response, _, headers) = response
if wait:
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id)
return {
'changed': True,
'failed': False,
'action': 'restore',
'snapshot': snapshot_response
}
except Exception as e:
module.fail_json(msg="failed to restore the snapshot: %s" %
to_native(e))
def fetch_resources(self, resource):
instance_data = {}
datacenter_server = ionoscloud.DataCenterApi(self.client)
lan_server = ionoscloud.LanApi(self.client)
location_server = ionoscloud.LocationApi(self.client)
image_server = ionoscloud.ImageApi(self.client)
server_server = ionoscloud.ServerApi(self.client)
volume_server = ionoscloud.VolumeApi(self.client)
datacenters = datacenter_server.datacenters_get(depth=3).items
if resource == 'datacenters' or resource == 'all':
instance_data['datacenters'] = datacenters
if resource == 'lans' or resource == 'servers' or resource == 'all':
lans = []
for datacenter in datacenters:
lans += lan_server.datacenters_lans_get(datacenter_id=datacenter.id, depth=3).items
instance_data['lans'] = lans
if resource == 'locations' or resource == 'all':
instance_data['locations'] = location_server.locations_get().items
if resource == 'images' or resource == 'all':
instance_data['images'] = image_server.images_get().items
if resource == 'servers' or resource == 'all' or resource == 'nics' or resource == 'fwrules':
servers = []
nics = []
fwrules = []
for datacenter in datacenters:
servers_list = server_server.datacenters_servers_get(datacenter_id=datacenter.id, depth=5).items
if resource == 'all' or resource == 'nics' or resource == 'fwrules':
for server in servers_list:
if len(server.entities.nics.items) > 0:
servers.append(server)
nics += server.entities.nics.items
if resource == 'all' or resource == 'fwrules':
for nic in server.entities.nics.items:
fwrules += nic.entities.firewallrules.items
if resource == 'servers' or resource == 'all':
instance_data['servers'] = servers
if resource == 'nics' or resource == 'all':
instance_data['nics'] = nics
if resource == 'fwrules' or resource == 'all':
instance_data['firewallrules'] = fwrules
if resource == 'volumes' or resource == 'all':
volumes = []
for datacenter in datacenters:
volumes += volume_server.datacenters_volumes_get(datacenter_id=datacenter.id, depth=3).items
instance_data['volumes'] = volumes
return instance_data
def delete_volume(module, client):
"""
Remove volumes.
This will remove one or more volumes from a datacenter.
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
True if the volumes were removed, false otherwise
"""
volume_server = ionoscloud.VolumeApi(client)
datacenter_server = ionoscloud.DataCenterApi(client)
if not isinstance(module.params.get('instance_ids'), list) or len(module.params.get('instance_ids')) < 1:
module.fail_json(msg='instance_ids should be a list of volume ids or names, aborting')
datacenter = module.params.get('datacenter')
changed = False
instance_ids = module.params.get('instance_ids')
volume_id = None
# Locate UUID for Datacenter
if not (uuid_match.match(datacenter)):
datacenter_list = datacenter_server.datacenters_get(depth=2)
for d in datacenter_list.items:
dc = datacenter_server.datacenters_find_by_id(d.id)
if datacenter in [dc.properties.name, dc.id]:
datacenter = d.id
break
for n in instance_ids:
if (uuid_match.match(n)):
_delete_volume(module, volume_server, datacenter, n)
changed = True
else:
volumes = volume_server.datacenters_volumes_get(datacenter, depth=2)
for v in volumes.items:
if n == v.properties.name:
volume_id = v.id
_delete_volume(module, volume_server, datacenter, volume_id)
changed = True
return {
'action': 'delete',
'changed': changed,
'id': volume_id
}
def delete_lan(module, client):
"""
Removes a LAN
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
True if the LAN was removed, false otherwise
"""
datacenter = module.params.get('datacenter')
name = module.params.get('name')
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
lan_server = ionoscloud.LanApi(api_client=client)
# Locate UUID for virtual datacenter
datacenter_list = datacenter_server.datacenters_get(depth=2)
datacenter_id = _get_resource_id(datacenter_list, datacenter, module, "Data center")
# Locate ID for LAN
lan_list = lan_server.datacenters_lans_get(datacenter_id=datacenter_id, depth=5)
lan = _get_resource(lan_list, name)
if not lan:
module.exit_json(changed=False)
lan_id = _get_resource_id(lan_list, name, module, "LAN")
if module.check_mode:
module.exit_json(changed=True)
try:
lan_server.datacenters_lans_delete(datacenter_id=datacenter_id, lan_id=lan_id)
return {
'action': 'delete',
'changed': True,
'id': lan_id
}
except Exception as e:
module.fail_json(msg="failed to remove the LAN: %s" % to_native(e))
def remove_datacenter(module, client):
"""
Removes a Datacenter.
This will remove a datacenter.
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
True if the datacenter was deleted, false otherwise
"""
name = module.params.get('name')
datacenter_id = module.params.get('id')
datacenter_server = ionoscloud.DataCenterApi(client)
wait = module.params.get('wait')
datacenters_list = datacenter_server.datacenters_get(depth=5)
if datacenter_id:
datacenter = _get_resource(datacenters_list, datacenter_id)
else:
datacenter = _get_resource(datacenters_list, name)
if not datacenter:
module.exit_json(changed=False)
if module.check_mode:
module.exit_json(changed=True)
try:
response = datacenter_server.datacenters_delete_with_http_info(
datacenter_id=datacenter)
(datacenter_response, _, headers) = response
if wait:
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id)
except Exception as e:
module.fail_json(msg="failed to remove the datacenter: %s" %
to_native(e))
return {'action': 'delete', 'changed': True, 'id': datacenter_id}
def _create_datacenter(module, client):
datacenter = module.params.get('datacenter')
location = module.params.get('location')
wait_timeout = module.params.get('wait_timeout')
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
datacenter_properties = DatacenterProperties(name=datacenter,
location=location)
datacenter = Datacenter(properties=datacenter_properties)
try:
response = datacenter_server.datacenters_post_with_http_info(
datacenter=datacenter)
(datacenter_response, _, headers) = response
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id, timeout=wait_timeout)
return datacenter_response
except ApiException as e:
module.fail_json(msg="failed to create the new datacenter: %s" %
to_native(e))
def create_firewall_rule(module, client):
"""
Creates a firewall rule.
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
The firewall rule instance being created
"""
datacenter = module.params.get('datacenter')
server = module.params.get('server')
nic = module.params.get('nic')
name = module.params.get('name')
protocol = module.params.get('protocol')
source_mac = module.params.get('source_mac')
source_ip = module.params.get('source_ip')
target_ip = module.params.get('target_ip')
port_range_start = module.params.get('port_range_start')
port_range_end = module.params.get('port_range_end')
icmp_type = module.params.get('icmp_type')
icmp_code = module.params.get('icmp_code')
wait = module.params.get('wait')
wait_timeout = module.params.get('wait_timeout')
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
server_server = ionoscloud.ServerApi(api_client=client)
nic_server = ionoscloud.NicApi(api_client=client)
# Locate UUID for virtual datacenter
datacenter_list = datacenter_server.datacenters_get(depth=2)
datacenter_id = _get_resource_id(datacenter_list, datacenter, module,
"Data center")
# Locate UUID for server
server_list = server_server.datacenters_servers_get(
datacenter_id=datacenter_id, depth=2)
server_id = _get_resource_id(server_list, server, module, "Server")
# Locate UUID for NIC
nic_list = nic_server.datacenters_servers_nics_get(
datacenter_id=datacenter_id, server_id=server_id, depth=2)
nic_id = _get_resource_id(nic_list, nic, module, "NIC")
fw_list = nic_server.datacenters_servers_nics_firewallrules_get(
datacenter_id=datacenter_id,
server_id=server_id,
nic_id=nic_id,
depth=2)
f = None
for fw in fw_list.items:
if name == fw.properties.name:
f = fw
break
should_change = f is None
if module.check_mode:
module.exit_json(changed=should_change)
if not should_change:
return {
'changed': should_change,
'failed': False,
'action': 'create',
'firewall_rule': f.to_dict()
}
try:
current_nic = nic_server.datacenters_servers_nics_find_by_id(
datacenter_id=datacenter_id, server_id=server_id, nic_id=nic_id)
nic = Nic(properties=NicProperties(firewall_active=True,
lan=current_nic.properties.lan))
nic_server.datacenters_servers_nics_put(datacenter_id=datacenter_id,
server_id=server_id,
nic_id=nic_id,
nic=nic)
except Exception as e:
module.fail_json(msg='Unable to activate the NIC firewall.' %
to_native(e))
firewall_properties = FirewallruleProperties(
name=name,
protocol=protocol,
source_mac=source_mac,
source_ip=source_ip,
target_ip=target_ip,
icmp_code=icmp_code,
icmp_type=icmp_type,
port_range_start=port_range_start,
port_range_end=port_range_end)
firewall_rule = FirewallRule(properties=firewall_properties)
try:
response = nic_server.datacenters_servers_nics_firewallrules_post_with_http_info(
datacenter_id=datacenter_id,
server_id=server_id,
nic_id=nic_id,
firewallrule=firewall_rule)
(firewall_rule_response, _, headers) = response
if wait:
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id,
timeout=wait_timeout)
return {
'changed': True,
'failed': False,
'action': 'create',
'firewall_rule': firewall_rule_response.to_dict()
}
except Exception as e:
module.fail_json(msg="failed to create the firewall rule: %s" %
to_native(e))
def create_snapshot(module, client):
"""
Creates a snapshot.
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
The snapshot instance
"""
datacenter = module.params.get('datacenter')
volume = module.params.get('volume')
name = module.params.get('name')
description = module.params.get('description')
wait = module.params.get('wait')
wait_timeout = module.params.get('wait_timeout')
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
volume_server = ionoscloud.VolumeApi(api_client=client)
snapshot_server = ionoscloud.SnapshotApi(api_client=client)
# Locate UUID for virtual datacenter
datacenter_list = datacenter_server.datacenters_get(depth=2)
datacenter_id = _get_resource_id(datacenter_list, datacenter, module,
"Data center")
# Locate UUID for volume
volume_list = volume_server.datacenters_volumes_get(
datacenter_id=datacenter_id, depth=2)
volume_id = _get_resource_id(volume_list, volume, module, "Volume")
snapshot_list = snapshot_server.snapshots_get(depth=2)
snapshot = None
for s in snapshot_list.items:
if name == s.properties.name:
snapshot = s
break
should_change = snapshot is None
if module.check_mode:
module.exit_json(changed=should_change)
if not should_change:
return {
'changed': False,
'failed': False,
'action': 'create',
'snapshot': snapshot.to_dict()
}
try:
response = volume_server.datacenters_volumes_create_snapshot_post_with_http_info(
datacenter_id=datacenter_id,
volume_id=volume_id,
name=name,
description=description)
(snapshot_response, _, headers) = response
if wait:
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id,
timeout=wait_timeout)
return {
'changed': True,
'failed': False,
'action': 'create',
'snapshot': snapshot_response.to_dict()
}
except Exception as e:
module.fail_json(msg="failed to create the snapshot: %s" %
to_native(e))
def create_virtual_machine(module, client):
"""
Create new virtual machine
module : AnsibleModule object
client: authenticated ionos-cloud object
Returns:
True if a new virtual machine was created, false otherwise
"""
datacenter = module.params.get('datacenter')
name = module.params.get('name')
auto_increment = module.params.get('auto_increment')
count = module.params.get('count')
lan = module.params.get('lan')
wait_timeout = module.params.get('wait_timeout')
datacenter_found = False
virtual_machines = []
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
server_server = ionoscloud.ServerApi(api_client=client)
nic_server = ionoscloud.NicApi(api_client=client)
# Locate UUID for datacenter if referenced by name.
datacenter_list = datacenter_server.datacenters_get(depth=2)
datacenter_id = _get_datacenter_id(datacenter_list, datacenter)
if datacenter_id:
datacenter_found = True
if not datacenter_found:
datacenter_response = _create_datacenter(module, client)
datacenter_id = datacenter_response.id
if auto_increment:
numbers = set()
count_offset = 1
try:
name % 0
except TypeError as e:
if (hasattr(e, 'message') and e.message.startswith('not all')
or to_native(e).startswith('not all')):
name = '%s%%d' % name
else:
module.fail_json(msg=e, exception=traceback.format_exc())
number_range = xrange(count_offset,
count_offset + count + len(numbers))
available_numbers = list(set(number_range).difference(numbers))
names = []
numbers_to_use = available_numbers[:count]
for number in numbers_to_use:
names.append(name % number)
else:
names = [name]
changed = False
# Prefetch a list of servers for later comparison.
server_list = server_server.datacenters_servers_get(
datacenter_id=datacenter_id, depth=3)
for name in names:
# Skip server creation if the server already exists.
server = _get_instance(server_list, name)
if server is not None:
virtual_machines.append(server)
continue
create_response = _create_machine(module, client, str(datacenter_id),
name)
changed = True
virtual_machines.append(create_response)
return {
'changed': changed,
'failed': False,
'machines': [v.to_dict() for v in virtual_machines],
'action': 'create'
}
def delete_nic(module, client):
"""
Removes a NIC
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
True if the NIC was removed, false otherwise
"""
datacenter = module.params.get('datacenter')
server = module.params.get('server')
name = module.params.get('name')
wait = module.params.get('wait')
wait_timeout = module.params.get('wait_timeout')
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
server_server = ionoscloud.ServerApi(api_client=client)
nic_server = ionoscloud.NicApi(api_client=client)
# Locate UUID for Datacenter
if not (uuid_match.match(datacenter)):
datacenter_list = datacenter_server.datacenters_get(depth=2)
for d in datacenter_list.items:
dc = datacenter_server.datacenters_find_by_id(datacenter_id=d.id)
if datacenter == dc.properties.name:
datacenter = d.id
break
# Locate UUID for Server
server_found = False
if not (uuid_match.match(server)):
server_list = server_server.datacenters_servers_get(datacenter,
depth=2)
for s in server_list.items:
if server == s.properties.name:
server_found = True
server = s.id
break
if not server_found:
return {'action': 'delete', 'changed': False, 'id': name}
# Locate UUID for NIC
nic_found = False
if not (uuid_match.match(name)):
nic_list = nic_server.datacenters_servers_nics_get(
datacenter_id=datacenter, server_id=server, depth=2)
for n in nic_list.items:
if name == n.properties.name:
nic_found = True
name = n.id
break
if not nic_found:
module.exit_json(changed=False)
if module.check_mode:
module.exit_json(changed=True)
try:
response = nic_server.datacenters_servers_nics_delete_with_http_info(
datacenter_id=datacenter, server_id=server, nic_id=name)
(nic_response, _, headers) = response
if wait:
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id,
timeout=wait_timeout)
return {'action': 'delete', 'changed': True, 'id': name}
except Exception as e:
module.fail_json(msg="failed to remove the NIC: %s" % to_native(e))
def update_nic(module, client):
"""
Updates a NIC.
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
The NIC instance being updated
"""
datacenter = module.params.get('datacenter')
server = module.params.get('server')
lan = module.params.get('lan')
nat = module.params.get('nat')
dhcp = module.params.get('dhcp')
firewall_active = module.params.get('firewall_active')
ips = module.params.get('ips')
id = module.params.get('id')
name = module.params.get('name')
wait = module.params.get('wait')
wait_timeout = module.params.get('wait_timeout')
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
server_server = ionoscloud.ServerApi(api_client=client)
nic_server = ionoscloud.NicApi(api_client=client)
# Locate UUID for Datacenter
if not (uuid_match.match(datacenter)):
datacenter_list = datacenter_server.datacenters_get(depth=2)
for d in datacenter_list.items:
dc = datacenter_server.datacenters_find_by_id(datacenter_id=d.id)
if datacenter == dc.properties.name:
datacenter = d.id
break
# Locate UUID for Server
if not (uuid_match.match(server)):
server_list = server_server.datacenters_servers_get(datacenter,
depth=2)
for s in server_list.items:
if server == s.properties.name:
server = s.id
break
nic = None
# Locate NIC to update
nic_list = nic_server.datacenters_servers_nics_get(
datacenter_id=datacenter, server_id=server, depth=2)
for n in nic_list.items:
if name == n.properties.name or id == n.id:
nic = n
break
if not nic:
module.fail_json(msg="NIC could not be found.")
if module.check_mode:
module.exit_json(changed=True)
try:
if lan is None:
lan = nic.properties.lan
if firewall_active is None:
firewall_active = nic.properties.firewall_active
if nat is None:
nat = nic.properties.nat
if dhcp is None:
dhcp = nic.properties.dhcp
nic_properties = NicProperties(ips=ips,
dhcp=dhcp,
lan=lan,
firewall_active=firewall_active,
nat=nat,
name=name)
response = nic_server.datacenters_servers_nics_patch_with_http_info(
datacenter_id=datacenter,
server_id=server,
nic_id=nic.id,
nic=nic_properties)
(nic_response, _, headers) = response
if wait:
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id,
timeout=wait_timeout)
nic_response = nic_server.datacenters_servers_nics_find_by_id(
datacenter_id=datacenter,
server_id=server,
nic_id=nic_response.id)
return {
'changed': True,
'failed': False,
'action': 'update',
'nic': nic_response.to_dict()
}
except Exception as e:
module.fail_json(msg="failed to update the NIC: %s" % to_native(e))
def update_server(module, client):
"""
Update servers.
This will update one or more servers.
module : AnsibleModule object
client: authenticated ionos-cloud object.
Returns:
dict of updated servers
"""
datacenter = module.params.get('datacenter')
instance_ids = module.params.get('instance_ids')
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
server_server = ionoscloud.ServerApi(api_client=client)
if not isinstance(module.params.get('instance_ids'),
list) or len(module.params.get('instance_ids')) < 1:
module.fail_json(
msg=
'instance_ids should be a list of virtual machine ids or names, aborting'
)
# Locate UUID for datacenter if referenced by name.
datacenter_list = datacenter_server.datacenters_get(depth=2)
datacenter_id = _get_datacenter_id(datacenter_list, datacenter)
if not datacenter_id:
module.fail_json(msg='Virtual data center \'%s\' not found.' %
str(datacenter))
updated_servers = []
cores = module.params.get('cores')
ram = module.params.get('ram')
cpu_family = module.params.get('cpu_family')
availability_zone = module.params.get('availability_zone')
server_list = server_server.datacenters_servers_get(
datacenter_id=datacenter_id, depth=2)
for instance in instance_ids:
server = None
for s in server_list.items:
if instance in (s.properties.name, s.id):
server = s
break
if not server:
module.fail_json(msg='Server \'%s\' not found.' % str(instance))
if module.check_mode:
module.exit_json(changed=True)
try:
server_properties = ServerProperties(
cores=cores,
ram=ram,
availability_zone=availability_zone,
cpu_family=cpu_family)
new_server = Server(properties=server_properties)
server_response = server_server.datacenters_servers_put(
datacenter_id=datacenter_id,
server_id=server.id,
server=new_server)
except Exception as e:
module.fail_json(msg="failed to update the server: %s" %
to_native(e),
exception=traceback.format_exc())
else:
updated_servers.append(server_response)
return {
'failed': False,
'changed': True,
'machines': [s.to_dict() for s in updated_servers],
'action': 'update'
}
def create_lan(module, client):
"""
Creates a LAN.
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
The LAN instance
"""
datacenter = module.params.get('datacenter')
name = module.params.get('name')
public = module.params.get('public')
wait = module.params.get('wait')
wait_timeout = module.params.get('wait_timeout')
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
lan_server = ionoscloud.LanApi(api_client=client)
# Locate UUID for virtual datacenter
datacenter_list = datacenter_server.datacenters_get(depth=2)
datacenter_id = _get_resource_id(datacenter_list, datacenter, module, "Data center")
lan_list = lan_server.datacenters_lans_get(datacenter_id, depth=2)
lan = None
for i in lan_list.items:
if name == i.properties.name:
lan = i
break
should_change = lan is None
if module.check_mode:
module.exit_json(changed=should_change)
if not should_change:
return {
'changed': should_change,
'failed': False,
'action': 'create',
'lan': lan.to_dict(),
}
lan_response = None
try:
lan_properties = LanPropertiesPost(name=name,
public=public)
lan = LanPost(properties=lan_properties)
response = lan_server.datacenters_lans_post_with_http_info(datacenter_id=datacenter_id, lan=lan)
(lan_response, _, headers) = response
if wait:
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id, timeout=wait_timeout)
return {
'failed': False,
'changed': True,
'action': 'create',
'lan': lan_response.to_dict()
}
except Exception as e:
module.fail_json(msg="failed to create the LAN: %s" % to_native(e))
def update_firewall_rule(module, client):
"""
Updates a firewall rule.
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
The firewall rule instance being updated
"""
datacenter = module.params.get('datacenter')
server = module.params.get('server')
nic = module.params.get('nic')
name = module.params.get('name')
source_mac = module.params.get('source_mac')
source_ip = module.params.get('source_ip')
target_ip = module.params.get('target_ip')
port_range_start = module.params.get('port_range_start')
port_range_end = module.params.get('port_range_end')
icmp_type = module.params.get('icmp_type')
icmp_code = module.params.get('icmp_code')
wait = module.params.get('wait')
wait_timeout = module.params.get('wait_timeout')
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
server_server = ionoscloud.ServerApi(api_client=client)
nic_server = ionoscloud.NicApi(api_client=client)
# Locate UUID for virtual datacenter
datacenter_list = datacenter_server.datacenters_get(depth=2)
datacenter_id = _get_resource_id(datacenter_list, datacenter, module,
"Data center")
# Locate UUID for server
server_list = server_server.datacenters_servers_get(
datacenter_id=datacenter_id, depth=2)
server_id = _get_resource_id(server_list, server, module, "Server")
# Locate UUID for NIC
nic_list = nic_server.datacenters_servers_nics_get(
datacenter_id=datacenter_id, server_id=server_id, depth=2)
nic_id = _get_resource_id(nic_list, nic, module, "NIC")
# Locate UUID for firewall rule
fw_list = nic_server.datacenters_servers_nics_firewallrules_get(
datacenter_id=datacenter_id,
server_id=server_id,
nic_id=nic_id,
depth=2)
fw_id = _get_resource_id(fw_list, name, module, "Firewall rule")
if module.check_mode:
module.exit_json(changed=True)
try:
firewall_rule_properties = FirewallruleProperties(
source_mac=source_mac, source_ip=source_ip, target_ip=target_ip)
if port_range_start or port_range_end:
firewall_rule_properties.port_range_start = port_range_start
firewall_rule_properties.port_range_end = port_range_end
if icmp_type or icmp_code:
firewall_rule_properties.icmp_code = icmp_code
firewall_rule_properties.icmp_type = icmp_type
response = nic_server.datacenters_servers_nics_firewallrules_patch_with_http_info(
datacenter_id=datacenter_id,
server_id=server_id,
nic_id=nic_id,
firewallrule_id=fw_id,
firewallrule=firewall_rule_properties)
(firewall_rule_response, _, headers) = response
if wait:
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id,
timeout=wait_timeout)
return {
'changed': True,
'failed': False,
'action': 'update',
'firewall_rule': firewall_rule_response.to_dict()
}
except Exception as e:
module.fail_json(msg="failed to update the firewall rule: %s" %
to_native(e))
def update_volume(module, client):
"""
Update volumes.
This will update one or more volumes in a datacenter.
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
dict of updated volumes
"""
datacenter = module.params.get('datacenter')
instance_ids = module.params.get('instance_ids')
volume_server = ionoscloud.VolumeApi(client)
datacenter_server = ionoscloud.DataCenterApi(client)
datacenter_found = False
failed = True
changed = False
volumes = []
update_response = None
datacenter_list = datacenter_server.datacenters_get(depth=2)
for d in datacenter_list.items:
dc = datacenter_server.datacenters_find_by_id(d.id)
if datacenter in [dc.properties.name, dc.id]:
datacenter = d.id
datacenter_found = True
break
if not datacenter_found:
module.fail_json(msg='datacenter could not be found.')
for n in instance_ids:
if (uuid_match.match(n)):
update_response = _update_volume(module, volume_server, client, datacenter, n)
changed = True
else:
volume_list = volume_server.datacenters_volumes_get(datacenter, depth=2)
for v in volume_list.items:
if n == v.properties.name:
volume_id = v.id
update_response = _update_volume(module, volume_server, client, datacenter, volume_id)
changed = True
volumes.append(update_response)
failed = False
results = {
'changed': changed,
'failed': failed,
'volumes': [v.to_dict() for v in volumes],
'action': 'update',
'instance_ids': {
'instances': [i.id for i in volumes],
}
}
return results
def create_volume(module, client):
"""
Create volumes.
This will create one or more volumes in a datacenter.
module : AnsibleModule object
client: authenticated ionoscloud object.
Returns:
dict of created volumes
"""
datacenter = module.params.get('datacenter')
name = module.params.get('name')
auto_increment = module.params.get('auto_increment')
count = module.params.get('count')
volume_server = ionoscloud.VolumeApi(client)
datacenter_server = ionoscloud.DataCenterApi(client)
servers_server = ionoscloud.ServerApi(client)
datacenter_found = False
volumes = []
instance_ids = []
datacenter_list = datacenter_server.datacenters_get(depth=2)
for d in datacenter_list.items:
dc = datacenter_server.datacenters_find_by_id(d.id)
if datacenter in [dc.properties.name, dc.id]:
datacenter = d.id
datacenter_found = True
break
if not datacenter_found:
module.fail_json(msg='datacenter could not be found.')
if auto_increment:
numbers = set()
count_offset = 1
try:
name % 0
except TypeError as e:
if (hasattr(e, 'message') and e.message.startswith('not all') or to_native(e).startswith('not all')):
name = '%s%%d' % name
else:
module.fail_json(msg=e.message, exception=traceback.format_exc())
number_range = xrange(count_offset, count_offset + count + len(numbers))
available_numbers = list(set(number_range).difference(numbers))
names = []
numbers_to_use = available_numbers[:count]
for number in numbers_to_use:
names.append(name % number)
else:
names = [name] * count
changed = False
# Prefetch a list of volumes for later comparison.
volume_list = volume_server.datacenters_volumes_get(datacenter, depth=2)
for name in names:
# Skip volume creation if a volume with the same name already exists.
if _get_instance_id(volume_list, name):
volumes.append(_get_resource(volume_list, name))
continue
create_response = _create_volume(module, volume_server, str(datacenter), name, client)
volumes.append(create_response)
instance_ids.append(create_response.id)
_attach_volume(module, servers_server, datacenter, create_response.id)
changed = True
results = {
'changed': changed,
'failed': False,
'volumes': [v.to_dict() for v in volumes],
'action': 'create',
'instance_ids': instance_ids
}
return results
def remove_virtual_machine(module, client):
"""
Removes a virtual machine.
This will remove the virtual machine along with the bootVolume.
module : AnsibleModule object
client: authenticated ionos-cloud object.
Not yet supported: handle deletion of attached data disks.
Returns:
True if a new virtual server was deleted, false otherwise
"""
datacenter = module.params.get('datacenter')
instance_ids = module.params.get('instance_ids')
remove_boot_volume = module.params.get('remove_boot_volume')
changed = False
datacenter_server = ionoscloud.DataCenterApi(api_client=client)
server_server = ionoscloud.ServerApi(api_client=client)
server_id = None
if not isinstance(module.params.get('instance_ids'),
list) or len(module.params.get('instance_ids')) < 1:
module.fail_json(
msg=
'instance_ids should be a list of virtual machine ids or names, aborting'
)
# Locate UUID for datacenter if referenced by name.
datacenter_list = datacenter_server.datacenters_get(depth=2)
datacenter_id = _get_datacenter_id(datacenter_list, datacenter)
if not datacenter_id:
module.fail_json(msg='Virtual data center \'%s\' not found.' %
str(datacenter))
# Prefetch server list for later comparison.
server_list = server_server.datacenters_servers_get(
datacenter_id=datacenter_id, depth=2)
for instance in instance_ids:
# Locate UUID for server if referenced by name.
server_id = _get_server_id(server_list, instance)
if server_id:
if module.check_mode:
module.exit_json(changed=True)
# Remove the server's boot volume
if remove_boot_volume:
_remove_boot_volume(module, client, datacenter_id, server_id)
# Remove the server
try:
server_server.datacenters_servers_delete(
datacenter_id, server_id)
except Exception as e:
module.fail_json(
msg="failed to terminate the virtual server: %s" %
to_native(e),
exception=traceback.format_exc())
else:
changed = True
return {'action': 'delete', 'changed': changed, 'id': server_id}
