def ntp_servers(self):
ntp_servers = self._values['ntp_servers']
if ntp_servers is None:
return None
if is_empty_list(ntp_servers):
return []
return ntp_servers
def addon_keys(self):
if self._values['license_key'] is None:
return None
if self._values['addon_keys'] is None or is_empty_list(self._values['addon_keys']):
return None
result = ' '.join(self._values['addon_keys'])
return result
def monitors(self):
if self._values['monitors'] is None:
return None
if is_empty_list(self._values['monitors']):
return '/Common/bigip'
monitors = [fq_name(self.partition, x) for x in self.monitors_list]
if self.availability_requirement_type == 'at_least':
if self.at_least > len(self.monitors_list):
raise F5ModuleError(
"The 'at_least' value must not exceed the number of 'monitors'."
)
monitors = ' '.join(monitors)
result = 'min {0} of {{ {1} }}'.format(self.at_least, monitors)
elif self.availability_requirement_type == 'require':
monitors = ' '.join(monitors)
if self.number_of_probes > self.number_of_probers:
raise F5ModuleError(
"The 'number_of_probes' must not exceed the 'number_of_probers'."
)
result = 'require {0} from {1} {{ {2} }}'.format(
self.number_of_probes, self.number_of_probers, monitors)
else:
result = ' and '.join(monitors).strip()
return result
def options(self):
choices = [
'netscape-reuse-cipher-change-bug', 'microsoft-big-sslv3-buffer',
'msie-sslv2-rsa-padding', 'ssleay-080-client-dh-bug', 'tls-d5-bug',
'tls-block-padding-bug', 'dont-insert-empty-fragments', 'no-ssl',
'no-dtls', 'no-session-resumption-on-renegotiation', 'no-tlsv1.1',
'no-tlsv1.2', 'single-dh-use', 'ephemeral-rsa',
'cipher-server-preference', 'tls-rollback-bug', 'no-sslv2',
'no-sslv3', 'no-tls', 'no-tlsv1', 'pkcs1-check-1', 'pkcs1-check-2',
'netscape-ca-dn-bug', 'netscape-demo-cipher-change-bug'
]
options = self._values['options']
if options is None:
return None
if is_empty_list(options):
return []
if set(options).issubset(set(choices)):
return options
else:
offenders = set(options).difference(set(choices))
raise F5ModuleError(
'Invalid options specified: {0}'.format(offenders))
def peers(self):
if self._values['peers'] is None:
return None
if is_empty_list(self._values['peers']):
return ""
result = [fq_name(self.partition, peer) for peer in self._values['peers']]
return result
def excluded_ipv4_adresses(self):
if self._values['excluded_ipv4_adresses'] is None:
return None
if is_empty_list(self._values['excluded_ipv4_adresses']):
return []
result = self._format_subnets(self._values['excluded_ipv4_adresses'])
return result
def ipv6_address_space(self):
if self._values['ipv6_address_space'] is None:
return None
if is_empty_list(self._values['ipv6_address_space']):
return []
result = self._format_subnets(self._values['ipv6_address_space'])
return result
def allow(self):
allow = self._values['allow']
if allow is None:
return None
if is_empty_list(allow):
return []
return allow
def options(self):
options = self._values['options']
if options is None:
return None
if is_empty_list(options):
return []
return options
def activation_modes(self):
value = self._values['activation_modes']
if value is None:
return None
if is_empty_list(value):
raise F5ModuleError(
"Activation Modes cannot be empty, please provide a value")
return value
def egress_interfaces(self):
if self._values['egress_interfaces'] is None:
return None
if is_empty_list(self._values['egress_interfaces']):
return ''
result = []
for interface in self._values['egress_interfaces']:
result.append(fq_name(self.partition, interface))
return result
def servers(self):
if self._values['servers'] is None:
return None
if is_empty_list(self._values['servers']):
return []
result = list()
for item in self._values['servers']:
result.append(fq_name('Common', item))
return result
def irules(self):
results = []
if self._values['irules'] is None:
return None
if is_empty_list(self._values['irules']):
return []
for irule in self._values['irules']:
result = fq_name(self.partition, irule)
results.append(result)
return results
def name_servers(self):
name_servers = self._values['name_servers']
if name_servers is None:
return None
if isinstance(name_servers, str) and name_servers != "":
result = list()
result.append(str(name_servers))
return result
if is_empty_list(name_servers):
return []
return name_servers
def search(self):
search = self._values['search']
if search is None:
return None
if isinstance(search, str) and search != "":
result = list()
result.append(str(search))
return result
if is_empty_list(search):
return []
return search
def partition_access(self):
if self._values['partition_access'] is None:
return None
if is_empty_list(self._values['partition_access']):
return []
result = []
part_access = self._values['partition_access']
for access in part_access:
if isinstance(access, string_types):
acl = access.split(':')
if acl[0].lower() == 'all':
acl[0] = 'all-partitions'
value = dict(
name=acl[0],
role=acl[1]
)
result.append(value)
return result
def excluded_dns_addresses(self):
if self._values['excluded_dns_addresses'] is None:
return None
if is_empty_list(self._values['excluded_dns_addresses']):
return []
return self._values['excluded_dns_addresses']
def dns_address_space(self):
if self._values['dns_address_space'] is None:
return None
if is_empty_list(self._values['dns_address_space']):
return []
return self._values['dns_address_space']
def backup_members(self):
if self._values['backup_members'] is None:
return None
if is_empty_list(self._values['backup_members']):
return ''
return self._values['backup_members']
