def fallback_ip(self): if self._values['fallback_ip'] is None: return None if self._values['fallback_ip'] == 'any': return 'any' if self._values['fallback_ip'] == 'any6': return 'any6' if is_valid_ip(self._values['fallback_ip']): return self._values['fallback_ip'] else: raise F5ModuleError( 'The provided fallback address is not a valid IPv4 address')
def _format_member_address(self, member): if len(member.split('%')) > 1: address, rd = member.split('%') if is_valid_ip(address): result = '/{0}/{1}%{2}'.format(self.partition, compress_address(address), rd) return result else: if is_valid_ip(member): address = '/{0}/{1}'.format(self.partition, member) return address else: # names must start with alphabetic character, and can contain hyphens and underscores and numbers # no special characters are allowed pattern = re.compile(r'(?!-)[A-Z-].*(?<!-)$', re.IGNORECASE) if pattern.match(member): address = '/{0}/{1}'.format(self.partition, member) return address raise F5ModuleError( 'The provided member address: {0} is not a valid IP address or snat translation name' .format(member))
def address(self): if self._values['destination'].count(':') >= 2: # IPv6 parts = self._values['destination'].split('.') else: # IPv4 parts = self._values['destination'].split(':') if is_valid_ip(parts[0]): return str(parts[0]) raise F5ModuleError( "'address' parameter from API was not an IP address." )
def local_host_name(self): if self._values['local_host_name'] is None: return None if is_valid_ip(self._values['local_host_name']): return self._values['local_host_name'] elif is_valid_hostname(self._values['local_host_name']): # else fallback to checking reasonably well formatted hostnames return str(self._values['local_host_name']) raise F5ModuleError( "The provided 'local_host_name' value {0} is not a valid IP or hostname".format( str(self._values['local_host_name']) ) )
def source_mask(self): if self._values['source_mask'] is None: return None elif self._values['source_mask'] == 'any': return 0 try: int(self._values['source_mask']) raise F5ModuleError("'source_mask' must not be in CIDR format.") except ValueError: pass if is_valid_ip(self._values['source_mask']): return self._values['source_mask']
def addresses(self): if self._values['addresses'] is None: return None for x in self._values['addresses']: if is_valid_ip(x) or is_valid_ip_network( x) or is_valid_ip_interface(x): continue else: raise F5ModuleError( "Address {0} must be either an IPv4 or IPv6 address or network." .format(x)) result = [str(x) for x in self._values['addresses']] result = sorted(result) return result
def _set_host_by_name(self): if is_valid_ip(self.want.name): self.want.update({ 'fqdn': None, 'address': self.want.name }) else: if not is_valid_hostname(self.want.name): raise F5ModuleError( "'name' is neither a valid IP address or FQDN name." ) self.want.update({ 'fqdn': self.want.name, 'address': None })
def _convert_netmask(self, item): result = -1 try: result = int(item) if 0 < result < 256: pass except ValueError: if is_valid_ip(item): ip = ip_network(u'0.0.0.0/%s' % str(item)) result = ip.prefixlen if result < 0: raise F5ModuleError( 'The provided netmask {0} is neither in IP or CIDR format'.format(result) ) return result
def addresses(self): if self._values['addresses'] is None: return None result = [] for x in self._values['addresses']: if is_valid_ip(x): result.append(str(ip_address(u'{0}'.format(x)))) elif is_valid_ip_interface(x): result.append(str(ip_interface(u'{0}'.format(x)))) else: raise F5ModuleError( "Address {0} must be either an IPv4 or IPv6 address or network.".format(x) ) result = sorted(result) return result
def _convert_address(self, item, mask=None): if item == 'any': return '0.0.0.0/0' if not is_valid_ip(item): raise F5ModuleError('The provided IP address is not a valid IP address.') if mask: msk = self._convert_netmask(mask) network = '{0}/{1}'.format(item, msk) if is_valid_ip_network(u'{0}'.format(network)): return network else: raise F5ModuleError( 'The provided IP and Mask are not a valid IP network.' ) host = ip_interface(u'{0}'.format(item)) return host.with_prefixlen
def encode_address_from_string(self, record): if self._network_pattern.match(record): # network 192.168.0.0 prefixlen 16 := "Network3", # network 2402:9400:1000:0:: prefixlen 64 := "Network4", return record elif self._host_pattern.match(record): # host 172.16.1.1/32 := "Host3" # host 2001:0db8:85a3:0000:0000:8a2e:0370:7334 := "Host4" return record else: # 192.168.0.0/16 := "Network3", # 2402:9400:1000:0::/64 := "Network4", parts = record.split(self._separator) if is_valid_ip_network(parts[0]): key = ip_network(u"{0}".format(str(parts[0]))) elif is_valid_ip(parts[0]): key = ip_address(u"{0}".format(str(parts[0]))) elif is_valid_ip_interface(parts[0]): key = ip_interface(u"{0}".format(str(parts[0]))) elif parts[0] == '': pass else: raise F5ModuleError( "When specifying an 'address' type, the value to the left of the separator must be an IP." ) if len(parts) == 2: try: # Only ip_address's have max_prefixlen if key.max_prefixlen in [32, 128]: return self.encode_host(str(key), parts[1]) except ValueError: return self.encode_network(str(key.network_address), key.prefixlen, parts[1]) elif len(parts) == 1 and parts[0] != '': try: # Only ip_address's have max_prefixlen if key.max_prefixlen in [32, 128]: return self.encode_host(str(key), str(key)) except ValueError: return self.encode_network(str(key.network_address), key.prefixlen, str(key.network_address))
def netmask(self): if self.want.netmask is None: return None ip = self.have.ip if is_valid_ip(ip): if self.want.route_domain is not None: want = "{0}%{1}/{2}".format(ip, self.want.route_domain, self.want.netmask) have = "{0}%{1}/{2}".format(ip, self.want.route_domain, self.have.netmask) elif self.have.route_domain is not None: want = "{0}%{1}/{2}".format(ip, self.have.route_domain, self.want.netmask) have = "{0}%{1}/{2}".format(ip, self.have.route_domain, self.have.netmask) else: want = "{0}/{1}".format(ip, self.want.netmask) have = "{0}/{1}".format(ip, self.have.netmask) if want != have: return want else: raise F5ModuleError( 'The provided address/netmask value "{0}" was invalid'.format(self.have.ip) )
def netmask(self): if self._values['netmask'] is None: return None result = -1 try: result = int(self._values['netmask']) if 0 < result < 256: pass except ValueError: if is_valid_ip(self._values['netmask']): addr = ip_address(u'{0}'.format(str(self._values['netmask']))) if addr.version == 4: ip = ip_network(u'0.0.0.0/%s' % str(self._values['netmask'])) result = ip.prefixlen else: result = ipv6_netmask_to_cidr(self._values['netmask']) if result < 0: raise F5ModuleError( 'The provided netmask {0} is neither in IP or CIDR format'.format(result) ) return result
def create(self): self._set_changed_options() if self.want.reverse == 'enabled': if self.want.time_until_up != 0: raise F5ModuleError( "Monitors with the 'reverse' attribute are not currently compatible with 'time_until_up'." ) if not self.want.receive: raise F5ModuleError( "A 'receive' string must be specified when setting 'reverse'." ) if self.want.receive is not None and validate_ip_v6_address( self.want.receive) and self.want.query_type == 'a': raise F5ModuleError( "Monitor has a IPv6 address. Only a 'query_type' of 'aaaa' is supported for IPv6." ) elif (self.want.receive is not None and validate_ip_address(self.want.receive) and self.want.query_type == 'aaaa'): raise F5ModuleError( "Monitor has a IPv4 address. Only a 'query_type' of 'a' is supported for IPv4." ) if self.want.accept_rcode == 'anything': if self.want.receive is not None and is_valid_ip( self.want.receive): raise F5ModuleError( "No 'receive' string may be specified, or exist, when 'accept_rcode' is 'anything'." ) elif self.want.receive is None: self.want.update({'receive': ''}) if self.want.query_name is None: raise F5ModuleError( "'query_name' is required when creating a new DNS monitor.") if self.module.check_mode: return True self.create_on_device() return True
def default_device_reference(self): if is_valid_ip(self.service_environment): filter = "address+eq+'{0}'".format(self.service_environment) else: # Assume a hostname was specified filter = "hostname+eq+'{0}'".format(self.service_environment) uri = "https://{0}:{1}/mgmt/shared/resolver/device-groups/cm-adccore-allbigipDevices/devices/?$filter={2}&$top=1&$select=selfLink".format( self.client.provider['server'], self.client.provider['server_port'], filter) resp = self.client.api.get(uri) try: response = resp.json() except ValueError as ex: raise F5ModuleError(str(ex)) if resp.status == 200 and response['totalItems'] == 0: return None elif 'code' in response and response['code'] == 400: if 'message' in response: raise F5ModuleError(response['message']) else: raise F5ModuleError(resp._content) result = dict(link=response['items'][0]['selfLink']) return result
def device_is_address(self): if is_valid_ip(self.device): return True return False
def device_address(self): if is_valid_ip(self._values['device_address']): return self._values['device_address'] raise F5ModuleError( 'Provided device address: {0} is not a valid IP.'.format( self._values['device_address']))
def address(self): if self._values['address'] is None: return None if is_valid_ip(self._values['address']): return self._values['address'] raise F5ModuleError("Specified 'address' is not an IP address.")
def _get_validated_ip_address(self, address): if is_valid_ip(self._values[address]): return self._values[address] raise F5ModuleError( "The specified '{0}' is not a valid IP address".format(address))