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)
