def _get_info_from_package_manager(cls, package):
cmd = compose_cmd(['apt-cache', 'show', package])
ret = cls._run_shell_command(cmd)
if ret.returncode != 0:
raise Exception('cannot get package info since {} returned {}'
.format(cmd, ret.returncode))
return ret.stdout.strip()
def _call_restart_node_script(self):
logger.info('Restarting indy')
cmd = compose_cmd(['restart_indy_node'])
ret = self._run_shell_script(cmd, self.timeout)
if ret.returncode != 0:
raise Exception('restart failed: script returned {}'
.format(ret.returncode))
def hold_packages(cls, packages):
if shutil.which("apt-mark"):
packages_to_hold = ' '.join(packages)
cmd = compose_cmd(['apt-mark', 'hold', packages_to_hold])
cls.run_shell_script(cmd)
logger.info('Successfully put {} packages on hold'.format(packages_to_hold))
else:
logger.info('Skipping packages holding')
def _hold_packages(self):
if shutil.which("apt-mark"):
packages_to_hold = ' '.join(self.config.PACKAGES_TO_HOLD + self.hold_ext)
cmd = compose_cmd(['apt-mark', 'hold', packages_to_hold])
NodeControlUtil.run_shell_script(cmd)
logger.info('Successfully put {} packages on hold'.format(packages_to_hold))
else:
logger.info('Skipping packages holding')
def update_package_cache(cls):
cmd = compose_cmd(['apt', 'update'])
ret = cls.run_shell_command(cmd, TIMEOUT)
if ret.returncode != 0:
raise Exception(
'cannot update package cache since {} returned {}'.format(
cmd, ret.returncode))
return ret.stdout.strip()
def _get_ext_info(cls, package):
cmd = compose_cmd(['dpkg', '-s', package])
ret = cls._run_shell_command(cmd)
if ret.returncode != 0:
raise Exception(
'cannot get package info since {} returned {}'.format(
cmd, ret.returncode))
return ret.stdout.strip()
def _update_package_cache(cls):
cmd = compose_cmd(['apt', 'update'])
ret = cls._run_shell_command(cmd)
if ret.returncode != 0:
raise Exception('cannot update package cache since {} returned {}'
.format(cmd,
ret.returncode))
return ret.stdout.strip()
def _get_curr_info(cls, package):
cmd = compose_cmd(['dpkg', '-s', package])
try:
ret = cls.run_shell_command(cmd, TIMEOUT)
except Exception as ex:
return ""
if ret.returncode != 0:
return ""
return ret.stdout.strip()
def _get_info_from_package_manager(cls, package):
cmd = compose_cmd(['apt-cache', 'show', package])
try:
ret = cls.run_shell_command(cmd, TIMEOUT)
except Exception as ex:
return ""
if ret.returncode != 0:
return ""
return ret.stdout.strip()
def _call_restart_node_script(self):
logger.info('Restarting indy')
ret = subprocess.run(compose_cmd(['restart_indy_node']),
shell=True,
timeout=self.timeout)
if ret.returncode != 0:
msg = 'Restart failed: script returned {}'.format(ret.returncode)
logger.error(msg)
raise Exception(msg)
def get_sys_holds(cls):
if shutil.which("apt-mark"):
cmd = compose_cmd(['apt-mark', 'showhold'])
ret = cls.run_shell_command(cmd)
hlds = ret.strip().split("\n")
return [h for h in hlds if h]
else:
logger.info('apt-mark not found. Assume holds is empty.')
return []
def _hold_packages(self):
cmd = compose_cmd(['apt-mark', 'hold', self.packages_to_hold])
ret = self._run_shell_command(cmd)
if ret.returncode != 0:
raise Exception('cannot mark {} packages for hold '
'since {} returned {}'.format(
self.packages_to_hold, cmd, ret.returncode))
logger.info('Successfully put {} packages on hold'.format(
self.packages_to_hold))
def get_latest_pkg_version(
cls,
pkg_name: str,
upstream: SourceVersion = None,
update_cache: bool = True) -> PackageVersion:
upstream_cls = src_version_cls(pkg_name)
if upstream and not isinstance(upstream, upstream_cls):
raise TypeError(
"'upstream' should be instance of {}, got {}"
.format(upstream_cls, type(upstream))
)
if update_cache:
cls.update_package_cache()
try:
cmd = compose_cmd(
['apt-cache', 'show', pkg_name, '|', 'grep', '-E', "'^Version: '"]
)
output = cls.run_shell_script_extended(cmd).strip()
except ShellError as exc:
# will fail if either package not found or grep returns nothing
# the latter is unexpected and treated as no-data as well
logger.info(
"no data for package '{}' found".format(pkg_name)
)
else:
if output:
versions = []
for v in output.split('\n'):
try:
dv = DebianVersion(v.split()[1], upstream_cls=upstream_cls)
except InvalidVersionError as exc:
logger.warning(
"ignoring invalid version from output {} for upstream class {}: {}"
.format(v.split()[1], upstream_cls, exc)
)
else:
if not upstream or (dv.upstream == upstream):
versions.append(dv)
try:
return sorted(versions)[-1]
except IndexError:
pass
except ShellError:
logger.warning(
"version comparison failed unexpectedly for versions: {}"
.format(versions)
)
return None
def _hold_packages(self):
cmd = compose_cmd(['apt-mark', 'hold', self.packages_to_hold])
ret = self._run_shell_command(cmd)
if ret.returncode != 0:
raise Exception('cannot mark {} packages for hold '
'since {} returned {}'
.format(self.packages_to_hold,
cmd,
ret.returncode))
logger.info('Successfully put {} packages on hold'.format(
self.packages_to_hold))
def _call_upgrade_script(self, pkg_name, version):
logger.info('Upgrading indy node to version {}, test_mode {}'.format(version, int(self.test_mode)))
deps = self._get_deps_list('{}={}'.format(pkg_name, version))
deps = '"{}"'.format(deps)
cmd_file = 'upgrade_indy_node'
if self.test_mode:
cmd_file = 'upgrade_indy_node_test'
cmd = compose_cmd([cmd_file, deps])
NodeControlUtil.run_shell_script(cmd, timeout=self.timeout)
def _call_upgrade_script(self, pkg_name: str, pkg_ver: PackageVersion):
logger.info("Upgrading {} to package version {}, test_mode {}".format(
pkg_name, pkg_ver, int(self.test_mode)))
deps = self._get_deps_list('{}={}'.format(pkg_name, pkg_ver))
deps = '"{}"'.format(deps)
cmd_file = 'upgrade_indy_node'
if self.test_mode:
cmd_file = 'upgrade_indy_node_test'
cmd = compose_cmd([cmd_file, deps])
NodeControlUtil.run_shell_script(cmd, timeout=self.timeout)
def _hold_packages(self):
if shutil.which("apt-mark"):
cmd = compose_cmd(['apt-mark', 'hold', self.packages_to_hold])
ret = NodeControlUtil.run_shell_command(cmd, TIMEOUT)
if ret.returncode != 0:
raise Exception('cannot mark {} packages for hold '
'since {} returned {}'.format(
self.packages_to_hold, cmd,
ret.returncode))
logger.info('Successfully put {} packages on hold'.format(
self.packages_to_hold))
else:
logger.info('Skipping packages holding')
def _cmp(cls, v1, v2):
if v1 == v2:
return 0
else:
cmd = compose_cmd(['dpkg', '--compare-versions', v1, 'gt', v2])
try:
NodeControlUtil.run_shell_script_extended(cmd)
except ShellError as exc:
if exc.stderr:
raise
else:
return -1
else:
return 1
def _hold_packages(self):
if shutil.which("apt-mark"):
packages_to_hold = '{} {}'.format(
' '.join(self.config.PACKAGES_TO_HOLD), self.hold_ext)
cmd = compose_cmd(['apt-mark', 'hold', packages_to_hold])
ret = NodeControlUtil.run_shell_command(cmd, TIMEOUT)
if ret.returncode != 0:
raise Exception(
'cannot mark {} packages for hold since {} returned {}'.
format(packages_to_hold, cmd, ret.returncode))
logger.info('Successfully put {} packages on hold'.format(
packages_to_hold))
else:
logger.info('Skipping packages holding')
def _get_info_from_package_manager(cls, package):
ret = subprocess.run(compose_cmd(['apt-cache', 'show', package]),
shell=True,
check=True,
universal_newlines=True,
stdout=subprocess.PIPE,
timeout=TIMEOUT)
if ret.returncode != 0:
msg = 'Upgrade failed: _get_deps_list returned {}'.format(
ret.returncode)
logger.error(msg)
raise Exception(msg)
return ret.stdout.strip()
def _update_package_cache(cls):
ret = subprocess.run(compose_cmd(['apt', 'update']),
shell=True,
check=True,
universal_newlines=True,
stdout=subprocess.PIPE,
timeout=TIMEOUT)
if ret.returncode != 0:
msg = 'Upgrade failed: _get_deps_list returned {}'.format(
ret.returncode)
logger.error(msg)
raise Exception(msg)
return ret.stdout.strip()
def get_sys_holds(cls):
if shutil.which("apt-mark"):
cmd = compose_cmd(['apt-mark', 'showhold'])
try:
ret = cls.run_shell_command(cmd, TIMEOUT)
except Exception as ex:
return []
if ret.returncode != 0:
return []
hlds = ret.stdout.strip().split("\n")
return [h for h in hlds if h]
else:
logger.info('apt-mark not found. Assume holds is empty.')
return []
def _call_upgrade_script(self, version):
logger.info('Upgrading indy node to version {}, test_mode {}'.format(
version, int(self.test_mode)))
deps = self._get_deps_list('indy-node={}'.format(version))
deps = '"{}"'.format(deps)
cmd_file = 'upgrade_indy_node'
if self.test_mode:
cmd_file = 'upgrade_indy_node_test'
cmd = compose_cmd([cmd_file, deps])
ret = self._run_shell_script(cmd, self.timeout)
if ret.returncode != 0:
raise Exception('upgrade script failed, exit code is {}'
.format(ret.returncode))
def _hold_packages(self):
ret = subprocess.run(compose_cmd(
['apt-mark', 'hold', self.packages_to_hold]),
shell=True,
check=True,
universal_newlines=True,
stdout=subprocess.PIPE,
timeout=TIMEOUT)
if ret.returncode != 0:
msg = 'Holding {} packages failed: _hold_packages returned {}'.format(
self.packages_to_hold, ret.returncode)
logger.error(msg)
raise Exception(msg)
logger.info('Successfully put {} packages on hold'.format(
self.packages_to_hold))
def migrate():
source_dir = os.path.expanduser('/home/sovrin/.sovrin')
target_dir = os.path.expanduser('/home/indy/.indy')
shutil.rmtree(target_dir)
shutil.copytree(source_dir, target_dir)
rename_if_exists(target_dir, '.sovrin', '.indy')
rename_if_exists(target_dir, 'sovrin.env', 'indy.env')
rename_if_exists(target_dir, 'sovrin_config.py', 'indy_config.py')
if os.path.isdir(os.path.join(target_dir, 'sample')):
rename_request_files(os.path.join(target_dir, 'sample'))
subprocess.run(compose_cmd(['chown', '-R', 'indy:indy', target_dir]),
shell=True,
check=True)
def migrate():
source_dir = os.path.expanduser('/home/sovrin/.sovrin')
target_dir = os.path.expanduser('/home/indy/.indy')
if os.path.isdir(target_dir):
shutil.rmtree(target_dir)
shutil.copytree(source_dir, target_dir)
rename_if_exists(target_dir, '.sovrin', '.indy')
rename_if_exists(target_dir, 'sovrin.env', 'indy.env')
rename_if_exists(target_dir, 'sovrin_config.py', 'indy_config.py')
if os.path.isdir(os.path.join(target_dir, 'sample')):
rename_request_files(os.path.join(target_dir, 'sample'))
subprocess.run(compose_cmd(['chown', '-R', 'indy:indy', target_dir]),
shell=True,
check=True)
def get_latest_pkg_version(
cls,
pkg_name: str,
upstream: SourceVersion = None,
update_cache: bool = True) -> PackageVersion:
upstream_cls = src_version_cls(pkg_name)
if upstream and not isinstance(upstream, upstream_cls):
raise TypeError(
"'upstream' should be instance of {}, got {}"
.format(upstream_cls, type(upstream))
)
if update_cache:
cls.update_package_cache()
regex = "'^Version: ([0-9]+:)?{}(-|$)'".format(
upstream.full if upstream else '.*')
try:
cmd = compose_cmd(
['apt-cache', 'show', pkg_name, '|', 'grep', '-E', regex])
output = cls.run_shell_script_extended(cmd).strip()
except ShellError as exc:
# will fail if either package not found or grep returns nothing
# the latter is unexpected and treated as no-data as well
logger.info(
"no-data for package '{}' with upstream version '{}' found"
.format(pkg_name, upstream))
else:
if output:
versions = [
DebianVersion(v.split()[1], upstream_cls=upstream_cls)
for v in output.split('\n')
]
try:
return sorted(versions)[-1]
except ShellError:
logger.warning(
"version comparison failed unexpectedly for versions: {}"
.format(versions)
)
return None
def _call_upgrade_script(self, version):
logger.info('Upgrading indy node to version {}, test_mode {}'.format(
version, int(self.test_mode)))
deps = self._get_deps_list('indy-node={}'.format(version))
deps = '"{}"'.format(deps)
cmd_file = 'upgrade_indy_node'
if self.test_mode:
cmd_file = 'upgrade_indy_node_test'
ret = subprocess.run(compose_cmd([cmd_file, deps]),
shell=True,
timeout=self.timeout)
if ret.returncode != 0:
msg = 'Upgrade failed: _upgrade script returned {}'.format(
ret.returncode)
logger.error(msg)
raise Exception(msg)
def _call_migration_script(migration_script, current_platform, timeout):
migration_script_path = \
os.path.normpath(
os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'..',
'..',
str(SCRIPT_PREFIX),
PLATFORM_PREFIX[current_platform],
migration_script + '.py'))
logger.info('script path {}'.format(migration_script_path))
ret = subprocess.run(compose_cmd(
['python3 {}'.format(migration_script_path)]),
shell=True,
timeout=timeout)
if ret.returncode != 0:
msg = 'Migration failed: script returned {}'.format(ret.returncode)
logger.error(msg)
raise Exception(msg)
def _call_migration_script(migration_script, current_platform, timeout):
migration_script_path = \
os.path.normpath(
os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'..',
'..',
str(SCRIPT_PREFIX),
PLATFORM_PREFIX[current_platform],
migration_script + '.py'))
logger.info('script path {}'.format(migration_script_path))
ret = subprocess.run(
compose_cmd(
['python3 {}'.format(migration_script_path)]
),
shell=True,
timeout=timeout)
if ret.returncode != 0:
msg = 'Migration failed: script returned {}'.format(ret.returncode)
logger.error(msg)
raise Exception(msg)
def _call_upgrade_node_script(self):
logger.info('Upgrading indy')
cmd = compose_cmd(['/opt/controller/upgrade_indy'])
NodeControlUtil.run_shell_script(cmd, timeout=self.timeout)
def _call_restart_node_script(self):
logger.info('Restarting indy')
cmd = compose_cmd(['/opt/controller/restart_indy_node'])
NodeControlUtil.run_shell_script(cmd, timeout=self.timeout)
def update_package_cache(cls):
cmd = compose_cmd(['apt', 'update'])
cls.run_shell_script(cmd)
def _get_info_from_package_manager(cls, *package):
cmd_arg = " ".join(list(package))
cmd = compose_cmd(['apt-cache', 'show', cmd_arg])
return cls.run_shell_command(cmd)
#!/usr/bin/python3.5
import os
import subprocess
from stp_core.common.log import getlogger
from indy_common.util import compose_cmd
from indy_node.utils.node_control_tool import NodeControlTool, TIMEOUT
logger = getlogger()
migration_script_path = \
os.path.normpath(
os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'helper_1_0_96_to_1_0_97.py'))
logger.info('script path {}'.format(migration_script_path))
ret = subprocess.run(
compose_cmd(
["su -c 'python3 {}' sovrin".format(migration_script_path)]
),
shell=True,
timeout=TIMEOUT)
if ret.returncode != 0:
msg = 'Migration failed: script returned {}'.format(ret.returncode)
logger.error(msg)
raise Exception(msg)
