# Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. """Multicast DNS implementation for API discovery. This implementation follows RFC 6763 as clarified by the API SIG guideline https://review.opendev.org/651222. """ import ipaddress import logging import time from oslo_config import cfg from oslo_config import types as cfg_types import zeroconf from ironic_python_agent import errors from ironic_python_agent import utils opts = [ cfg.IntOpt('lookup_attempts', min=1, default=3, help='Number of attempts to lookup a service.'), cfg.Opt('params', # This is required for values that contain commas. type=cfg_types.Dict(cfg_types.String(quotes=True)), default={}, help='Additional parameters to pass for the registered ' 'service.'), cfg.ListOpt('interfaces', help='List of IP addresses of interfaces to use for mDNS. ' 'Defaults to all interfaces on the system.'), ] CONF = cfg.CONF opt_group = cfg.OptGroup(name='mdns', title='Options for multicast DNS client') CONF.register_group(opt_group) CONF.register_opts(opts, opt_group) LOG = logging.getLogger(__name__) _MDNS_DOMAIN = '_openstack._tcp.local.' class Zeroconf(object): """Multicast DNS implementation client and server. Uses threading internally, so there is no start method. It starts automatically on creation. .. warning:: The underlying library does not yet support IPv6. """ def __init__(self): """Initialize and start the mDNS server.""" interfaces = (CONF.mdns.interfaces if CONF.mdns.interfaces else zeroconf.InterfaceChoice.All) # If interfaces are set, let zeroconf auto-detect the version ip_version = None if CONF.mdns.interfaces else zeroconf.IPVersion.All self._zc = zeroconf.Zeroconf(interfaces=interfaces, ip_version=ip_version) self._registered = [] def get_endpoint(self, service_type, skip_loopback=True, skip_link_local=False): """Get an endpoint and its properties from mDNS. If the requested endpoint is already in the built-in server cache, and its TTL is not exceeded, the cached value is returned. :param service_type: OpenStack service type. :param skip_loopback: Whether to ignore loopback addresses. :param skip_link_local: Whether to ignore link local V6 addresses. :returns: tuple (endpoint URL, properties as a dict). :raises: :exc:`.ServiceLookupFailure` if the service cannot be found. """ delay = 0.1 for attempt in range(CONF.mdns.lookup_attempts): name = '%s.%s' % (service_type, _MDNS_DOMAIN) info = self._zc.get_service_info(name, name) if info is not None: break elif attempt == CONF.mdns.lookup_attempts - 1: raise errors.ServiceLookupFailure(service=service_type) else: time.sleep(delay) delay *= 2 all_addr = info.parsed_addresses() # Try to find the first routable address fallback = None for addr in all_addr: try: loopback = ipaddress.ip_address(addr).is_loopback except ValueError: LOG.debug('Skipping invalid IP address %s', addr) continue else: if loopback and skip_loopback: LOG.debug('Skipping loopback IP address %s', addr) continue if utils.get_route_source(addr, skip_link_local): address = addr break elif fallback is None: fallback = addr else: if fallback is None: raise errors.ServiceLookupFailure( f'None of addresses {all_addr} for service %(' '{service_type} are valid') else: LOG.warning('None of addresses %s seem routable, ' 'using %s', all_addr, fallback) address = fallback properties = {} for key, value in info.properties.items(): try: if isinstance(key, bytes): key = key.decode('utf-8') except UnicodeError as exc: raise errors.ServiceLookupFailure( f'Invalid properties for service {service_type}. Cannot ' f'decode key {key!r}: {exc!r}') try: if isinstance(value, bytes): value = value.decode('utf-8') except UnicodeError as exc: LOG.debug('Cannot convert value %(value)r for key %(key)s ' 'to string, assuming binary: %(exc)s', {'key': key, 'value': value, 'exc': exc}) properties[key] = value path = properties.pop('path', '') protocol = properties.pop('protocol', None) if not protocol: if info.port == 80: protocol = 'http' else: protocol = 'https' if info.server.endswith('.local.'): # Local hostname means that the catalog lists an IP address, # so use it host = address if int(ipaddress.ip_address(host).version) == 6: host = '[%s]' % host else: # Otherwise use the provided hostname. host = info.server.rstrip('.') return ('{proto}://{host}:{port}{path}'.format(proto=protocol, host=host, port=info.port, path=path), properties) def close(self): """Shut down mDNS and unregister services. .. note:: If another server is running for the same services, it will re-register them immediately. """ for info in self._registered: try: self._zc.unregister_service(info) except Exception: LOG.exception('Cound not unregister mDNS service %s', info) self._zc.close() def __enter__(self): return self def __exit__(self, *args): self.close() def get_endpoint(service_type): """Get an endpoint and its properties from mDNS. If the requested endpoint is already in the built-in server cache, and its TTL is not exceeded, the cached value is returned. :param service_type: OpenStack service type. :returns: tuple (endpoint URL, properties as a dict). :raises: :exc:`.ServiceLookupFailure` if the service cannot be found. """ with Zeroconf() as zc: return zc.get_endpoint(service_type) def list_opts(): """Entry point for oslo-config-generator.""" return [('mdns', opts)]