def main():
argument_spec = f5_argument_spec()
meta_args = dict(
contact=dict(required=False, default=None),
description=dict(required=False, default=None),
enabled=dict(required=False, type='bool', default=None),
location=dict(required=False, default=None),
name=dict(required=True)
)
argument_spec.update(meta_args)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
try:
obj = BigIpGtmDatacenter(check_mode=module.check_mode, **module.params)
result = obj.flush()
module.exit_json(**result)
except F5ModuleError as e:
module.fail_json(msg=str(e))
def initialize_argument_spec(self):
self.argument_spec = f5_argument_spec()
self.argument_spec.update(self.meta_args)
def main():
argument_spec = f5_argument_spec()
meta_args = dict(
state=dict(type='str', default='present', choices=['present', 'absent', 'enabled', 'disabled']),
host=dict(type='str', default=None, aliases=['address']),
port=dict(type='int', default=None),
virtual_server_name=dict(type='str', required=True),
virtual_server_server=dict(type='str', required=True)
)
argument_spec.update(meta_args)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
if not bigsuds_found:
module.fail_json(msg="the python bigsuds module is required")
server = module.params['server']
server_port = module.params['server_port']
validate_certs = module.params['validate_certs']
user = module.params['user']
password = module.params['password']
virtual_server_name = module.params['virtual_server_name']
virtual_server_server = module.params['virtual_server_server']
state = module.params['state']
address = module.params['host']
port = module.params['port']
result = {'changed': False} # default
try:
api = bigip_api(server, user, password, validate_certs, port=server_port)
if state == 'absent':
if virtual_server_exists(api, virtual_server_name, virtual_server_server):
if not module.check_mode:
remove_virtual_server(api, virtual_server_name, virtual_server_server)
result = {'changed': True}
else:
# check-mode return value
result = {'changed': True}
elif state == 'present':
if virtual_server_name and virtual_server_server and address and port:
if not virtual_server_exists(api, virtual_server_name, virtual_server_server):
if not module.check_mode:
if server_exists(api, virtual_server_server):
add_virtual_server(api, virtual_server_name, virtual_server_server, address, port)
result = {'changed': True}
else:
module.fail_json(msg="server does not exist")
else:
# check-mode return value
result = {'changed': True}
else:
# virtual server exists -- potentially modify attributes --future feature
result = {'changed': False}
else:
module.fail_json(msg="Address and port are required to create virtual server")
elif state == 'enabled':
if not virtual_server_exists(api, virtual_server_name, virtual_server_server):
module.fail_json(msg="virtual server does not exist")
if state != get_virtual_server_state(api, virtual_server_name, virtual_server_server):
if not module.check_mode:
set_virtual_server_state(api, virtual_server_name, virtual_server_server, state)
result = {'changed': True}
else:
result = {'changed': True}
elif state == 'disabled':
if not virtual_server_exists(api, virtual_server_name, virtual_server_server):
module.fail_json(msg="virtual server does not exist")
if state != get_virtual_server_state(api, virtual_server_name, virtual_server_server):
if not module.check_mode:
set_virtual_server_state(api, virtual_server_name, virtual_server_server, state)
result = {'changed': True}
else:
result = {'changed': True}
except Exception:
e = get_exception()
module.fail_json(msg="received exception: %s" % e)
module.exit_json(**result)
def main():
result = {}
argument_spec = f5_argument_spec()
meta_args = dict(session_state=dict(type='str',
choices=['enabled', 'disabled']),
monitor_state=dict(type='str',
choices=['enabled', 'disabled']),
pool=dict(type='str', required=True),
host=dict(type='str',
required=True,
aliases=['address', 'name']),
port=dict(type='int', required=True),
connection_limit=dict(type='int'),
description=dict(type='str'),
rate_limit=dict(type='int'),
ratio=dict(type='int'),
preserve_node=dict(type='bool', default=False),
priority_group=dict(type='int'))
argument_spec.update(meta_args)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if not bigsuds_found:
module.fail_json(msg="the python bigsuds module is required")
if module.params['validate_certs']:
import ssl
if not hasattr(ssl, 'SSLContext'):
module.fail_json(
msg=
'bigsuds does not support verifying certificates with python < 2.7.9. Either update python or set validate_certs=False on the task'
)
server = module.params['server']
server_port = module.params['server_port']
user = module.params['user']
password = module.params['password']
state = module.params['state']
partition = module.params['partition']
validate_certs = module.params['validate_certs']
session_state = module.params['session_state']
monitor_state = module.params['monitor_state']
pool = fq_name(partition, module.params['pool'])
connection_limit = module.params['connection_limit']
description = module.params['description']
rate_limit = module.params['rate_limit']
ratio = module.params['ratio']
priority_group = module.params['priority_group']
host = module.params['host']
address = fq_name(partition, host)
port = module.params['port']
preserve_node = module.params['preserve_node']
if (host and port is None) or (port is not None and not host):
module.fail_json(msg="both host and port must be supplied")
if 0 > port or port > 65535:
module.fail_json(msg="valid ports must be in range 0 - 65535")
try:
api = bigip_api(server,
user,
password,
validate_certs,
port=server_port)
if not pool_exists(api, pool):
module.fail_json(msg="pool %s does not exist" % pool)
result = {'changed': False} # default
if state == 'absent':
if member_exists(api, pool, address, port):
if not module.check_mode:
remove_pool_member(api, pool, address, port)
if preserve_node:
result = {'changed': True}
else:
deleted = delete_node_address(api, address)
result = {'changed': True, 'deleted': deleted}
else:
result = {'changed': True}
elif state == 'present':
if not member_exists(api, pool, address, port):
if not module.check_mode:
add_pool_member(api, pool, address, port)
if connection_limit is not None:
set_connection_limit(api, pool, address, port,
connection_limit)
if description is not None:
set_description(api, pool, address, port, description)
if rate_limit is not None:
set_rate_limit(api, pool, address, port, rate_limit)
if ratio is not None:
set_ratio(api, pool, address, port, ratio)
if session_state is not None:
set_member_session_enabled_state(
api, pool, address, port, session_state)
if monitor_state is not None:
set_member_monitor_state(api, pool, address, port,
monitor_state)
if priority_group is not None:
set_priority_group(api, pool, address, port,
priority_group)
result = {'changed': True}
else:
# pool member exists -- potentially modify attributes
if connection_limit is not None and connection_limit != get_connection_limit(
api, pool, address, port):
if not module.check_mode:
set_connection_limit(api, pool, address, port,
connection_limit)
result = {'changed': True}
if description is not None and description != get_description(
api, pool, address, port):
if not module.check_mode:
set_description(api, pool, address, port, description)
result = {'changed': True}
if rate_limit is not None and rate_limit != get_rate_limit(
api, pool, address, port):
if not module.check_mode:
set_rate_limit(api, pool, address, port, rate_limit)
result = {'changed': True}
if ratio is not None and ratio != get_ratio(
api, pool, address, port):
if not module.check_mode:
set_ratio(api, pool, address, port, ratio)
result = {'changed': True}
if session_state is not None:
session_status = get_member_session_status(
api, pool, address, port)
if session_state == 'enabled' and session_status == 'forced_disabled':
if not module.check_mode:
set_member_session_enabled_state(
api, pool, address, port, session_state)
result = {'changed': True}
elif session_state == 'disabled' and session_status != 'forced_disabled':
if not module.check_mode:
set_member_session_enabled_state(
api, pool, address, port, session_state)
result = {'changed': True}
if monitor_state is not None:
monitor_status = get_member_monitor_status(
api, pool, address, port)
if monitor_state == 'enabled' and monitor_status == 'forced_down':
if not module.check_mode:
set_member_monitor_state(api, pool, address, port,
monitor_state)
result = {'changed': True}
elif monitor_state == 'disabled' and monitor_status != 'forced_down':
if not module.check_mode:
set_member_monitor_state(api, pool, address, port,
monitor_state)
result = {'changed': True}
if priority_group is not None and priority_group != get_priority_group(
api, pool, address, port):
if not module.check_mode:
set_priority_group(api, pool, address, port,
priority_group)
result = {'changed': True}
except Exception as e:
module.fail_json(msg="received exception: %s" % e)
module.exit_json(**result)
def initialize_argument_spec(self):
self.argument_spec = f5_argument_spec()
self.argument_spec.update(self.meta_args)
def main():
argument_spec = f5_argument_spec()
meta_args = dict(state=dict(
type='str',
default='present',
choices=['present', 'absent', 'enabled', 'disabled']),
host=dict(type='str', default=None, aliases=['address']),
port=dict(type='int', default=None),
virtual_server_name=dict(type='str', required=True),
virtual_server_server=dict(type='str', required=True))
argument_spec.update(meta_args)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if not bigsuds_found:
module.fail_json(msg="the python bigsuds module is required")
server = module.params['server']
server_port = module.params['server_port']
validate_certs = module.params['validate_certs']
user = module.params['user']
password = module.params['password']
virtual_server_name = module.params['virtual_server_name']
virtual_server_server = module.params['virtual_server_server']
state = module.params['state']
address = module.params['host']
port = module.params['port']
result = {'changed': False} # default
try:
api = bigip_api(server,
user,
password,
validate_certs,
port=server_port)
if state == 'absent':
if virtual_server_exists(api, virtual_server_name,
virtual_server_server):
if not module.check_mode:
remove_virtual_server(api, virtual_server_name,
virtual_server_server)
result = {'changed': True}
else:
# check-mode return value
result = {'changed': True}
elif state == 'present':
if virtual_server_name and virtual_server_server and address and port:
if not virtual_server_exists(api, virtual_server_name,
virtual_server_server):
if not module.check_mode:
if server_exists(api, virtual_server_server):
add_virtual_server(api, virtual_server_name,
virtual_server_server, address,
port)
result = {'changed': True}
else:
module.fail_json(msg="server does not exist")
else:
# check-mode return value
result = {'changed': True}
else:
# virtual server exists -- potentially modify attributes --future feature
result = {'changed': False}
else:
module.fail_json(
msg="Address and port are required to create virtual server"
)
elif state == 'enabled':
if not virtual_server_exists(api, virtual_server_name,
virtual_server_server):
module.fail_json(msg="virtual server does not exist")
if state != get_virtual_server_state(api, virtual_server_name,
virtual_server_server):
if not module.check_mode:
set_virtual_server_state(api, virtual_server_name,
virtual_server_server, state)
result = {'changed': True}
else:
result = {'changed': True}
elif state == 'disabled':
if not virtual_server_exists(api, virtual_server_name,
virtual_server_server):
module.fail_json(msg="virtual server does not exist")
if state != get_virtual_server_state(api, virtual_server_name,
virtual_server_server):
if not module.check_mode:
set_virtual_server_state(api, virtual_server_name,
virtual_server_server, state)
result = {'changed': True}
else:
result = {'changed': True}
except Exception:
e = get_exception()
module.fail_json(msg="received exception: %s" % e)
module.exit_json(**result)
def main():
argument_spec = f5_argument_spec()
argument_spec.update(
dict(state=dict(type='str',
default='present',
choices=['present', 'absent', 'disabled', 'enabled']),
name=dict(type='str', required=True, aliases=['vs']),
destination=dict(type='str', aliases=['address', 'ip']),
port=dict(type='str', default=None),
all_policies=dict(type='list'),
all_profiles=dict(type='list', default=None),
all_rules=dict(type='list'),
enabled_vlans=dict(type='list'),
pool=dict(type='str'),
description=dict(type='str'),
snat=dict(type='str'),
route_advertisement_state=dict(type='str',
default=None,
choices=['enabled', 'disabled']),
default_persistence_profile=dict(type='str'),
fallback_persistence_profile=dict(type='str')))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if not bigsuds_found:
module.fail_json(msg="the python bigsuds module is required")
if module.params['validate_certs']:
import ssl
if not hasattr(ssl, 'SSLContext'):
module.fail_json(
msg=
'bigsuds does not support verifying certificates with python < 2.7.9. Either update python or set validate_certs=False on the task'
)
server = module.params['server']
server_port = module.params['server_port']
user = module.params['user']
password = module.params['password']
state = module.params['state']
partition = module.params['partition']
validate_certs = module.params['validate_certs']
name = fq_name(partition, module.params['name'])
destination = module.params['destination']
port = module.params['port']
if port == '' or port is None:
port = None
else:
port = int(port)
all_profiles = fq_list_names(partition, module.params['all_profiles'])
all_policies = fq_list_names(partition, module.params['all_policies'])
all_rules = fq_list_names(partition, module.params['all_rules'])
enabled_vlans = module.params['enabled_vlans']
if enabled_vlans is None or 'ALL' in enabled_vlans:
all_enabled_vlans = enabled_vlans
else:
all_enabled_vlans = fq_list_names(partition, enabled_vlans)
pool = fq_name(partition, module.params['pool'])
description = module.params['description']
snat = module.params['snat']
route_advertisement_state = module.params['route_advertisement_state']
default_persistence_profile = fq_name(
partition, module.params['default_persistence_profile'])
fallback_persistence_profile = module.params[
'fallback_persistence_profile']
if 0 > port > 65535:
module.fail_json(msg="valid ports must be in range 0 - 65535")
try:
api = bigip_api(server,
user,
password,
validate_certs,
port=server_port)
result = {'changed': False} # default
if state == 'absent':
if not module.check_mode:
if vs_exists(api, name):
# hack to handle concurrent runs of module
# pool might be gone before we actually remove
try:
vs_remove(api, name)
result = {'changed': True, 'deleted': name}
except bigsuds.OperationFailed as e:
if "was not found" in str(e):
result['changed'] = False
else:
raise
else:
# check-mode return value
result = {'changed': True}
else:
update = False
if not vs_exists(api, name):
if (not destination) or (port is None):
module.fail_json(
msg=
"both destination and port must be supplied to create a VS"
)
if not module.check_mode:
# a bit of a hack to handle concurrent runs of this module.
# even though we've checked the virtual_server doesn't exist,
# it may exist by the time we run virtual_server().
# this catches the exception and does something smart
# about it!
try:
vs_create(api, name, destination, port, pool,
all_profiles)
set_policies(api, name, all_policies)
set_enabled_vlans(api, name, all_enabled_vlans)
set_rules(api, name, all_rules)
set_snat(api, name, snat)
set_description(api, name, description)
set_default_persistence_profiles(
api, name, default_persistence_profile)
set_fallback_persistence_profile(
api, partition, name, fallback_persistence_profile)
set_state(api, name, state)
set_route_advertisement_state(
api, destination, partition,
route_advertisement_state)
result = {'changed': True}
except bigsuds.OperationFailed as e:
raise Exception(
'Error on creating Virtual Server : %s' % e)
else:
# check-mode return value
result = {'changed': True}
else:
update = True
if update:
# VS exists
if not module.check_mode:
# Have a transaction for all the changes
try:
api.System.Session.start_transaction()
result['changed'] |= set_destination(
api, name, fq_name(partition, destination))
result['changed'] |= set_port(api, name, port)
result['changed'] |= set_pool(api, name, pool)
result['changed'] |= set_description(
api, name, description)
result['changed'] |= set_snat(api, name, snat)
result['changed'] |= set_profiles(
api, name, all_profiles)
result['changed'] |= set_policies(
api, name, all_policies)
result['changed'] |= set_enabled_vlans(
api, name, all_enabled_vlans)
result['changed'] |= set_rules(api, name, all_rules)
result['changed'] |= set_default_persistence_profiles(
api, name, default_persistence_profile)
result['changed'] |= set_fallback_persistence_profile(
api, partition, name, fallback_persistence_profile)
result['changed'] |= set_state(api, name, state)
result['changed'] |= set_route_advertisement_state(
api, destination, partition,
route_advertisement_state)
api.System.Session.submit_transaction()
except Exception as e:
raise Exception(
"Error on updating Virtual Server : %s" % str(e))
else:
# check-mode return value
result = {'changed': True}
except Exception as e:
module.fail_json(msg="received exception: %s" % e)
module.exit_json(**result)