def test_valid_port_fail(self):
invalid_inputs = [
'-32768', '65536', 528491, '528491', '528.491', 'thirty-seven',
None
]
for input_str in invalid_inputs:
self.assertFalse(netutils.is_valid_port(input_str))
def validate_port_range_or_none(data, valid_values=None):
"""Validate data is a range of TCP/UDP port numbers
:param data: The data to validate
:param valid_values: Not used!
:returns: None if data is an int between 0 and 65535, or two ints between 0
and 65535 with a colon between them, otherwise a human readable message
as to why data is invalid.
"""
if data is None:
return
data = str(data)
ports = data.split(':')
if len(ports) > 2:
msg = _("Port range must be two integers separated by a colon")
LOG.debug(msg)
return msg
for p in ports:
if len(p) == 0:
msg = _("Port range must be two integers separated by a colon")
LOG.debug(msg)
return msg
if not netutils.is_valid_port(p):
msg = _("Invalid port: %s") % p
LOG.debug(msg)
return msg
if len(ports) > 1 and int(ports[0]) > int(ports[1]):
msg = _("First port in a port range must be lower than the second "
"port")
LOG.debug(msg)
return msg
def convert_validate_port_value(port):
if port is None:
return port
if netutils.is_valid_port(port):
return int(port)
else:
raise SecurityGroupInvalidPortValue(port=port)
def convert_validate_port_value(port):
if port is None:
return port
if netutils.is_valid_port(port):
return int(port)
else:
raise SecurityGroupInvalidPortValue(port=port)
def convert_validate_port_value(port):
if port is None:
return port
if netutils.is_valid_port(port):
return int(port)
else:
raise HostingDeviceInvalidPortValue(port=port)
def convert_validate_port_value(port):
if port is None:
return port
if netutils.is_valid_port(port):
return int(port)
else:
raise HostingDeviceInvalidPortValue(port=port)
def validate_network_port(port, port_name="Port"):
"""Validates the given port.
:param port: TCP/UDP port.
:param port_name: Name of the port.
:returns: An integer port number.
:raises: InvalidParameterValue, if the port is invalid.
"""
if netutils.is_valid_port(port):
return int(port)
raise exception.InvalidParameterValue(_(
'%(port_name)s "%(port)s" is not a valid port.') %
{'port_name': port_name, 'port': port})
def validate_network_port(port, port_name="Port"):
"""Validates the given port.
:param port: TCP/UDP port.
:param port_name: Name of the port.
:returns: An integer port number.
:raises: InvalidParameterValue, if the port is invalid.
"""
if netutils.is_valid_port(port):
return int(port)
raise exception.InvalidParameterValue(_(
'%(port_name)s "%(port)s" is not a valid port.') %
{'port_name': port_name, 'port': port})
def parse_valid_host_port(host_port):
"""
Given a "host:port" string, attempts to parse it as intelligently as
possible to determine if it is valid. This includes IPv6 [host]:port form,
IPv4 ip:port form, and hostname:port or fqdn:port form.
Invalid inputs will raise a ValueError, while valid inputs will return
a (host, port) tuple where the port will always be of type int.
"""
try:
try:
host, port = netutils.parse_host_port(host_port)
except Exception:
raise ValueError(_('Host and port "%s" is not valid.') % host_port)
if not netutils.is_valid_port(port):
raise ValueError(_('Port "%s" is not valid.') % port)
# First check for valid IPv6 and IPv4 addresses, then a generic
# hostname. Failing those, if the host includes a period, then this
# should pass a very generic FQDN check. The FQDN check for letters at
# the tail end will weed out any hilariously absurd IPv4 addresses.
if not (
netutils.is_valid_ipv6(host)
or netutils.is_valid_ipv4(host)
or is_valid_hostname(host)
or is_valid_fqdn(host)
):
raise ValueError(_('Host "%s" is not valid.') % host)
except Exception as ex:
raise ValueError(
_(
"%s "
"Please specify a host:port pair, where host is an "
"IPv4 address, IPv6 address, hostname, or FQDN. If "
"using an IPv6 address, enclose it in brackets "
"separately from the port (i.e., "
'"[fe80::a:b:c]:9876").'
)
% ex
)
return (host, int(port))
def parse_valid_host_port(host_port):
"""
Given a "host:port" string, attempts to parse it as intelligently as
possible to determine if it is valid. This includes IPv6 [host]:port form,
IPv4 ip:port form, and hostname:port or fqdn:port form.
Invalid inputs will raise a ValueError, while valid inputs will return
a (host, port) tuple where the port will always be of type int.
"""
try:
try:
host, port = netutils.parse_host_port(host_port)
except Exception:
raise ValueError(_('Host and port "%s" is not valid.') % host_port)
if not netutils.is_valid_port(port):
raise ValueError(_('Port "%s" is not valid.') % port)
# First check for valid IPv6 and IPv4 addresses, then a generic
# hostname. Failing those, if the host includes a period, then this
# should pass a very generic FQDN check. The FQDN check for letters at
# the tail end will weed out any hilariously absurd IPv4 addresses.
if not (netutils.is_valid_ipv6(host) or netutils.is_valid_ipv4(host)
or is_valid_hostname(host) or is_valid_fqdn(host)):
raise ValueError(_('Host "%s" is not valid.') % host)
except Exception as ex:
raise ValueError(
_('%s '
'Please specify a host:port pair, where host is an '
'IPv4 address, IPv6 address, hostname, or FQDN. If '
'using an IPv6 address, enclose it in brackets '
'separately from the port (i.e., '
'"[fe80::a:b:c]:9876").') % ex)
return (host, int(port))
def validate_port_range(port):
if not netutils.is_valid_port(port):
raise ValidationError(_("Not a valid port number"))
def __init__(self, parsed_url):
self.driver_endpoint_from_pipeline = parsed_url
# database connection parameters
self.dbaddress = cfg.CONF.influxdb.influxdb_addr
self.dbport = cfg.CONF.influxdb.influxdb_port
self.dbname = cfg.CONF.influxdb.influxdb_instance
self.dbuser = cfg.CONF.influxdb.influxdb_user
self.dbpass = cfg.CONF.influxdb.influxdb_pass
self.retention_policy = cfg.CONF.influxdb.retention_policy
self.verboselog = cfg.CONF.influxdb.verboselog
self.mappings = cfg.CONF.influxdb.mappings
self.mapping_data = {}
# open mapping file
with open(self.mappings, "r") as mapping_descriptor:
self.mappingfile = json.loads(mapping_descriptor.read())
LOG.info(
"[*] InfluxDB Publisher: Loaded Meters and Tag Mappings from config file [%s]."
% self.mappings)
# parse json...
for entry in self.mappingfile:
self.mapping_data[entry["name"]] = entry["values"]
# this host
self.hostname = gethostname()
# compile additional tags
self.additional_tags = {
'hypervisor_hostname': self.hostname,
'retention_policy': self.retention_policy
}
# set meter prefix
if cfg.CONF.influxdb.append_hypervisor:
self.meter_prefix = cfg.CONF.influxdb.metering_prefix + self.hostname
else:
self.meter_prefix = cfg.CONF.influxdb.metering_prefix
# get keystone client instance
self.identity = get_client()
# get initial tenant list
self.tenants = self.identity.projects.list()
# at startup, register available tenants in in-memory database
# subsequent queries either hit the in memory cache or need a new query to keystone
for t in self.tenants:
InfluxDBPublisherUtils.pushTenant(t.id, t.name)
# create DB connection
# sanity check on database parameters
if not (network_utils.is_valid_ipv4(self.dbaddress)
and network_utils.is_valid_port(self.dbport)):
raise Exception("dbaddr:dbport validation error %s:%s" %
(self.dbaddress, self.dbport))
try:
self.dbconn = dbclient(self.dbaddress, self.dbport, self.dbuser,
self.dbpass, self.dbname)
except Exception as e:
LOG.info(e)
# OK init done
LOG.info("[+] InfluxDB Publisher [%s] registered to [%s]" %
(self.driver_endpoint_from_pipeline, self.dbaddress))
def test_valid_port_fail(self):
invalid_inputs = ['-32768', '0', 0, '65536', 528491, '528491',
'528.491', 'thirty-seven', None]
for input_str in invalid_inputs:
self.assertFalse(netutils.is_valid_port(input_str))
def test_valid_port(self):
valid_inputs = [1, '1', 2, '3', '5', 8, 13, 21,
'80', '3246', '65535']
for input_str in valid_inputs:
self.assertTrue(netutils.is_valid_port(input_str))
def test_valid_port(self):
valid_inputs = [
0, '0', 1, '1', 2, '3', '5', 8, 13, 21, '80', '3246', '65535'
]
for input_str in valid_inputs:
self.assertTrue(netutils.is_valid_port(input_str))
