def _create_repo(self, repo_name):
repo_dir = sh.joinpths(self.anvil_repo_dir, repo_name)
src_repo_dir = sh.joinpths(self.anvil_repo_dir, self.SRC_REPOS[repo_name])
for a_dir in (repo_dir, src_repo_dir):
if not sh.isdir(a_dir):
sh.mkdirslist(a_dir, tracewriter=self.tracewriter)
cmdline = ["createrepo", a_dir]
LOG.info("Creating repo at %s", a_dir)
sh.execute(cmdline)
repo_filename = sh.joinpths(self.anvil_repo_dir, "%s.repo" % repo_name)
LOG.info("Writing %s", repo_filename)
(_fn, content) = utils.load_template("packaging", "common.repo")
params = {
"repo_name": repo_name,
"baseurl_bin": "file://%s" % repo_dir,
"baseurl_src": "file://%s" % src_repo_dir,
}
sh.write_file(repo_filename, utils.expand_template(content, params),
tracewriter=self.tracewriter)
# Install *.repo file so that anvil deps will be available
# when building OpenStack
system_repo_filename = sh.joinpths(self.YUM_REPO_DIR, "%s.repo" % repo_name)
sh.copy(repo_filename, system_repo_filename)
LOG.info("Copying to %s", system_repo_filename)
self.tracewriter.file_touched(system_repo_filename)
def run_tests(self):
app_dir = self.get_option('app_dir')
if not sh.isdir(app_dir):
LOG.warn("Unable to find application directory at %s, can not run %s tests.",
colorizer.quote(app_dir), colorizer.quote(self.name))
return
pre_cmd = self._get_pre_test_command()
cmd = self._get_test_command()
if not cmd:
LOG.warn("Unable to determine test command for %s, can not run tests.",
colorizer.quote(self.name))
return
env = self._get_env()
try:
if pre_cmd:
LOG.info("Running test setup via: %s",
utils.truncate_text(" ".join(pre_cmd), 80))
sh.execute(pre_cmd, stdout_fh=sys.stdout, stderr_fh=sys.stdout,
cwd=app_dir, env_overrides=env)
LOG.info("Running tests via: %s",
utils.truncate_text(" ".join(cmd), 80))
sh.execute(cmd, stdout_fh=sys.stdout, stderr_fh=sys.stdout,
cwd=app_dir, env_overrides=env)
except excp.ProcessExecutionError as e:
if self.ignore_test_failures:
LOG.warn("Ignoring test failure of component %s: %s", colorizer.quote(self.name), e)
else:
raise
def stop(self):
if self.status()[0].status != comp.STATUS_STOPPED:
stop_cmd = self.distro.get_command('apache', 'stop')
sh.execute(*stop_cmd, run_as_root=True, check_exit_code=True)
return 1
else:
return 0
def _setup_vol_groups(self):
LOG.info("Attempting to setup volume groups for nova volume management.")
mp = dict()
backing_file = self.cfg.getdefaulted('nova', 'volume_backing_file',
sh.joinpths(self.installer.get_option('app_dir'), 'nova-volumes-backing-file'))
vol_group = self.cfg.getdefaulted('nova', 'volume_group', 'nova-volumes')
backing_file_size = utils.to_bytes(self.cfg.getdefaulted('nova', 'volume_backing_file_size', '2052M'))
mp['VOLUME_GROUP'] = vol_group
mp['VOLUME_BACKING_FILE'] = backing_file
mp['VOLUME_BACKING_FILE_SIZE'] = backing_file_size
try:
utils.execute_template(*VG_CHECK_CMD, params=mp)
LOG.warn("Volume group already exists: %r" % (vol_group))
except exceptions.ProcessExecutionError as err:
# Check that the error from VG_CHECK is an expected error
if err.exit_code != 5:
raise
LOG.info("Need to create volume group: %r" % (vol_group))
sh.touch_file(backing_file, die_if_there=False, file_size=backing_file_size)
vg_dev_result = utils.execute_template(*VG_DEV_CMD, params=mp)
if vg_dev_result and vg_dev_result[0]:
LOG.debug("VG dev result: %s" % (vg_dev_result))
# Strip the newlines out of the stdout (which is in the first
# element of the first (and only) tuple in the response
(sysout, _) = vg_dev_result[0]
mp['DEV'] = sysout.replace('\n', '')
utils.execute_template(*VG_CREATE_CMD, params=mp)
# One way or another, we should have the volume group, Now check the
# logical volumes
self._process_lvs(mp)
# Finish off by restarting tgt, and ignore any errors
cmdrestart = self.distro.get_command('iscsi', 'restart', quiet=True)
if cmdrestart:
sh.execute(*cmdrestart, run_as_root=True, check_exit_code=False)
def _create_repo(self, repo_name):
repo_dir = sh.joinpths(self.anvil_repo_dir, repo_name)
src_repo_dir = sh.joinpths(self.anvil_repo_dir,
self.SRC_REPOS[repo_name])
for a_dir in (repo_dir, src_repo_dir):
if not sh.isdir(a_dir):
sh.mkdirslist(a_dir, tracewriter=self.tracewriter)
cmdline = ["createrepo", a_dir]
LOG.info("Creating repo at %s", a_dir)
sh.execute(cmdline)
repo_filename = sh.joinpths(self.anvil_repo_dir, "%s.repo" % repo_name)
LOG.info("Writing %s", repo_filename)
(_fn, content) = utils.load_template("packaging", "common.repo")
params = {
"repo_name": repo_name,
"baseurl_bin": "file://%s" % repo_dir,
"baseurl_src": "file://%s" % src_repo_dir,
}
sh.write_file(repo_filename,
utils.expand_template(content, params),
tracewriter=self.tracewriter)
# NOTE(harlowja): Install *.repo file so that anvil deps will be available
# when building openstack core project packages.
system_repo_filename = sh.joinpths(self.YUM_REPO_DIR,
"%s.repo" % repo_name)
sh.copy(repo_filename,
system_repo_filename,
tracewriter=self.tracewriter)
LOG.info("Copied to %s", system_repo_filename)
def run_tests(self):
app_dir = self.get_option('app_dir')
if not sh.isdir(app_dir):
LOG.warn(
"Unable to find application directory at %s, can not run %s tests.",
colorizer.quote(app_dir), colorizer.quote(self.name))
return
cmd = self._get_test_command()
env = self._get_env()
with open(os.devnull, 'wb') as null_fh:
if self.get_bool_option("verbose", default_value=False):
null_fh = None
try:
sh.execute(cmd,
stdout_fh=None,
stderr_fh=null_fh,
cwd=app_dir,
env_overrides=env)
except excp.ProcessExecutionError as e:
if self.get_bool_option("ignore-test-failures",
default_value=False):
LOG.warn("Ignoring test failure of component %s: %s",
colorizer.quote(self.name), e)
else:
raise e
def _remove(self, pip):
root_cmd = self._get_pip_command()
# Versions don't seem to matter here...
name = self._make_pip_name(pip['name'], None)
LOG.audit("Uninstalling python package %r using pip command %s" % (name, root_cmd))
cmd = [root_cmd] + ['uninstall'] + PIP_UNINSTALL_CMD_OPTS + [name]
sh.execute(*cmd, run_as_root=True)
def _add_bridge(self, name):
cmd_template = self.distro.get_command('openvswitch', 'add_bridge')
cmd = utils.expand_template_deep(cmd_template, {'NAME': name})
try:
sh.execute(cmd)
except excp.ProcessExecutionError:
LOG.warn("Failed to create '%s' openvswitch bridge." % name)
def start(self):
if self._status() != constants.STATUS_STARTED:
start_cmd = self.distro.get_command('apache', 'start')
sh.execute(*start_cmd, run_as_root=True, check_exit_code=True)
return 1
else:
return 0
def status_app(self, program):
status_cmd = self.get_command("status", program)
try:
sh.execute(status_cmd, shell=True)
except excp.ProcessExecutionError:
return False
return True
def run_tests(self):
app_dir = self.get_option('app_dir')
if not sh.isdir(app_dir):
LOG.warn("Unable to find application directory at %s, can not run %s tests.",
colorizer.quote(app_dir), colorizer.quote(self.name))
return
pre_cmd = self._get_pre_test_command()
cmd = self._get_test_command()
if not cmd:
LOG.warn("Unable to determine test command for %s, can not run tests.",
colorizer.quote(self.name))
return
env = self._get_env()
try:
if pre_cmd:
LOG.info("Running test setup via: %s",
utils.truncate_text(" ".join(pre_cmd), 80))
sh.execute(pre_cmd, stdout_fh=sys.stdout, stderr_fh=sys.stdout,
cwd=app_dir, env_overrides=env)
LOG.info("Running tests via: %s",
utils.truncate_text(" ".join(cmd), 80))
sh.execute(cmd, stdout_fh=sys.stdout, stderr_fh=sys.stdout,
cwd=app_dir, env_overrides=env)
except excp.ProcessExecutionError as e:
if self.ignore_test_failures:
LOG.warn("Ignoring test failure of component %s: %s", colorizer.quote(self.name), e)
else:
raise
def stop(self):
if self.status()[0].status != comp.STATUS_STOPPED:
stop_cmd = self._get_run_actions('stop', excp.StopException)
sh.execute(*stop_cmd, run_as_root=True, check_exit_code=True)
return 1
else:
return 0
def stop(self):
if self._status() != constants.STATUS_STOPPED:
stop_cmd = self.distro.get_command('qpid', 'stop')
sh.execute(*stop_cmd, run_as_root=True, check_exit_code=True)
return 1
else:
return 0
def restart(self):
LOG.info("Restarting your database.")
restartcmd = self._get_run_actions('restart', excp.RestartException)
sh.execute(*restartcmd, run_as_root=True, check_exit_code=True)
LOG.info("Please wait %s seconds while it restarts." % self.wait_time)
sh.sleep(self.wait_time)
return 1
def download(distro, uri, target_dir, **kwargs):
puri = urlparse(uri)
scheme = puri.scheme.lower()
path = puri.path
if scheme in ['git'] or path.find('.git') != -1:
dirs_made = sh.mkdirslist(target_dir)
downloader = GitDownloader(distro, uri, target_dir)
downloader.download()
return dirs_made
if scheme in ['http', 'https']:
dirs_made = []
with utils.tempdir() as tdir:
fn = sh.basename(path)
downloader = UrlLibDownloader(uri, sh.joinpths(tdir, fn))
downloader.download()
if fn.endswith('.tar.gz'):
dirs_made = sh.mkdirslist(target_dir)
cmd = ['tar', '-xzvf', sh.joinpths(tdir, fn), '-C', target_dir]
sh.execute(*cmd)
elif fn.endswith('.zip'):
# TODO(harlowja) this might not be 100% right...
# we might have to move the finished directory...
dirs_made = sh.mkdirslist(target_dir)
cmd = ['unzip', sh.joinpths(tdir, fn), '-d', target_dir]
sh.execute(*cmd)
else:
raise excp.DownloadException("Unable to extract %s downloaded from %s" % (fn, uri))
return dirs_made
else:
raise excp.DownloadException("Unknown scheme %s, unable to download from %s" % (scheme, uri))
def status_app(self, program):
status_cmd = self.get_command("status", program)
try:
sh.execute(status_cmd, shell=True)
except excp.ProcessExecutionError:
return False
return True
def stop(self):
if self.status()[0].status != comp.STATUS_STOPPED:
stop_cmd = self.distro.get_command('apache', 'stop')
sh.execute(*stop_cmd, run_as_root=True, check_exit_code=True)
return 1
else:
return 0
def _add_bridge(self, name):
cmd_template = self.distro.get_command('openvswitch', 'add_bridge')
cmd = utils.expand_template_deep(cmd_template, {'NAME': name})
try:
sh.execute(cmd)
except excp.ProcessExecutionError:
LOG.warn("Failed to create '%s' openvswitch bridge." % name)
def restart(self):
LOG.info("Restarting your qpid daemon.")
restart_cmd = self.distro.get_command('qpid', 'restart')
sh.execute(*restart_cmd, run_as_root=True, check_exit_code=True)
LOG.info("Please wait %s seconds while it restarts." % self.wait_time)
sh.sleep(self.wait_time)
return 1
def _clean_it(self):
cleaner_fn = sh.joinpths(self.get_option("app_dir"), BIN_DIR, CLEANER_DATA_CONF)
if sh.isfile(cleaner_fn):
LOG.info("Cleaning up your system by running nova cleaner script: %s", colorizer.quote(cleaner_fn))
# These environment additions are important
# in that they eventually affect how this script runs
env = {"ENABLED_SERVICES": ",".join(self.subsystems.keys())}
sh.execute(cleaner_fn, run_as_root=True, env_overrides=env)
def _install_build_requirements():
build_requires = self.requirements["build-requires"]
if build_requires:
utils.log_iterable(sorted(build_requires),
header=("Installing %s build requirements" % len(build_requires)),
logger=LOG)
cmdline = ["yum", "install", "-y"] + list(build_requires)
sh.execute(cmdline)
def pre_uninstall(self):
try:
self.runtime.restart()
LOG.info("Attempting to reset the rabbit-mq guest password to: %s", colorizer.quote(RESET_BASE_PW))
cmd = self.distro.get_command('rabbit-mq', 'change_password') + [RESET_BASE_PW]
sh.execute(*cmd, run_as_root=True)
except IOError:
LOG.warn(("Could not reset the rabbit-mq password. You might have to manually "
"reset the password to %s before the next install"), colorizer.quote(RESET_BASE_PW))
def start(self):
if self._status() != constants.STATUS_STARTED:
start_cmd = self.distro.get_command('qpid', 'start')
sh.execute(*start_cmd, run_as_root=True, check_exit_code=True)
LOG.info("Please wait %s seconds while it starts up." % self.wait_time)
sh.sleep(self.wait_time)
return 1
else:
return 0
def start(self):
if self._status() != constants.STATUS_STARTED:
startcmd = self._get_run_actions('start', excp.StartException)
sh.execute(*startcmd, run_as_root=True, check_exit_code=True)
LOG.info("Please wait %s seconds while it starts up." % self.wait_time)
sh.sleep(self.wait_time)
return 1
else:
return 0
def _setup_pw(self):
user_id = self.cfg.get('rabbit', 'rabbit_userid')
LOG.info("Setting up your rabbit-mq %s password.", colorizer.quote(user_id))
self.runtime.restart()
passwd = self.cfg.get_password("rabbit", PW_USER_PROMPT)
cmd = self.distro.get_command('rabbit-mq', 'change_password') + [user_id, passwd]
sh.execute(*cmd, run_as_root=True)
LOG.info("Restarting so that your rabbit-mq password is reflected.")
self.runtime.restart()
def run_tests(self):
app_dir = self.get_option('app_dir')
if not sh.isdir(app_dir):
LOG.warn("Unable to find application directory at %s, can not run %s tests.",
colorizer.quote(app_dir), colorizer.quote(self.name))
return
cmd = self._get_test_command()
env = self._get_env()
sh.execute(*cmd, stdout_fh=None, stderr_fh=None, cwd=app_dir, env_overrides=env)
def _write_python_tarball(self, pkg_dir):
cmdline = [
sys.executable,
"setup.py",
"sdist",
"--formats", "gztar",
"--dist-dir", self.rpm_sources_dir,
]
sh.execute(cmdline, cwd=pkg_dir)
def _execute_pip(self, cmd):
pip_cmd = self._get_pip_command()
if not isinstance(pip_cmd, (list, tuple)):
pip_cmd = [pip_cmd]
pip_cmd = pip_cmd + cmd
try:
sh.execute(*pip_cmd, run_as_root=True)
finally:
# The known packages installed is probably not consistent anymore so uncache it
pip_helper.uncache()
def configure(self):
files = self._configure_files()
conf_dir = "/etc/%s" % self.name
if sh.isdir(conf_dir):
sh.execute(
["chown", "-R",
"%s:%s" % (self.name, self.name),
conf_dir],
check_exit_code=False)
return files
def _execute_pip(self, cmd):
pip_cmd = self._get_pip_command()
if not isinstance(pip_cmd, (list, tuple)):
pip_cmd = [pip_cmd]
pip_cmd = pip_cmd + cmd
try:
sh.execute(*pip_cmd, run_as_root=True)
finally:
# The known packages installed is probably not consistent anymore so uncache it
pip_helper.uncache()
def stop_app(self, program):
LOG.info("Stopping program %s under component %s.",
colorizer.quote(program), self.name)
stop_cmd = self.get_command("stop", program)
try:
sh.execute(stop_cmd, shell=True)
except excp.ProcessExecutionError:
LOG.error("Failed to stop program %s under component %s.",
colorizer.quote(program), self.name)
return False
return True
def _setup_pw(self):
user_id = self.get_option('user_id')
LOG.info("Setting up your rabbit-mq %s password.", colorizer.quote(user_id))
self.runtime.start()
self.runtime.wait_active()
cmd = list(self.distro.get_command('rabbit-mq', 'change_password'))
cmd += [user_id, self.get_password('rabbit')]
sh.execute(cmd)
LOG.info("Restarting so that your rabbit-mq password is reflected.")
self.runtime.restart()
self.runtime.wait_active()
def _setup_pw(self):
user_id = self.get_option("user_id")
LOG.info("Setting up your rabbit-mq %s password.", colorizer.quote(user_id))
self.runtime.start()
self.runtime.wait_active()
cmd = list(self.distro.get_command("rabbit-mq", "change_password"))
cmd += [user_id, rhelper.get_shared_passwords(self)["pw"]]
sh.execute(*cmd, run_as_root=True)
LOG.info("Restarting so that your rabbit-mq password is reflected.")
self.runtime.restart()
self.runtime.wait_active()
def stop_app(self, program):
LOG.info("Stopping program %s under component %s.",
colorizer.quote(program), self.name)
stop_cmd = self.get_command("stop", program)
try:
sh.execute(stop_cmd, shell=True)
except excp.ProcessExecutionError:
LOG.error("Failed to stop program %s under component %s.",
colorizer.quote(program), self.name)
return False
return True
def _clean_it(self):
# These environment additions are important
# in that they eventually affect how this script runs
env = dict()
env["ENABLED_SERVICES"] = ",".join(self._filter_subsystems())
env["BIN_DIR"] = sh.joinpths(self.get_option("app_dir"), BIN_DIR)
env["VOLUME_NAME_PREFIX"] = self.cfg.getdefaulted("nova", "volume_name_prefix", DEF_VOL_PREFIX)
cleaner_fn = sh.joinpths(sh.joinpths(self.get_option("app_dir"), BIN_DIR), CLEANER_DATA_CONF)
if sh.isfile(cleaner_fn):
LOG.info("Cleaning up your system by running nova cleaner script: %s", colorizer.quote(cleaner_fn))
cmd = [cleaner_fn]
sh.execute(*cmd, run_as_root=True, env_overrides=env)
def _setup_pw(self):
user_id = self.get_option('user_id')
LOG.info("Setting up your rabbit-mq %s password.",
colorizer.quote(user_id))
self.runtime.start()
self.runtime.wait_active()
cmd = list(self.distro.get_command('rabbit-mq', 'change_password'))
cmd += [user_id, self.get_password('rabbit')]
sh.execute(cmd)
LOG.info("Restarting so that your rabbit-mq password is reflected.")
self.runtime.restart()
self.runtime.wait_active()
def _setup_pw(self):
user_id = self.get_option('user_id')
LOG.info("Setting up your rabbit-mq %s password.",
colorizer.quote(user_id))
self.runtime.start()
self.runtime.wait_active()
cmd = list(self.distro.get_command('rabbit-mq', 'change_password'))
cmd += [user_id, rhelper.get_shared_passwords(self)['pw']]
sh.execute(*cmd, run_as_root=True)
LOG.info("Restarting so that your rabbit-mq password is reflected.")
self.runtime.restart()
self.runtime.wait_active()
def _clean_it(self):
cleaner_fn = sh.joinpths(self.get_option('app_dir'), BIN_DIR,
CLEANER_DATA_CONF)
if sh.isfile(cleaner_fn):
LOG.info(
"Cleaning up your system by running nova cleaner script: %s",
colorizer.quote(cleaner_fn))
# These environment additions are important
# in that they eventually affect how this script runs
env = {
'ENABLED_SERVICES': ",".join(self.subsystems.keys()),
}
sh.execute(cleaner_fn, run_as_root=True, env_overrides=env)
def apply_patches(patch_files, working_dir):
apply_files = expand_patches(patch_files)
if not len(apply_files):
return
if not sh.isdir(working_dir):
LOG.warn("Can only apply %s patches 'inside' a directory and not '%s'", len(apply_files), working_dir)
return
with utils.chdir(working_dir):
for p in apply_files:
LOG.debug("Applying patch %s in directory %s", p, working_dir)
patch_contents = sh.load_file(p)
if len(patch_contents):
sh.execute(*PATCH_CMD, process_input=patch_contents)
def run_tests(self):
app_dir = self.get_option('app_dir')
if not sh.isdir(app_dir):
LOG.warn("Unable to find application directory at %s, can not run %s tests.",
colorizer.quote(app_dir), colorizer.quote(self.name))
return
cmd = self._get_test_command()
env = self._get_env()
with open(os.devnull, 'wb') as null_fh:
if self.get_bool_option("tests_verbose", default_value=False):
null_fh = None
sh.execute(*cmd, stdout_fh=None, stderr_fh=null_fh,
cwd=app_dir, env_overrides=env)
def pre_uninstall(self):
try:
LOG.debug("Attempting to reset the rabbit-mq guest password to: %s", colorizer.quote(RESET_BASE_PW))
self.runtime.start()
self.runtime.wait_active()
cmd = self.distro.get_command('rabbit-mq', 'change_password') + [RESET_BASE_PW]
sh.execute(cmd)
LOG.info("Restarting so that your rabbit-mq password is reflected.")
self.runtime.restart()
self.runtime.wait_active()
except IOError:
LOG.warn(("Could not reset the rabbit-mq password. You might have to manually "
"reset the password to %s before the next install"), colorizer.quote(RESET_BASE_PW))
def run_tests(self):
app_dir = self.get_option('app_dir')
if not sh.isdir(app_dir):
LOG.warn(
"Unable to find application directory at %s, can not run %s tests.",
colorizer.quote(app_dir), colorizer.quote(self.name))
return
cmd = self._get_test_command()
env = self._get_env()
sh.execute(*cmd,
stdout_fh=None,
stderr_fh=None,
cwd=app_dir,
env_overrides=env)
def install(self):
super(YumDependencyHandler, self).install()
repo_filename = sh.joinpths(self.YUM_REPO_DIR, self.REPO_FN)
# Ensure we copy the local repo file name to the main repo so that
# yum will find it when installing packages.
sh.write_file(repo_filename,
sh.load_file(self.anvil_repo_filename),
tracewriter=self.tracewriter)
# Erase it if its been previously installed.
cmdline = []
if self.helper.is_installed(self.OPENSTACK_DEPS_PACKAGE_NAME):
cmdline.append(self.OPENSTACK_DEPS_PACKAGE_NAME)
for p in self.nopackages:
if self.helper.is_installed(p):
cmdline.append(p)
if cmdline:
cmdline = ["yum", "erase", "-y"] + cmdline
sh.execute(cmdline, stdout_fh=sys.stdout, stderr_fh=sys.stderr)
cmdline = ["yum", "clean", "all"]
sh.execute(cmdline)
cmdline = ["yum", "install", "-y", self.OPENSTACK_DEPS_PACKAGE_NAME]
sh.execute(cmdline, stdout_fh=sys.stdout, stderr_fh=sys.stderr)
rpm_names = self._convert_names_python2rpm(self.python_names)
if rpm_names:
cmdline = ["yum", "install", "-y"] + rpm_names
sh.execute(cmdline, stdout_fh=sys.stdout, stderr_fh=sys.stderr)
def apply_patches(patch_files, working_dir):
apply_files = expand_patches(patch_files)
if not len(apply_files):
return
if not sh.isdir(working_dir):
LOG.warn("Can only apply %s patches 'inside' a directory and not '%s'",
len(apply_files), working_dir)
return
with utils.chdir(working_dir):
for p in apply_files:
LOG.debug("Applying patch %s in directory %s", p, working_dir)
patch_contents = sh.load_file(p)
if len(patch_contents):
sh.execute(PATCH_CMD, process_input=patch_contents)
def _uninstall_python(self):
py_listing = self.tracereader.py_listing()
if py_listing:
py_listing_dirs = set()
for (_name, where) in py_listing:
py_listing_dirs.add(where)
utils.log_iterable(py_listing_dirs, logger=LOG,
header="Uninstalling %s python setups" % (len(py_listing_dirs)))
unsetup_cmd = self.distro.get_command('python', 'unsetup')
for where in py_listing_dirs:
if sh.isdir(where):
sh.execute(*unsetup_cmd, cwd=where, run_as_root=True)
else:
LOG.warn("No python directory found at %s - skipping", colorizer.quote(where, quote_color='red'))
def configure(self):
configs_made = nova.NovaInstaller.configure(self)
driver_canon = utils.canon_virt_driver(self.get_option('virt_driver'))
if driver_canon == 'libvirt':
# Create a libvirtd user group
if not sh.group_exists('libvirtd'):
cmd = ['groupadd', 'libvirtd']
sh.execute(cmd)
if not sh.isfile(LIBVIRT_POLICY_FN):
contents = self._get_policy(self._get_policy_users())
sh.mkdirslist(sh.dirname(LIBVIRT_POLICY_FN))
sh.write_file(LIBVIRT_POLICY_FN, contents)
configs_made += 1
return configs_made
def post_install(self):
binstall.PkgInstallComponent.post_install(self)
user_name = self.get_option('user_id')
try:
LOG.debug(
"Attempting to create the qpid user '%s' and their associated password.",
user_name)
cmd_template = self.distro.get_command('qpid', 'create_user')
cmd = utils.expand_template_deep(cmd_template, {'USER': user_name})
if cmd:
sh.execute(cmd, process_input=self.get_password('qpid'))
except IOError:
LOG.warn((
"Could not create the user/password. You might have to manually "
"create the user/password before running."))
def details(self):
base = super(PythonPackager, self).details
if self._extended_details is None:
ext_dets = {
'automatic_dependencies': False,
}
setup_cmd = ['python', self._setup_fn]
replacements = {
'version': '--version',
'license': '--license',
'name': '--name',
'vendor': '--author',
'url': '--url',
}
for (key, opt) in replacements.items():
cmd = setup_cmd + [opt]
(stdout, _stderr) = sh.execute(*cmd, run_as_root=True, cwd=self.get_option('app_dir'))
stdout = stdout.strip()
if stdout:
ext_dets[key] = stdout
description = self._description()
if description:
ext_dets['description'] = "\n".join(description)
ext_dets['summary'] = utils.truncate_text("\n".join(description[0:1]), 50)
ext_dets['changelog'] = self._build_changelog()
self._extended_details = ext_dets
extended_dets = dict(base)
extended_dets.update(self._extended_details)
return extended_dets
def _get_python_names(package_dirs):
python_names = []
for pkg_dir in package_dirs:
cmdline = ["python", "setup.py", "--name"]
python_names.append(
sh.execute(cmdline, cwd=pkg_dir)[0].splitlines()[-1].strip())
return python_names
def _call_multipip(self, requirements,
requires_files=None, ignore_requirements=None):
cmdline = [self._multipip_executable]
if requires_files:
cmdline.append("-r")
cmdline.extend(requires_files)
if ignore_requirements:
cmdline.append("--ignore-package")
cmdline.extend(ignore_requirements)
if requirements:
cmdline.append("--")
cmdline.extend(requirements)
(stdout, stderr) = sh.execute(cmdline, check_exit_code=False)
compatibles = list(utils.splitlines_not_empty(stdout))
incompatibles = collections.defaultdict(list)
current_name = ''
for line in stderr.strip().splitlines():
if line.endswith(": incompatible requirements"):
current_name = line.split(":", 1)[0].lower().strip()
if current_name not in incompatibles:
incompatibles[current_name] = []
else:
incompatibles[current_name].append(line)
cleaned_incompatibles = dict()
for (requirement, lines) in six.iteritems(incompatibles):
requirement = requirement.strip()
if not requirement:
continue
if not lines:
continue
cleaned_incompatibles[requirement] = lines
incompatibles = cleaned_incompatibles
return (compatibles, incompatibles)
def pre_install(self):
# Check if network namespaces are supported.
if self.get_option("use_namespaces", default_value=True):
try:
# "ip netns" command is used for network namespace management.
# We are trying to execute this command and if it was executed
# successfully then network namespaces support is enabled.
sh.execute(["ip", "netns"])
except exceptions.ProcessExecutionError:
raise exceptions.InstallException(
"Network namespaces are not supported in your system. "
"Please, install kernel and iproute with network "
"namespaces support. To install them from RDO you can "
"use the following script: "
"./tools/install-neutron-ns-packages.sh")
super(NeutronInstaller, self).pre_install()
def post_uninstall(self):
binstall.PkgUninstallComponent.post_uninstall(self)
user_name = self.get_option('user_id')
if user_name in NO_DELETE:
return
try:
LOG.debug(
"Attempting to delete the qpid user '%s' and their associated password.",
user_name)
cmd_template = self.distro.get_command('qpid', 'delete_user')
cmd = utils.expand_template_deep(cmd_template, {'USER': user_name})
if cmd:
sh.execute(cmd)
except IOError:
LOG.warn((
"Could not delete the user/password. You might have to manually "
"reset the user/password before the next install."))
def _run_action(self, action, check_exit_code=True):
cmd = self._get_command(action)
if not cmd:
raise NotImplementedError(
"No distro command provided to perform action %r" % (action))
return sh.execute(*cmd,
run_as_root=True,
check_exit_code=check_exit_code)
def _service_status(self):
cmd = self.distro.get_command('libvirt', 'status')
(stdout, stderr) = sh.execute(cmd, check_exit_code=False)
combined = (stdout + stderr)
if combined.lower().find("running") != -1 or combined.lower().find(
'start') != -1:
return (_ALIVE, combined)
else:
return (_DEAD, combined)
def uninstall(self):
super(YumDependencyHandler, self).uninstall()
if self.tracereader.exists():
for f in self.tracereader.files_touched():
sh.unlink(f)
for d in self.tracereader.dirs_made():
sh.deldir(d)
sh.unlink(self.tracereader.filename())
self.tracereader = None
rpm_names = []
for name in self._convert_names_python2rpm(self.python_names):
if self.helper.is_installed(name):
rpm_names.append(name)
if rpm_names:
cmdline = ["yum", "remove", "--remove-leaves", "-y"] + rpm_names
sh.execute(cmdline, stdout_fh=sys.stdout, stderr_fh=sys.stderr)
def _get_commit_detail(self, commit, field, am=1):
detail_cmd = ['git', 'log', '--color=never', '-%s' % (am), "--pretty=format:%s" % (field), commit]
(stdout, _stderr) = sh.execute(*detail_cmd, cwd=self.wkdir)
ret = stdout.strip('\n').splitlines()
if len(ret) == 1:
ret = ret[0]
else:
ret = filter(lambda x: x.strip() != '', ret)
ret = "\n".join(ret)
return ret
def pre_uninstall(self):
try:
LOG.debug(
"Attempting to reset the rabbit-mq guest password to: %s",
colorizer.quote(RESET_BASE_PW))
self.runtime.start()
self.runtime.wait_active()
cmd = self.distro.get_command('rabbit-mq',
'change_password') + [RESET_BASE_PW]
sh.execute(cmd)
LOG.info(
"Restarting so that your rabbit-mq password is reflected.")
self.runtime.restart()
self.runtime.wait_active()
except IOError:
LOG.warn((
"Could not reset the rabbit-mq password. You might have to manually "
"reset the password to %s before the next install"),
colorizer.quote(RESET_BASE_PW))
def status_app(self, program):
status_cmd = self.get_command("status", program)
try:
output = sh.execute(status_cmd, shell=True)[0]
except excp.ProcessExecutionError:
return False
if utils.has_any(output, "is not running"):
return False
return True
def _install_python_setups(self):
py_dirs = self.python_directories
if py_dirs:
real_dirs = {}
for (name, wkdir) in py_dirs.items():
real_dirs[name] = wkdir
if not real_dirs[name]:
real_dirs[name] = self.get_option('app_dir')
utils.log_iterable(real_dirs.values(), logger=LOG,
header="Setting up %s python directories" % (len(real_dirs)))
setup_cmd = self.distro.get_command('python', 'setup')
for (name, working_dir) in real_dirs.items():
sh.mkdirslist(working_dir, tracewriter=self.tracewriter)
setup_fn = sh.joinpths(self.get_option('trace_dir'), "%s.python.setup" % (name))
sh.execute(*setup_cmd, cwd=working_dir, run_as_root=True,
stderr_fn='%s.stderr' % (setup_fn),
stdout_fn='%s.stdout' % (setup_fn),
tracewriter=self.tracewriter)
self.tracewriter.py_installed(name, working_dir)
