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 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 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 get_host_info(self):
"""Generate a JSON response to a --host call"""
host = self.args.host
# Check if host is specified by UUID
if re.match('[\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}', host, re.I):
for server in self.data['servers']:
if host == server.id:
datacenter_id = self._parse_id_from_href(server['href'], 2)
return ionoscloud.ServerApi(self.client).datacenters_servers_get(datacenter_id=datacenter_id, depth=5)
else:
for server in self.data.servers:
for nic in server.entities.nics.items:
for ip in nic.properties.ips:
if host == ip:
datacenter_id = self._parse_id_from_href(server['href'], 2)
server_id = self._parse_id_from_href(server['href'], 0)
return ionoscloud.ServerApi(self.client).datacenters_servers_get(datacenter_id=datacenter_id,
depth=5)
return {}
def _remove_boot_volume(module, client, datacenter_id, server_id):
"""
Remove the boot volume from the server
"""
server_server = ionoscloud.ServerApi(api_client=client)
try:
server = server_server.datacenters_servers_find_by_id(datacenter_id,
server_id,
depth=2)
volume = server.properties.boot_volume
if volume:
server_server.datacenters_servers_volumes_delete(
datacenter_id, server_id, volume.id)
except Exception as e:
module.fail_json(msg="failed to remove the server's boot volume: %s" %
to_native(e),
exception=traceback.format_exc())
def _startstop_machine(module, client, datacenter_id, server_id,
current_state):
state = module.params.get('state')
server_server = ionoscloud.ServerApi(api_client=client)
server = None
changed = False
try:
if state == 'running':
if current_state != 'RUNNING':
response = server_server.datacenters_servers_start_post_with_http_info(
datacenter_id, server_id)
(_, _, headers) = response
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id)
server_response = server_server.datacenters_servers_find_by_id(
datacenter_id, server_id)
if server_response.properties.vm_state == 'RUNNING':
changed = True
server = server_response
else:
if current_state != 'SHUTOFF':
response = server_server.datacenters_servers_stop_post_with_http_info(
datacenter_id, server_id)
(_, _, headers) = response
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id)
server_response = server_server.datacenters_servers_find_by_id(
datacenter_id, server_id)
if server_response.properties.vm_state == 'SHUTOFF':
changed = True
server = server_response
except Exception as e:
module.fail_json(
msg="failed to start or stop the virtual machine %s at %s: %s" %
(server_id, datacenter_id, to_native(e)))
return changed, server
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 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}
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_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 _create_machine(module, client, datacenter, name):
cores = module.params.get('cores')
ram = module.params.get('ram')
cpu_family = module.params.get('cpu_family')
volume_size = module.params.get('volume_size')
disk_type = module.params.get('disk_type')
availability_zone = module.params.get('availability_zone')
volume_availability_zone = module.params.get('volume_availability_zone')
image_password = module.params.get('image_password')
ssh_keys = module.params.get('ssh_keys')
bus = module.params.get('bus')
lan = module.params.get('lan')
nat = module.params.get('nat')
image = module.params.get('image')
assign_public_ip = module.boolean(module.params.get('assign_public_ip'))
nic_ips = module.params.get('nic_ips')
wait = module.params.get('wait')
wait_timeout = module.params.get('wait_timeout')
server_server = ionoscloud.ServerApi(api_client=client)
lan_server = ionoscloud.LanApi(api_client=client)
nics = []
if assign_public_ip:
lans_list = lan_server.datacenters_lans_get(datacenter_id=datacenter,
depth=2).items
public_lan = _get_lan_by_id_or_properties(lans_list, public=True)
public_ip_lan_id = public_lan.id if public_lan is not None else None
if public_ip_lan_id is None:
lan_properties = LanPropertiesPost(name='public', public=True)
lan_post = LanPost(properties=lan_properties)
response = lan_server.datacenters_lans_post_with_http_info(
datacenter_id=datacenter, lan=lan_post)
(lan_response, _, headers) = response
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id,
timeout=wait_timeout)
public_ip_lan_id = lan_response.id
nic = Nic(
properties=NicProperties(name=str(uuid4()).replace('-', '')[:10],
nat=nat,
lan=int(public_ip_lan_id)))
if nic_ips:
nic.properties.ips = nic_ips
nics.append(nic)
if lan is not None:
lans_list = lan_server.datacenters_lans_get(datacenter_id=datacenter,
depth=2).items
matching_lan = _get_lan_by_id_or_properties(lans_list, lan, name=lan)
if (not any(n.properties.lan == int(matching_lan.id)
for n in nics)) or len(nics) < 1:
nic = Nic(properties=NicProperties(name=str(uuid4()).replace(
'-', '')[:10],
nat=nat,
lan=int(int(matching_lan.id))))
if nic_ips:
nic.properties.ips = nic_ips
nics.append(nic)
volume_properties = VolumeProperties(
name=str(uuid4()).replace('-', '')[:10],
type=disk_type,
size=volume_size,
availability_zone=volume_availability_zone,
image_password=image_password,
ssh_keys=ssh_keys,
bus=bus)
if image:
if uuid_match.match(image):
volume_properties.image = image
else:
volume_properties.image_alias = image
volume = Volume(properties=volume_properties)
server_properties = ServerProperties(name=name,
cores=cores,
ram=ram,
availability_zone=availability_zone,
cpu_family=cpu_family)
server_entities = ServerEntities(volumes=Volumes(items=[volume]),
nics=Nics(items=nics))
server = Server(properties=server_properties, entities=server_entities)
try:
response = server_server.datacenters_servers_post_with_http_info(
datacenter_id=datacenter, server=server)
(server_response, _, headers) = response
request_id = _get_request_id(headers['Location'])
client.wait_for_completion(request_id=request_id, timeout=wait_timeout)
client.wait_for(
fn_request=lambda: server_server.datacenters_servers_find_by_id(
datacenter_id=datacenter,
server_id=server_response.id,
depth=2),
fn_check=lambda r: (r.entities.volumes is not None) and
(r.entities.volumes.items is not None) and
(len(r.entities.volumes.items) > 0) and
(r.entities.nics is not None) and
(r.entities.nics.items is not None) and
(len(r.entities.nics.items) == len(nics)),
scaleup=10000)
server = server_server.datacenters_servers_find_by_id(
datacenter_id=datacenter, server_id=server_response.id, depth=2)
except Exception as e:
module.fail_json(msg="failed to create the new server: %s" %
to_native(e))
else:
if len(server.entities.nics.items) > 0:
server.nic = server.entities.nics.items[0]
return server
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 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))