def __init__(self, credentials=None, session=None): super(KeystoneSessionFixture, self).__init__() if credentials: tobiko.check_valid_type(credentials, *self.VALID_CREDENTIALS_TYPES) self.credentials = credentials if session: self.session = session
def list_ip_addresses(ip_version: int = None, device: str = None, scope: str = None, **execute_params) -> \ tobiko.Selection[netaddr.IPAddress]: inets = INETS.get(ip_version) if inets is None: error = "invalid IP version: {!r}".format(ip_version) raise IpError(error=error) command = ['-o', 'address', 'list'] if device is not None: tobiko.check_valid_type(device, str) command.append(device) output = execute_ip(command, **execute_params) ips: tobiko.Selection[netaddr.IPAddress] = tobiko.Selection() if output: for line in output.splitlines(): fields = line.strip().split() inet = fields[2] if inet not in inets: continue # List only address of selected IP version if scope: try: scope_index = fields.index('scope') if fields[scope_index + 1] != scope: continue except (IndexError, ValueError): continue address, _ = parse_ip_address(fields[3]) ips.append(address) return ips
def setup_command(self): command = _command.shell_command(self.parameters.command) network_namespace = self.parameters.network_namespace sudo = self.parameters.sudo shell = self.parameters.shell if shell is None: shell = self.default_shell if shell is not None: tobiko.check_valid_type(shell, (bool, str)) if isinstance(shell, str): command = _command.shell_command(shell) + [str(command)] elif shell is True: command = default_shell_command() + [str(command)] if network_namespace: if sudo is None: sudo = True command = network_namespace_command(network_namespace, command) if sudo: if sudo is True: sudo = default_sudo_command() else: sudo = _command.shell_command(sudo) command = sudo + command self.command = command
def ansible_playbook_manager(manager: 'AnsiblePlaybookManager' = None) -> \ 'AnsiblePlaybookManager': if manager is None: return tobiko.setup_fixture(AnsiblePlaybookManager) else: tobiko.check_valid_type(manager, AnsiblePlaybookManager) return manager
def __init__(self, image_url=None, **kwargs): super(URLGlanceImageFixture, self).__init__(**kwargs) if image_url: self.image_url = image_url else: image_url = self.image_url tobiko.check_valid_type(image_url, str)
def make_netloc(hostname: typing.Union[str, netaddr.IPAddress, None] = None, port: typing.Optional[int] = None, username: typing.Optional[str] = None, password: typing.Optional[str] = None) -> str: if not hostname: return '' try: ip_address = netaddr.IPAddress(hostname) except netaddr.AddrFormatError: tobiko.check_valid_type(hostname, str) netloc = hostname else: if ip_address.version == 6: # Add square brackets around IPv6 address to please curl netloc = f'[{hostname}]' else: netloc = str(hostname) if port is not None: netloc = f'{netloc}:{port}' if username is not None: if password is not None: netloc = f'{username}:{password}@{netloc}' else: netloc = f'{username}@{netloc}' return netloc
def get_group(self, group: str) \ -> tobiko.Selection[OpenStackTopologyNode]: tobiko.check_valid_type(group, str) try: return tobiko.Selection(self._groups[group]) except KeyError as ex: raise _exception.NoSuchOpenStackTopologyNodeGroup( group=group) from ex
def compile_pattern(pattern: typing.Optional[PatternType]) \ -> typing.Pattern[str]: if pattern is None: return MATCH_ALL elif isinstance(pattern, str): return re.compile(pattern, re.IGNORECASE) tobiko.check_valid_type(pattern, Pattern) return pattern
def __init__(self, host, ip_version=None, network_name=None, **kwargs): super(OvercloudHostConfig, self).__init__() tobiko.check_valid_type(host, six.string_types) self.host = host if ip_version: self.ip_version = ip_version if network_name: self.network_name = network_name self._connect_parameters = ssh.gather_ssh_connect_parameters(**kwargs)
def get_connection( self, address: netaddr.IPAddress, proxy_client: ssh.SSHClientFixture = None) \ -> SSHConnection: tobiko.check_valid_type(address, netaddr.IPAddress) tobiko.check_valid_type(proxy_client, ssh.SSHClientFixture, type(None)) connection = SSHConnection(address, proxy_client=proxy_client) return self._connections.setdefault((address, proxy_client), connection)
async def _receive_request(self, request: _request.ActorRequest): tobiko.check_valid_type(request, _request.ActorRequest) if request.actor_id != self.actor_id: raise ValueError(f"Invalid request actor_id: {request.actor_id}") method = self._get_actor_method(request.method) try: result = await method(self, **request.arguments) except Exception as ex: request.future.set_exception(ex) else: request.future.set_result(result)
def heat_template(obj: HeatTemplateType, template_files: typing.Mapping = None) \ -> HeatTemplateFixture: if isinstance(obj, abc.Mapping): template = HeatTemplateFixture(template=obj, template_files=template_files) else: template = tobiko.get_fixture(obj) tobiko.check_valid_type(template, HeatTemplateFixture) return template
def __init__(self, disk_format=None, container_format=None, **kwargs): super(UploadGranceImageFixture, self).__init__(**kwargs) if container_format: self.container_format = disk_format tobiko.check_valid_type(self.container_format, str) if disk_format: self.disk_format = disk_format tobiko.check_valid_type(self.disk_format, str) self.prevent_image_create = get_bool_env('TOBIKO_PREVENT_CREATE')
def __init__(self, ssh_client: ssh.SSHClientFixture, timeout: tobiko.Seconds = None, method: RebootHostMethod = RebootHostMethod.SOFT): super(RebootHostOperation, self).__init__() tobiko.check_valid_type(ssh_client, ssh.SSHClientFixture) tobiko.check_valid_type(method, RebootHostMethod) self.is_rebooted = False self.method = method self.ssh_client = ssh_client self.start_time: tobiko.Seconds = None self.timeout = tobiko.to_seconds(timeout)
def heat_stack_parameters(obj, stack=None): if isinstance(obj, HeatStackParametersFixture): parameters = obj elif obj is None or isinstance(obj, collections.Mapping): parameters = HeatStackParametersFixture(stack, obj) else: parameters = tobiko.get_fixture(obj) tobiko.check_valid_type(parameters, HeatStackParametersFixture) if stack: parameters.stack = parameters.stack or stack tobiko.check_valid_type(parameters.stack, type(None), HeatStackFixture) return parameters
def heat_stack_parameters(obj, stack: 'HeatStackFixture' = None) \ -> 'HeatStackParametersFixture': if isinstance(obj, HeatStackParametersFixture): parameters = obj elif obj is None or isinstance(obj, abc.Mapping): parameters = HeatStackParametersFixture(stack, obj) else: parameters = tobiko.get_fixture(obj) tobiko.check_valid_type(parameters, HeatStackParametersFixture) if stack is not None and parameters.stack is None: parameters.stack = stack tobiko.check_valid_type(parameters.stack, type(None), HeatStackFixture) return parameters
def __init__(self, image_name=None, username=None, password=None): super(GlanceImageFixture, self).__init__() if image_name: self.image_name = image_name elif not self.image_name: self.image_name = self.fixture_name tobiko.check_valid_type(self.image_name, str) if username: self.username = username if password: self.password = password
def match_strings(strings: typing.Iterable[str], *matchers: MatchStringType) -> \ typing.List[str]: matching: typing.List[str] = [] for matcher in matchers: tobiko.check_valid_type(matcher, str, PatternType) if isinstance(matcher, str): if matcher in strings: matching.append(matcher) else: assert isinstance(matcher, PatternType) for string in strings: if matcher.match(string): matching.append(string) return matching
def create_process(self): """Execute command on a remote host using SSH client""" command = str(self.command) ssh_client = self.ssh_client parameters = self.parameters tobiko.check_valid_type(ssh_client, ssh.SSHClientFixture) tobiko.check_valid_type(parameters, SSHShellProcessParameters) environment = parameters.environment for attempt in tobiko.retry( timeout=self.parameters.timeout, default_count=self.parameters.retry_count, default_interval=self.parameters.retry_interval, default_timeout=self.parameters.retry_timeout): timeout = attempt.time_left details = (f"command='{command}', " f"login={ssh_client.login}, " f"timeout={timeout}, " f"attempt={attempt}, " f"environment={environment}") LOG.debug(f"Create remote process... ({details})") try: client = ssh_client.connect() process = client.get_transport().open_session() if environment: variables = " ".join( f"{name}={shlex.quote(value)}" for name, value in self.environment.items()) command = variables + " " + command process.exec_command(command) LOG.debug(f"Remote process created. ({details})") return process except Exception: # Before doing anything else cleanup SSH connection ssh_client.close() LOG.debug(f"Error creating remote process. ({details})", exc_info=1) try: attempt.check_limits() except tobiko.RetryTimeLimitError as ex: LOG.debug(f"Timed out creating remote process. ({details})") raise _exception.ShellTimeoutExpired(command=command, stdin=None, stdout=None, stderr=None, timeout=timeout) from ex
def get_forwarder(self, address, ssh_client): try: return self.forwarders[address, ssh_client] except KeyError: pass if ssh_client: tobiko.check_valid_type(ssh_client, _client.SSHClientFixture) forwarder = SSHTunnelForwarderFixture(ssh_client=ssh_client) forwarder.put_forwarding(address) tobiko.setup_fixture(forwarder) else: forwarder = None self.forwarders[address, ssh_client] = forwarder return forwarder
def __init__(self, image_file=None, image_dir=None, **kwargs): super(FileGlanceImageFixture, self).__init__(**kwargs) if image_file: self.image_file = image_file elif not self.image_file: self.image_file = self.fixture_name tobiko.check_valid_type(self.image_file, str) if image_dir: self.image_dir = image_dir elif not self.image_dir: from tobiko import config CONF = config.CONF self.image_dir = CONF.tobiko.glance.image_dir or "." tobiko.check_valid_type(self.image_dir, str)
def get_node(self, name=None, hostname=None, address=None): name = name or (hostname and node_name_from_hostname(hostname)) details = {} if name: tobiko.check_valid_type(name, str) details['name'] = name try: return self._names[name] except KeyError: pass if address: details['address'] = address for address in self._list_addresses(address): try: return self._addresses[address] except KeyError: pass raise _exception.NoSuchOpenStackTopologyNode(details=details)
def _ips(self, obj): if isinstance(obj, tobiko.Selection): ips = obj elif isinstance(obj, netaddr.IPAddress): ips = tobiko.select([obj]) elif isinstance(obj, six.string_types): try: ips = tobiko.select([netaddr.IPAddress(obj)]) except (netaddr.AddrFormatError, ValueError): ips = resolve_host_ips(obj) else: for item in iter(obj): tobiko.check_valid_type(item, netaddr.IPAddress) ips = tobiko.select(obj) if ips and self.ip_version: ips = ips.with_attributes(version=self.ip_version) return ips
def __init__(self, host=None, ip_version=None, network_name=None, server=None, **kwargs): super(OvercloudHostConfig, self).__init__() if host: self.host = host if ip_version: self.ip_version = ip_version if network_name: self.network_name = network_name if server: self.server = server if self.host is None: self.host = server.name tobiko.check_valid_type(self.host, str) self._connect_parameters = ssh.gather_ssh_connect_parameters(**kwargs)
def ssh_hostname(ssh_client: ssh.SSHClientFixture, **execute_params) \ -> str: tobiko.check_valid_type(ssh_client, ssh.SSHClientFixture) try: result = _execute.execute('hostname', ssh_client=ssh_client, **execute_params) except _exception.ShellCommandFailed as ex: raise HostnameError(error=ex.stderr) from ex line: str for line in result.stdout.splitlines(): hostname = line.strip() if hostname: break else: raise HostnameError(error=f"Invalid result: '{result}'") return hostname
def resolve_host_ips(host, port=0): tobiko.check_valid_type(host, six.string_types) LOG.debug('Calling getaddrinfo with host %r', host) ips = tobiko.Selection() try: addrinfo = socket.getaddrinfo(host, port, 0, 0, socket.AI_CANONNAME | socket.IPPROTO_TCP) except socket.gaierror: LOG.exception('Error calling getaddrinfo for host %r', host) else: for _, _, _, canonical_name, sockaddr in addrinfo: try: ips.append(netaddr.IPAddress(sockaddr[0])) except netaddr.AddrFormatError as ex: LOG.error("Invalid sockaddr for host %r: %r -> %r (%s)", host, canonical_name, sockaddr, ex) else: LOG.debug("IP address for host %r: %r -> %r", host, canonical_name, sockaddr) return ips
def get_cloud_init_status( ssh_client: typing.Optional[ssh.SSHClientFixture] = None, timeout: tobiko.Seconds = None) \ -> str: try: output = sh.execute('cloud-init status', ssh_client=ssh_client, timeout=timeout, sudo=True).stdout except sh.ShellCommandFailed as ex: output = ex.stdout if output: LOG.debug(f"Cloud init status error reported:\n{ex}") else: raise status = tobiko.load_yaml(output) tobiko.check_valid_type(status, dict) tobiko.check_valid_type(status['status'], str) return status['status']
def add_write_file(self, path: str, content: str, owner: str = None, permissions: str = None): tobiko.check_valid_type(path, str) tobiko.check_valid_type(content, str) entry = dict(path=path, content=content) if owner is not None: tobiko.check_valid_type(owner, str) entry['owner'] = owner if permissions is not None: tobiko.check_valid_type(owner, str) entry['permission'] = permissions self.write_files.append(entry)
def playbook_dirname(self) -> str: return tobiko.check_valid_type(self._playbook_dirname, str)
def register_ansible_playbook(playbook: 'AnsiblePlaybook', manager: 'AnsiblePlaybookManager' = None) -> \ None: tobiko.check_valid_type(playbook, AnsiblePlaybook) ansible_playbook_manager(manager).register_ansible_playbook(playbook)