mirror of
https://github.com/ansible-collections/community.general.git
synced 2026-04-01 16:23:10 +00:00
a65a137cdd
The cloudscale_floating_ip module failed if no server was assigned to the floating IP. This also adds a test to avoid a regression. The only way to have a floating IP without a server assigned is to delete the server where the floating IP is currently assigned. Under normal circumstances it's not possible to have an unassigned floating IP.
273 lines
9.0 KiB
Python
273 lines
9.0 KiB
Python
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
#
|
|
# (c) 2017, Gaudenz Steinlin <gaudenz.steinlin@cloudscale.ch>
|
|
# 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: cloudscale_floating_ip
|
|
short_description: Manages floating IPs on the cloudscale.ch IaaS service
|
|
description:
|
|
- Create, assign and delete floating IPs on the cloudscale.ch IaaS service.
|
|
notes:
|
|
- To create a new floating IP at least the C(ip_version) and C(server) options are required.
|
|
- Once a floating_ip is created all parameters except C(server) are read-only.
|
|
- It's not possible to request a floating IP without associating it with a server at the same time.
|
|
- This module requires the ipaddress python library. This library is included in Python since version 3.3. It is available as a
|
|
module on PyPI for earlier versions.
|
|
version_added: 2.5
|
|
author: "Gaudenz Steinlin (@gaudenz) <gaudenz.steinlin@cloudscale.ch>"
|
|
options:
|
|
state:
|
|
description:
|
|
- State of the floating IP.
|
|
default: present
|
|
choices: [ present, absent ]
|
|
ip:
|
|
description:
|
|
- Floating IP address to change.
|
|
- Required to assign the IP to a different server or if I(state) is absent.
|
|
aliases: [ network ]
|
|
ip_version:
|
|
description:
|
|
- IP protocol version of the floating IP.
|
|
choices: [ 4, 6 ]
|
|
server:
|
|
description:
|
|
- UUID of the server assigned to this floating IP.
|
|
- Required unless I(state) is absent.
|
|
prefix_length:
|
|
description:
|
|
- Only valid if I(ip_version) is 6.
|
|
- Prefix length for the IPv6 network. Currently only a prefix of /56 can be requested. If no I(prefix_length) is present, a
|
|
single address is created.
|
|
choices: [ 56 ]
|
|
reverse_ptr:
|
|
description:
|
|
- Reverse PTR entry for this address.
|
|
- You cannot set a reverse PTR entry for IPv6 floating networks. Reverse PTR entries are only allowed for single addresses.
|
|
extends_documentation_fragment: cloudscale
|
|
'''
|
|
|
|
EXAMPLES = '''
|
|
# Request a new floating IP
|
|
- name: Request a floating IP
|
|
cloudscale_floating_ip:
|
|
ip_version: 4
|
|
server: 47cec963-fcd2-482f-bdb6-24461b2d47b1
|
|
reverse_ptr: my-server.example.com
|
|
api_token: xxxxxx
|
|
register: floating_ip
|
|
|
|
# Assign an existing floating IP to a different server
|
|
- name: Move floating IP to backup server
|
|
cloudscale_floating_ip:
|
|
ip: 192.0.2.123
|
|
server: ea3b39a3-77a8-4d0b-881d-0bb00a1e7f48
|
|
api_token: xxxxxx
|
|
|
|
# Request a new floating IPv6 network
|
|
- name: Request a floating IP
|
|
cloudscale_floating_ip:
|
|
ip_version: 6
|
|
prefix_length: 56
|
|
server: 47cec963-fcd2-482f-bdb6-24461b2d47b1
|
|
api_token: xxxxxx
|
|
register: floating_ip
|
|
|
|
# Assign an existing floating network to a different server
|
|
- name: Move floating IP to backup server
|
|
cloudscale_floating_ip:
|
|
ip: '{{ floating_ip.network | ip }}'
|
|
server: ea3b39a3-77a8-4d0b-881d-0bb00a1e7f48
|
|
api_token: xxxxxx
|
|
|
|
# Release a floating IP
|
|
- name: Release floating IP
|
|
cloudscale_floating_ip:
|
|
ip: 192.0.2.123
|
|
state: absent
|
|
api_token: xxxxxx
|
|
'''
|
|
|
|
RETURN = '''
|
|
href:
|
|
description: The API URL to get details about this floating IP.
|
|
returned: success when state == present
|
|
type: str
|
|
sample: https://api.cloudscale.ch/v1/floating-ips/2001:db8::cafe
|
|
network:
|
|
description: The CIDR notation of the network that is routed to your server.
|
|
returned: success when state == present
|
|
type: str
|
|
sample: 2001:db8::cafe/128
|
|
next_hop:
|
|
description: Your floating IP is routed to this IP address.
|
|
returned: success when state == present
|
|
type: str
|
|
sample: 2001:db8:dead:beef::42
|
|
reverse_ptr:
|
|
description: The reverse pointer for this floating IP address.
|
|
returned: success when state == present
|
|
type: str
|
|
sample: 185-98-122-176.cust.cloudscale.ch
|
|
server:
|
|
description: The floating IP is routed to this server.
|
|
returned: success when state == present
|
|
type: str
|
|
sample: 47cec963-fcd2-482f-bdb6-24461b2d47b1
|
|
ip:
|
|
description: The floating IP address or network. This is always present and used to identify floating IPs after creation.
|
|
returned: success
|
|
type: str
|
|
sample: 185.98.122.176
|
|
state:
|
|
description: The current status of the floating IP.
|
|
returned: success
|
|
type: str
|
|
sample: present
|
|
'''
|
|
|
|
import os
|
|
import traceback
|
|
|
|
IPADDRESS_IMP_ERR = None
|
|
try:
|
|
from ipaddress import ip_network
|
|
HAS_IPADDRESS = True
|
|
except ImportError:
|
|
IPADDRESS_IMP_ERR = traceback.format_exc()
|
|
HAS_IPADDRESS = False
|
|
|
|
from ansible.module_utils.basic import AnsibleModule, env_fallback, missing_required_lib
|
|
from ansible.module_utils.cloudscale import AnsibleCloudscaleBase, cloudscale_argument_spec
|
|
|
|
|
|
class AnsibleCloudscaleFloatingIP(AnsibleCloudscaleBase):
|
|
|
|
def __init__(self, module):
|
|
super(AnsibleCloudscaleFloatingIP, self).__init__(module)
|
|
|
|
# Initialize info dict
|
|
# Set state to absent, will be updated by self.update_info()
|
|
self.info = {'state': 'absent'}
|
|
|
|
if self._module.params['ip']:
|
|
self.update_info()
|
|
|
|
@staticmethod
|
|
def _resp2info(resp):
|
|
# If the API response has some content, the floating IP must exist
|
|
resp['state'] = 'present'
|
|
|
|
# Add the IP address to the response, otherwise handling get's to complicated as this
|
|
# has to be converted from the network all the time.
|
|
resp['ip'] = str(ip_network(resp['network']).network_address)
|
|
|
|
# Replace the server with just the UUID, the href to the server is useless and just makes
|
|
# things more complicated
|
|
if resp['server'] is not None:
|
|
resp['server'] = resp['server']['uuid']
|
|
|
|
return resp
|
|
|
|
def update_info(self):
|
|
resp = self._get('floating-ips/' + self._module.params['ip'])
|
|
if resp:
|
|
self.info = self._resp2info(resp)
|
|
else:
|
|
self.info = {'ip': self._module.params['ip'],
|
|
'state': 'absent'}
|
|
|
|
def request_floating_ip(self):
|
|
params = self._module.params
|
|
|
|
# check for required parameters to request a floating IP
|
|
missing_parameters = []
|
|
for p in ('ip_version', 'server'):
|
|
if p not in params or not params[p]:
|
|
missing_parameters.append(p)
|
|
|
|
if len(missing_parameters) > 0:
|
|
self._module.fail_json(msg='Missing required parameter(s) to request a floating IP: %s.' %
|
|
' '.join(missing_parameters))
|
|
|
|
data = {'ip_version': params['ip_version'],
|
|
'server': params['server']}
|
|
|
|
if params['prefix_length']:
|
|
data['prefix_length'] = params['prefix_length']
|
|
if params['reverse_ptr']:
|
|
data['reverse_ptr'] = params['reverse_ptr']
|
|
|
|
self.info = self._resp2info(self._post('floating-ips', data))
|
|
|
|
def release_floating_ip(self):
|
|
self._delete('floating-ips/%s' % self._module.params['ip'])
|
|
self.info = {'ip': self.info['ip'], 'state': 'absent'}
|
|
|
|
def update_floating_ip(self):
|
|
params = self._module.params
|
|
if 'server' not in params or not params['server']:
|
|
self._module.fail_json(msg='Missing required parameter to update a floating IP: server.')
|
|
self.info = self._resp2info(self._post('floating-ips/%s' % params['ip'], {'server': params['server']}))
|
|
|
|
|
|
def main():
|
|
argument_spec = cloudscale_argument_spec()
|
|
argument_spec.update(dict(
|
|
state=dict(default='present', choices=('present', 'absent')),
|
|
ip=dict(aliases=('network', )),
|
|
ip_version=dict(choices=(4, 6), type='int'),
|
|
server=dict(),
|
|
prefix_length=dict(choices=(56,), type='int'),
|
|
reverse_ptr=dict(),
|
|
))
|
|
|
|
module = AnsibleModule(
|
|
argument_spec=argument_spec,
|
|
required_one_of=(('ip', 'ip_version'),),
|
|
supports_check_mode=True,
|
|
)
|
|
|
|
if not HAS_IPADDRESS:
|
|
module.fail_json(msg=missing_required_lib('ipaddress'), exception=IPADDRESS_IMP_ERR)
|
|
|
|
target_state = module.params['state']
|
|
target_server = module.params['server']
|
|
floating_ip = AnsibleCloudscaleFloatingIP(module)
|
|
current_state = floating_ip.info['state']
|
|
current_server = floating_ip.info['server'] if 'server' in floating_ip.info else None
|
|
|
|
if module.check_mode:
|
|
module.exit_json(changed=not target_state == current_state or
|
|
(current_state == 'present' and current_server != target_server),
|
|
**floating_ip.info)
|
|
|
|
changed = False
|
|
if current_state == 'absent' and target_state == 'present':
|
|
floating_ip.request_floating_ip()
|
|
changed = True
|
|
elif current_state == 'present' and target_state == 'absent':
|
|
floating_ip.release_floating_ip()
|
|
changed = True
|
|
elif current_state == 'present' and current_server != target_server:
|
|
floating_ip.update_floating_ip()
|
|
changed = True
|
|
|
|
module.exit_json(changed=changed, **floating_ip.info)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|