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.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: %s" % (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: %s" % (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 restart(self):
LOG.info("Restarting your database.")
restartcmd = self._get_run_actions('restart', excp.RestartException)
sh.execute(*restartcmd, run_as_root=True)
LOG.info("Please wait %s seconds while it restarts." % START_WAIT_TIME)
time.sleep(START_WAIT_TIME)
return 1
def stop(self):
if self.status() == comp.STATUS_STARTED:
stopcmd = self._get_run_actions('stop', excp.StopException)
sh.execute(*stopcmd, run_as_root=True)
return 1
else:
return 0
def post_install(self):
parent_result = comp.PkgInstallComponent.post_install(self)
#extra actions to ensure we are granted access
dbtype = self.cfg.get("db", "type")
dbactions = DB_ACTIONS.get(dbtype)
if dbactions and dbactions.get('grant_all'):
#update the DB to give user 'USER'@'%' full control of the all databases:
grant_cmd = dbactions.get('grant_all')
params = self._get_param_map(None)
cmds = list()
cmds.append({
'cmd': grant_cmd,
'run_as_root': False,
})
#shell seems to be needed here
#since python escapes this to much...
utils.execute_template(*cmds, params=params, shell=True)
#special mysql actions
if dbactions and dbtype == MYSQL:
cmd = dbactions.get('host_adjust')
if cmd:
sh.execute(*cmd, run_as_root=True, shell=True)
#restart it to make sure all good
self.runtime.restart()
return parent_result
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 start(self):
if self.status() == comp.STATUS_STOPPED:
startcmd = self._gettypeactions('start', excp.StartException)
sh.execute(*startcmd, run_as_root=True)
return 1
else:
return 0
def _uninstall_python(self):
pylisting = self.tracereader.py_listing()
if pylisting:
LOG.info("Uninstalling %s python setups" % (len(pylisting)))
for entry in pylisting:
where = entry.get('where')
sh.execute(*PY_UNINSTALL, cwd=where, run_as_root=True)
def restart(self):
curr_status = self.status()
if curr_status == comp.STATUS_STARTED:
sh.execute(*APACHE_RESTART_CMD,
run_as_root=True)
return 1
return 0
def stop(self):
curr_status = self.status()
if curr_status == comp.STATUS_STARTED:
sh.execute(*APACHE_STOP_CMD,
run_as_root=True)
return 1
return 0
def stop(self):
if self.status() != comp.STATUS_STOPPED:
stopcmd = self._get_run_actions('stop', excp.StopException)
sh.execute(*stopcmd, run_as_root=True, check_exit_code=True)
return 1
else:
return 0
def start(self):
curr_status = self.status()
if curr_status == comp.STATUS_STARTED:
# restart it ?
return self.restart()
else:
sh.execute(*APACHE_START_CMD, run_as_root=True)
return 1
def _setup_pw(self):
LOG.info("Setting up your rabbit-mq guest password.")
self.runtime.restart()
passwd = self.pw_gen.get_password("rabbit", PW_USER_PROMPT)
cmd = self.distro.get_command('rabbit-mq', 'change_password') + [passwd]
sh.execute(*cmd, run_as_root=True)
LOG.info("Restarting so that your rabbit-mq guest password is reflected.")
self.runtime.restart()
def _setup_pw(self):
LOG.info("Setting up your rabbit-mq guest password.")
self.runtime.restart()
passwd = self.cfg.get("passwords", "rabbit")
cmd = PWD_CMD + [passwd]
sh.execute(*cmd, run_as_root=True)
LOG.info("Restarting so that your rabbit-mq guest password is reflected.")
self.runtime.restart()
def _setup_pw(self):
LOG.info("Setting up your rabbit-mq guest password.")
self.runtime.restart()
passwd = self.pw_gen.get_password("rabbit", PW_USER_PROMPT)
cmd = self.distro.get_command('rabbit-mq', 'change_password') + [passwd]
sh.execute(*cmd, run_as_root=True)
LOG.info("Restarting so that your rabbit-mq guest password is reflected.")
self.runtime.restart()
def restart_service(self):
if self._service_status() != _ALIVE:
cmd = self.distro.get_command('libvirt', 'restart')
sh.execute(*cmd, run_as_root=True)
LOG.info(
"Restarting the libvirt service, please wait %s seconds until its started."
% (self.wait_time))
sh.sleep(self.wait_time)
def start(self):
if self.status() == comp.STATUS_STOPPED:
startcmd = self._get_run_actions('start', excp.StartException)
sh.execute(*startcmd, run_as_root=True)
LOG.info("Please wait %s seconds while it starts up." % START_WAIT_TIME)
time.sleep(START_WAIT_TIME)
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 stop(self):
if self.status() != comp.STATUS_STOPPED:
stopcmd = self._get_run_actions('stop', excp.StopException)
sh.execute(*stopcmd,
run_as_root=True,
check_exit_code=True)
return 1
else:
return 0
def pre_uninstall(self):
try:
self.runtime.restart()
LOG.info("Attempting to reset the rabbit-mq guest password to \"%s\"", RESET_BASE_PW)
cmd = PWD_CMD + [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") % (RESET_BASE_PW))
def pre_uninstall(self):
try:
self.runtime.restart()
LOG.info("Attempting to reset the rabbit-mq guest password to %r", 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 %r before the next install") % (RESET_BASE_PW))
def pre_uninstall(self):
try:
self.runtime.restart()
LOG.info("Attempting to reset the rabbit-mq guest password to %r", 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 %r before the next install") % (RESET_BASE_PW))
def _uninstall_python(self):
py_listing = self.tracereader.py_listing()
if py_listing:
py_listing_dirs = set()
for (_, 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)))
for where in py_listing_dirs:
sh.execute(*PY_UNINSTALL, cwd=where, run_as_root=True)
def _gitdownload(storewhere, uri, branch=None):
dirsmade = sh.mkdirslist(storewhere)
LOG.info("Downloading from %s to %s" % (uri, storewhere))
cmd = ["git", "clone"] + [uri, storewhere]
sh.execute(*cmd)
if branch and branch != GIT_MASTER_BRANCH:
LOG.info("Adjusting git branch to %s" % (branch))
cmd = ['git', 'checkout'] + [branch]
sh.execute(*cmd, cwd=storewhere)
return dirsmade
def _run_cmd(self, cmd):
#this seems to fix one of the bugs with rabbit mq starting and stopping
#not cool, possibly connected to the following bugs:
#https://bugs.launchpad.net/ubuntu/+source/rabbitmq-server/+bug/878597
#https://bugs.launchpad.net/ubuntu/+source/rabbitmq-server/+bug/878600
#
#rhel seems to have this bug also...
with TemporaryFile() as f:
sh.execute(*cmd, run_as_root=True,
stdout_fh=f, stderr_fh=f)
def start(self):
if self.status() != comp.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 start(self):
if self.status() != comp.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 install(pip, distro):
name = pip['name']
root_cmd = distro.get_command_config('pip')
LOG.audit("Installing python package %r using pip command %s" % (name, root_cmd))
name_full = _make_pip_name(name, pip.get('version'))
real_cmd = [root_cmd, 'install'] + PIP_INSTALL_CMD_OPTS
options = pip.get('options')
if options:
LOG.debug("Using pip options: %s" % (options))
real_cmd += [str(options)]
real_cmd += [name_full]
sh.execute(*real_cmd, run_as_root=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.desired_subsystems)
env['BIN_DIR'] = self.bin_dir
env['VOLUME_NAME_PREFIX'] = self.cfg.getdefaulted('nova', 'volume_name_prefix', DEF_VOL_PREFIX)
cleaner_fn = sh.joinpths(self.bin_dir, CLEANER_DATA_CONF)
if sh.isfile(cleaner_fn):
LOG.info("Cleaning up your system by running nova cleaner script [%s]." % (cleaner_fn))
cmd = CLEANER_CMD_ROOT + [cleaner_fn]
sh.execute(*cmd, run_as_root=True, env_overrides=env)
def install(pip, distro):
name = pip['name']
root_cmd = distro.get_command_config('pip')
LOG.audit("Installing python package %r using pip command %s" %
(name, root_cmd))
name_full = _make_pip_name(name, pip.get('version'))
real_cmd = [root_cmd, 'install'] + PIP_INSTALL_CMD_OPTS
options = pip.get('options')
if options:
LOG.debug("Using pip options: %s" % (options))
real_cmd += [str(options)]
real_cmd += [name_full]
sh.execute(*real_cmd, run_as_root=True)
def stop(self, app_name):
fn_name = UPSTART_TEMPL % (app_name)
trace_fn = tr.trace_fn(self.trace_dir, fn_name)
# Emit the start, keep track and only do one per component name
component_event = self.component_name + STOP_EVENT_SUFFIX
if component_event in self.events:
LOG.debug("Already emitted event: %s" % (component_event))
else:
LOG.info("About to emit event: %s" % (component_event))
cmd = EMIT_BASE_CMD + [component_event]
sh.execute(*cmd, run_as_root=True)
self.events.add(component_event)
sh.unlink(trace_fn)
def stop(self, app_name):
fn_name = UPSTART_TEMPL % (app_name)
trace_fn = tr.trace_fn(self.trace_dir, fn_name)
# Emit the start, keep track and only do one per component name
component_event = self.component_name + STOP_EVENT_SUFFIX
if component_event in self.events:
LOG.debug("Already emitted event: %s" % (component_event))
else:
LOG.debug("About to emit event: %s" % (component_event))
cmd = EMIT_BASE_CMD + [component_event]
sh.execute(*cmd, run_as_root=True)
self.events.add(component_event)
sh.unlink(trace_fn)
def virt_ok(virt_type, distro):
virt_protocol = LIBVIRT_PROTOCOL_MAP.get(virt_type)
if not virt_protocol:
return False
#ensure we can do this
restart(distro)
#this is our sanity check to ensure that we can actually use that virt technology
cmd = ['virsh', '-c', virt_protocol, 'uri']
try:
sh.execute(*cmd, run_as_root=True)
return True
except excp.ProcessExecutionError:
return False
def uninstall(pip, distro, skip_errors=True):
root_cmd = distro.get_command('pip')
try:
# Versions don't seem to matter here...
name = _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)
except excp.ProcessExecutionError:
if skip_errors:
LOG.debug(("Ignoring execution error that occured when uninstalling pip %r!"
" (this may be ok if it was uninstalled by a previous component)") % (name))
else:
raise
def uninstall(pips, distro, skip_errors=True):
pipnames = sorted(pips.keys())
root_cmd = PIP_CMD_NAMES[distro]
LOG.info("Uninstalling python packages (%s) using command (%s)" % (", ".join(pipnames), root_cmd))
for name in pipnames:
try:
LOG.debug("Uninstall python package (%s)" % (name))
cmd = [root_cmd, 'uninstall'] + PIP_UNINSTALL_CMD_OPTS + [str(name)]
sh.execute(*cmd, run_as_root=True)
except excp.ProcessExecutionError:
if skip_errors:
LOG.warn("Ignoring execution error that occured when uninstalling pip %s!" % (name))
else:
raise
def _do_screen_init(self):
LOG.debug("Creating a new screen session named [%s]" % (SESSION_NAME))
session_init_cmd = self._gen_cmd(SESSION_INIT)
sh.execute(*session_init_cmd,
shell=True,
run_as_root=ROOT_GO,
env_overrides=self._get_env())
LOG.debug("Waiting %s seconds before we attempt to set the title bar for that session." % (self.wait_time))
sh.sleep(self.wait_time)
bar_init_cmd = self._gen_cmd(BAR_INIT)
sh.execute(*bar_init_cmd,
shell=True,
run_as_root=ROOT_GO,
env_overrides=self._get_env())
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.desired_subsystems)
env['BIN_DIR'] = self.bin_dir
env['VOLUME_NAME_PREFIX'] = self.cfg.getdefaulted(
'nova', 'volume_name_prefix', DEF_VOL_PREFIX)
cleaner_fn = sh.joinpths(self.bin_dir, CLEANER_DATA_CONF)
if sh.isfile(cleaner_fn):
LOG.info(
"Cleaning up your system by running nova cleaner script %r" %
(cleaner_fn))
cmd = CLEANER_CMD_ROOT + [cleaner_fn]
sh.execute(*cmd, run_as_root=True, env_overrides=env)
def post_start(self):
tgt_fn = sh.joinpths(self.bin_dir, MANAGE_DATA_CONF)
if sh.is_executable(tgt_fn):
# If its still there, run it
# these environment additions are important
# in that they eventually affect how this script runs
LOG.info("Waiting %s seconds so that keystone can start up before running first time init." % (self.wait_time))
sh.sleep(self.wait_time)
env = dict()
env['ENABLED_SERVICES'] = ",".join(self.instances.keys())
env['BIN_DIR'] = self.bin_dir
setup_cmd = MANAGE_CMD_ROOT + [tgt_fn]
LOG.info("Running %r command to initialize keystone." % (" ".join(setup_cmd)))
sh.execute(*setup_cmd, env_overrides=env, run_as_root=False)
utils.mark_unexecute_file(tgt_fn, env)
def _setup_data(self):
LOG.info("Configuring data setup template %s", MANAGE_DATA_CONF)
(src_fn, contents) = utils.load_template(self.component_name, MANAGE_DATA_CONF)
params = self._get_param_map(MANAGE_DATA_CONF)
contents = utils.param_replace(contents, params, True)
tgt_fn = sh.joinpths(self.bindir, MANAGE_DATA_CONF)
sh.write_file(tgt_fn, contents)
# This environment additions are important
# in that they eventually affect how this script runs
env = dict()
env['ENABLED_SERVICES'] = ",".join(self.instances.keys())
env['BIN_DIR'] = self.bindir
setup_cmd = MANAGER_CMD_ROOT + [tgt_fn]
LOG.info("Running (%s) command to setup keystone." % (" ".join(setup_cmd)))
sh.execute(*setup_cmd, env_overrides=env)
def _start(self, app_name, program, program_args):
run_trace = tr.TraceWriter(tr.trace_fn(self.trace_dir, UPSTART_TEMPL % (app_name)))
run_trace.trace(TYPE, RUN_TYPE)
run_trace.trace(NAME, app_name)
run_trace.trace(ARGS, json.dumps(program_args))
# Emit the start, keep track and only do one per component name
component_event = self.component_name + START_EVENT_SUFFIX
if component_event in self.events:
LOG.debug("Already emitted event: %s" % (component_event))
else:
LOG.debug("About to emit event: %s" % (component_event))
cmd = EMIT_BASE_CMD + [component_event]
sh.execute(*cmd, run_as_root=True)
self.events.add(component_event)
return run_trace.filename()
def _run_cmd(self, cmd, check_exit=True):
# This seems to fix one of the bugs with rabbit mq starting and stopping
# not cool, possibly connected to the following bugs:
#
# See: https://bugs.launchpad.net/ubuntu/+source/rabbitmq-server/+bug/878597
# See: https://bugs.launchpad.net/ubuntu/+source/rabbitmq-server/+bug/878600
#
# RHEL seems to have this bug also...
if self.redir_out:
with TemporaryFile() as f:
return sh.execute(*cmd, run_as_root=True,
stdout_fh=f, stderr_fh=f,
check_exit_code=check_exit)
else:
return sh.execute(*cmd, run_as_root=True,
check_exit_code=check_exit)
def _do_screen_init(self):
LOG.debug("Creating a new screen session named [%s]" % (SESSION_NAME))
session_init_cmd = self._gen_cmd(SESSION_INIT)
sh.execute(*session_init_cmd,
shell=True,
run_as_root=ROOT_GO,
env_overrides=self._get_env())
LOG.debug(
"Waiting %s seconds before we attempt to set the title bar for that session."
% (self.wait_time))
sh.sleep(self.wait_time)
bar_init_cmd = self._gen_cmd(BAR_INIT)
sh.execute(*bar_init_cmd,
shell=True,
run_as_root=ROOT_GO,
env_overrides=self._get_env())
def _start(self, app_name, program, program_args):
run_trace = tr.TraceWriter(
tr.trace_fn(self.trace_dir, UPSTART_TEMPL % (app_name)))
run_trace.trace(TYPE, RUN_TYPE)
run_trace.trace(NAME, app_name)
run_trace.trace(ARGS, json.dumps(program_args))
# Emit the start, keep track and only do one per component name
component_event = self.component_name + START_EVENT_SUFFIX
if component_event in self.events:
LOG.debug("Already emitted event: %s" % (component_event))
else:
LOG.debug("About to emit event: %s" % (component_event))
cmd = EMIT_BASE_CMD + [component_event]
sh.execute(*cmd, run_as_root=True)
self.events.add(component_event)
return run_trace.filename()
def uninstall(pip, distro, skip_errors=True):
root_cmd = distro.get_command('pip')
try:
# Versions don't seem to matter here...
name = _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)
except excp.ProcessExecutionError:
if skip_errors:
LOG.debug((
"Ignoring execution error that occured when uninstalling pip %r!"
" (this may be ok if it was uninstalled by a previous component)"
) % (name))
else:
raise
def post_start(self):
tgt_fn = sh.joinpths(self.bin_dir, MANAGE_DATA_CONF)
if sh.is_executable(tgt_fn):
# If its still there, run it
# these environment additions are important
# in that they eventually affect how this script runs
LOG.info(
"Waiting %s seconds so that keystone can start up before running first time init."
% (self.wait_time))
sh.sleep(self.wait_time)
env = dict()
env['ENABLED_SERVICES'] = ",".join(self.instances.keys())
env['BIN_DIR'] = self.bin_dir
setup_cmd = MANAGE_CMD_ROOT + [tgt_fn]
LOG.info("Running %r command to initialize keystone." %
(" ".join(setup_cmd)))
sh.execute(*setup_cmd, env_overrides=env, run_as_root=False)
utils.mark_unexecute_file(tgt_fn, env)
def _setup_network_init(self):
tgt_fn = sh.joinpths(self.bin_dir, NET_INIT_CONF)
if sh.is_executable(tgt_fn):
LOG.info("Creating your nova network to be used with instances.")
# If still there, run it
# these environment additions are important
# in that they eventually affect how this script runs
if 'quantum' in self.options:
LOG.info(
"Waiting %s seconds so that quantum can start up before running first time init."
% (self.wait_time))
sh.sleep(self.wait_time)
env = dict()
env['ENABLED_SERVICES'] = ",".join(self.options)
setup_cmd = NET_INIT_CMD_ROOT + [tgt_fn]
LOG.info("Running %r command to initialize nova's network." %
(" ".join(setup_cmd)))
sh.execute(*setup_cmd, env_overrides=env, run_as_root=False)
utils.mark_unexecute_file(tgt_fn, env)
def _service_status(self):
cmd = self.distro.get_command('libvirt', 'status')
(stdout, stderr) = sh.execute(*cmd,
run_as_root=True,
check_exit_code=False)
combined = (stdout + stderr).lower()
if combined.find("running") != -1 or combined.find('start') != -1:
return _ALIVE
else:
return _DEAD
def _do_stop(self, app_name, session_id):
mp = dict()
mp['SESSION_NAME'] = session_id
mp['NAME'] = app_name
LOG.debug(
"Stopping program running in session [%s] in window named [%s]." %
(session_id, app_name))
kill_cmd = self._gen_cmd(CMD_KILL, mp)
sh.execute(*kill_cmd,
shell=True,
run_as_root=ROOT_GO,
env_overrides=self._get_env(),
check_exit_code=False)
# We have really no way of knowing if it worked or not, screen sux...
wipe_cmd = self._gen_cmd(CMD_WIPE, mp)
sh.execute(*wipe_cmd,
shell=True,
run_as_root=ROOT_GO,
env_overrides=self._get_env(),
check_exit_code=False)
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.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 _active_sessions(self):
knowns = list()
list_cmd = self._gen_cmd(LIST_CMD)
(sysout, _) = sh.execute(*list_cmd,
check_exit_code=False,
run_as_root=ROOT_GO,
env_overrides=self._get_env())
if sysout.lower().find("No Sockets found") != -1:
return knowns
for line in sysout.splitlines():
mtch = SESSION_NAME_MTCHER.match(line)
if mtch:
knowns.append(mtch.group(1))
return knowns
def _do_start(self, session, prog_name, cmd):
init_cmd = list()
mp = dict()
run_cmd = " ".join(cmd)
mp['SESSION_NAME'] = session
mp['NAME'] = prog_name
mp['CMD'] = run_cmd
init_cmd = self._gen_cmd(CMD_INIT, mp)
LOG.debug("Creating a new screen window named [%s] in session [%s]" %
(prog_name, session))
sh.execute(*init_cmd,
shell=True,
run_as_root=ROOT_GO,
env_overrides=self._get_env())
LOG.debug(
"Waiting %s seconds before we attempt to run command [%s] in that window."
% (self.wait_time, run_cmd))
sh.sleep(self.wait_time)
start_cmd = self._gen_cmd(CMD_START, mp)
sh.execute(*start_cmd,
shell=True,
run_as_root=ROOT_GO,
env_overrides=self._get_env())
def status(self):
statuscmd = self._get_run_actions('status', excp.StatusException)
run_result = sh.execute(*statuscmd,
run_as_root=True,
check_exit_code=False)
if not run_result:
return comp.STATUS_UNKNOWN
(sysout, stderr) = run_result
combined = (str(sysout) + str(stderr)).lower()
if combined.find("running") != -1:
return comp.STATUS_STARTED
elif combined.find("stop") != -1 or \
combined.find('unrecognized') != -1:
return comp.STATUS_STOPPED
else:
return comp.STATUS_UNKNOWN
def download(self):
dirsmade = list()
if sh.isdir(self.store_where):
LOG.info("Updating using git: located at %r" % (self.store_where))
cmd = list(self.distro.get_command('git', 'checkout'))
cmd += [GIT_MASTER_BRANCH]
sh.execute(*cmd, cwd=self.store_where)
cmd = self.distro.get_command('git', 'pull')
sh.execute(*cmd, cwd=self.store_where)
else:
LOG.info("Downloading using git: %r to %r" % (self.uri, self.store_where))
dirsmade.extend(sh.mkdirslist(self.store_where))
cmd = list(self.distro.get_command('git', 'clone'))
cmd += [self.uri, self.store_where]
sh.execute(*cmd)
if self.branch and self.branch != GIT_MASTER_BRANCH:
LOG.info("Adjusting branch using git: %r" % (self.branch))
cmd = list(self.distro.get_command('git', 'checkout'))
cmd += [self.branch]
sh.execute(*cmd, cwd=self.store_where)
return dirsmade
def status(self):
# This has got to be the worst status output.
#
# I have ever seen (its like a weird mix json+crap)
run_result = sh.execute(
*self.distro.get_command('rabbit-mq', 'status'),
check_exit_code=False,
run_as_root=True)
if not run_result:
return comp.STATUS_UNKNOWN
(sysout, stderr) = run_result
combined = str(sysout) + str(stderr)
combined = combined.lower()
if combined.find('nodedown') != -1 or \
combined.find("unable to connect to node") != -1 or \
combined.find('unrecognized') != -1:
return comp.STATUS_STOPPED
elif combined.find('running_applications') != -1:
return comp.STATUS_STARTED
else:
return comp.STATUS_UNKNOWN
def _install_python_setups(self):
pydirs = self._get_python_directories()
if pydirs:
LOG.info("Setting up %s python directories (%s)", len(pydirs),
pydirs)
for (name, wkdir) in pydirs.items():
working_dir = wkdir or self.app_dir
self.tracewriter.dirs_made(*sh.mkdirslist(working_dir))
self.tracewriter.py_installed(name, working_dir)
(stdout, stderr) = sh.execute(*PY_INSTALL,
cwd=working_dir,
run_as_root=True)
py_trace_name = "%s-%s" % (tr.PY_TRACE, name)
py_writer = tr.TraceWriter(
tr.trace_fn(self.trace_dir, py_trace_name))
# Format or json encoding isn't really needed here since this is
# more just for information output/lookup if desired.
py_writer.trace("CMD", " ".join(PY_INSTALL))
py_writer.trace("STDOUT", stdout)
py_writer.trace("STDERR", stderr)
self.tracewriter.file_touched(py_writer.filename())
def execute_template(*cmds, **kargs):
params_replacements = kargs.pop('params', None)
ignore_missing = kargs.pop('ignore_missing', False)
cmd_results = list()
for cmdinfo in cmds:
cmd_to_run_templ = cmdinfo["cmd"]
cmd_to_run = param_replace_list(cmd_to_run_templ, params_replacements,
ignore_missing)
stdin_templ = cmdinfo.get('stdin')
stdin = None
if stdin_templ:
stdin_full = param_replace_list(stdin_templ, params_replacements,
ignore_missing)
stdin = joinlinesep(*stdin_full)
exec_result = sh.execute(*cmd_to_run,
run_as_root=cmdinfo.get('run_as_root', False),
process_input=stdin,
ignore_exit_code=cmdinfo.get(
'ignore_failure', False),
**kargs)
cmd_results.append(exec_result)
return cmd_results
def post_uninstall(self):
sh.execute(*RSYSLOG_SERVICE_RESTART, run_as_root=True)
sh.execute(*RSYNC_SERVICE_RESTART, run_as_root=True)
def _execute_apt(self, cmd, **kargs):
full_cmd = APT_GET + cmd
return sh.execute(*full_cmd, run_as_root=True,
check_exit_code=True,
env_overrides=ENV_ADDITIONS,
**kargs)
def _execute_yum(self, cmd, **kargs):
full_cmd = YUM_CMD + cmd
return sh.execute(*full_cmd,
run_as_root=True,
check_exit_code=True,
**kargs)
def _sync_db(self):
# Initialize the horizon database (it stores sessions and notices shown to users).
# The user system is external (keystone).
LOG.info("Initializing the horizon database.")
sh.execute(*DB_SYNC_CMD, cwd=self.app_dir)
def restart(self):
swift_restart_cmd = [sh.joinpths(self.bin_dir, SWIFT_INIT)
] + ['all', 'restart']
sh.execute(*swift_restart_cmd, run_as_root=True)
