def revert_snapshot(self, name):
"""Revert snapshot by name
- Revert a libvirt snapshots for all nodes in the environment
- Try to reload 'config' object from a file 'config_<name>.ini'
If the file not found, then pass with defaults.
- Set <name> as the current state of the environment after reload
:param name: string
"""
LOG.info("Reverting from snapshot named '{0}'".format(name))
if self.__env is not None:
self.__env.revert(name=name)
LOG.info("Resuming environment after revert")
self.__env.resume()
else:
raise exceptions.EnvironmentIsNotSet()
try:
test_config_path = self._get_snapshot_config_name(name)
settings_oslo.reload_snapshot_config(self.__config,
test_config_path)
except cfg.ConfigFilesNotFoundError as conf_err:
LOG.error("Config file(s) {0} not found!".format(
conf_err.config_files))
self.__config.hardware.current_snapshot = name
def create_snapshot(self, name, description=None, force=False):
"""Create named snapshot of current env.
- Create a libvirt snapshots for all nodes in the environment
- Save 'config' object to a file 'config_<name>.ini'
:name: string
"""
if not settings.MAKE_SNAPSHOT_STAGES and not force:
msg = ("[ SKIP snapshot '{0}' because MAKE_SNAPSHOT_STAGES=false ]"
" {1}".format(name, description or ''))
LOG.info("\n\n{0}\n{1}".format(msg, '*' * len(msg)))
return
msg = "[ Create snapshot '{0}' ] {1}".format(name, description or '')
LOG.info("\n\n{0}\n{1}".format(msg, '*' * len(msg)))
self.__config.hardware.current_snapshot = name
LOG.info("Set current snapshot in config to '{0}'".format(
self.__config.hardware.current_snapshot))
if self.__env is not None:
LOG.info('trying to suspend ....')
self.__env.suspend()
LOG.info('trying to snapshot ....')
self.__env.snapshot(name, description=description, force=True)
LOG.info('trying to resume ....')
self.__env.resume()
else:
raise exceptions.EnvironmentIsNotSet()
settings_oslo.save_config(self.__config, name, self.__env.name)
if settings.VIRTUAL_ENV:
venv_msg = "source {0}/bin/activate;\n".format(
settings.VIRTUAL_ENV)
else:
venv_msg = ""
LOG.info("To revert the snapshot:\n\n"
"************************************\n"
"{venv_msg}"
"dos.py revert {env_name} {snapshot_name};\n"
"dos.py resume {env_name};\n"
"# dos.py time-sync {env_name}; # Optional\n"
"ssh -i {key_file} {login}@{salt_master_host} "
"# Optional password: {password}\n"
"************************************\n".format(
venv_msg=venv_msg,
env_name=self._d_env_name,
snapshot_name=name,
login=settings.SSH_NODE_CREDENTIALS['login'],
password=settings.SSH_NODE_CREDENTIALS['password'],
salt_master_host=self.__config.salt.salt_master_host,
key_file=self.__config.underlay.ssh_key_file))
def start(self):
"""Method for start environment
"""
if self._env is None:
raise exceptions.EnvironmentIsNotSet()
self._env.start()
LOG.info('Environment "{0}" started'.format(self._env.name))
for node in self._env.get_nodes(role__in=ext.UNDERLAY_NODE_ROLES):
LOG.info("Waiting for SSH on node '{}...'".format(node.name))
timeout = 480
helpers.wait(
lambda: helpers.tcp_ping(self.node_ip(node), 22),
timeout=timeout,
timeout_msg="Node '{}' didn't open SSH in {} sec".format(
node.name, timeout))
LOG.info('Environment "{0}" ready'.format(self._env.name))
def start(self, underlay_node_roles, timeout=480):
"""Method for start environment
"""
if self.__env is None:
raise exceptions.EnvironmentIsNotSet()
self.__env.start()
LOG.info('Environment "{0}" started'.format(self.__env.name))
for node in self.__env.get_nodes(role__in=underlay_node_roles):
LOG.info("Waiting for SSH on node '{0}' / {1} ...".format(
node.name, self.node_ip(node)))
helpers.wait(
lambda: helpers.tcp_ping(self.node_ip(node), 22),
timeout=timeout,
timeout_msg="Node '{}' didn't open SSH in {} sec".format(
node.name, timeout))
LOG.info('Environment "{0}" ready'.format(self.__env.name))
def start(self):
"""Method for start environment
"""
if self._env is None:
raise exceptions.EnvironmentIsNotSet()
self._env.start()
# for node in self.k8s_nodes:
for node in self.master_nodes + self.slave_nodes:
LOG.debug("Waiting for SSH on node '{}...'".format(node.name))
timeout = 360
helpers.wait(
lambda: helpers.tcp_ping(self.node_ip(node), 22),
timeout=timeout,
timeout_msg="Node '{}' didn't open SSH in {} sec".format(
node.name, timeout
)
)
def create_snapshot(self, name, description=None):
"""Create named snapshot of current env.
- Create a libvirt snapshots for all nodes in the environment
- Save 'config' object to a file 'config_<name>.ini'
:name: string
"""
LOG.info("Creating snapshot named '{0}'".format(name))
self.__config.hardware.current_snapshot = name
LOG.info("current config '{0}'".format(
self.__config.hardware.current_snapshot))
if self._env is not None:
LOG.info('trying to suspend ....')
self._env.suspend()
LOG.info('trying to snapshot ....')
self._env.snapshot(name, description=description, force=True)
LOG.info('trying to resume ....')
self._env.resume()
else:
raise exceptions.EnvironmentIsNotSet()
settings_oslo.save_config(self.__config, name, self._env.name)
def stop(self):
"""Stop environment"""
if self.__env is None:
raise exceptions.EnvironmentIsNotSet()
self.__env.destroy()
def suspend(self):
"""Suspend environment"""
if self.__env is None:
raise exceptions.EnvironmentIsNotSet()
self.__env.suspend()
def resume(self):
"""Resume environment"""
if self.__env is None:
raise exceptions.EnvironmentIsNotSet()
self.__env.resume()
def start(self, underlay_node_roles, timeout=480):
"""Method for start environment
"""
if self.__env is None:
raise exceptions.EnvironmentIsNotSet()
self.__env.start()
LOG.info('Environment "{0}" started'.format(self.__env.name))
check_cloudinit_started = '[ -f /is_cloud_init_started ]'
check_cloudinit_finished = ('[ -f /is_cloud_init_finished ] || '
'[ -f /var/log/mcp/.bootstrap_done ]')
check_cloudinit_failed = 'cat /is_cloud_init_failed'
passed = {}
for node in self.__env.get_nodes(role__in=underlay_node_roles):
LOG.info("Waiting for SSH on node '{0}' / {1} ...".format(
node.name, self.node_ip(node)))
def _ssh_check(host,
port,
username=settings.SSH_NODE_CREDENTIALS['login'],
password=settings.SSH_NODE_CREDENTIALS['password'],
timeout=0):
try:
ssh = ssh_client.SSHClient(host=host,
port=port,
auth=ssh_client.SSHAuth(
username=username,
password=password))
# If '/is_cloud_init_started' exists, then wait for
# the flag /is_cloud_init_finished
if ssh.execute(check_cloudinit_started)['exit_code'] == 0:
result = ssh.execute(check_cloudinit_failed)
if result['exit_code'] == 0:
raise exceptions.EnvironmentNodeIsNotStarted(
"{0}:{1}".format(host, port),
result.stdout_str)
status = ssh.execute(
check_cloudinit_finished)['exit_code'] == 0
# Else, just wait for SSH
else:
status = ssh.execute('echo ok')['exit_code'] == 0
return status
except (AuthenticationException, BadAuthenticationType):
return True
except Exception:
return False
def _ssh_wait(host,
port,
username=settings.SSH_NODE_CREDENTIALS['login'],
password=settings.SSH_NODE_CREDENTIALS['password'],
timeout=0):
if host in passed and passed[host] >= 2:
# host already passed the check
return True
for node in self.__env.get_nodes(role__in=underlay_node_roles):
ip = self.node_ip(node)
if ip not in passed:
passed[ip] = 0
if _ssh_check(ip, port):
passed[ip] += 1
else:
passed[ip] = 0
helpers.wait(
lambda: _ssh_wait(self.node_ip(node), 22),
timeout=timeout,
timeout_msg="Node '{}' didn't open SSH in {} sec".format(
node.name, timeout))
LOG.info('Environment "{0}" ready'.format(self.__env.name))
