def validate_load_for_delete(load):
if not load:
raise exception.InventoryException(_("Load not found"))
valid_delete_states = [
constants.IMPORTED_LOAD_STATE, constants.ERROR_LOAD_STATE,
constants.DELETING_LOAD_STATE
]
if load.state not in valid_delete_states:
raise exception.InventoryException(
_("Only a load in an imported or error state can be deleted"))
def get_local_controller_hostname():
try:
local_hostname = socket.gethostname()
except Exception as e:
raise exception.InventoryException(
_("Failed to get the local hostname: %s") % str(e))
return local_hostname
def get_mate_controller_hostname(hostname=None):
if not hostname:
try:
hostname = socket.gethostname()
except Exception as e:
raise exception.InventoryException(
_("Failed to get the local hostname: %s") % str(e))
if hostname == k_host.CONTROLLER_0_HOSTNAME:
mate_hostname = k_host.CONTROLLER_1_HOSTNAME
elif hostname == k_host.CONTROLLER_1_HOSTNAME:
mate_hostname = k_host.CONTROLLER_0_HOSTNAME
else:
raise exception.InventoryException(
_("Unknown local hostname: %s)") % hostname)
return mate_hostname
def get_imported_load(loads):
imported_load = None
for db_load in loads:
if db_load.state == constants.IMPORTED_LOAD_STATE:
imported_load = db_load
if imported_load is None:
raise exception.InventoryException(_("No imported load found"))
return imported_load
def get_active_load(loads):
active_load = None
for db_load in loads:
if db_load.state == constants.ACTIVE_LOAD_STATE:
active_load = db_load
if active_load is None:
raise exception.InventoryException(_("No active load found"))
return active_load
def _get_primary_cgtsclient(self):
# import the module in the function that uses it
# as the cgtsclient is only installed on the controllers
from cgtsclient.v1 import client as cgts_client
# get region one name from platform.conf
region1_name = get_region_name('region_1_name')
if region1_name is None:
region1_name = 'RegionOne'
auth_ref = self._get_keystoneclient().auth_ref
if auth_ref is None:
raise exception.InventoryException(
_("Unable to get auth ref from keystone client"))
auth_token = auth_ref.service_catalog.get_token()
endpoint = (auth_ref.service_catalog.
get_endpoints(service_type='platform',
endpoint_type='internal',
region_name=region1_name))
endpoint = endpoint['platform'][0]
version = 1
return cgts_client.Client(version=version,
endpoint=endpoint['url'],
auth_url=self.auth_url,
token=auth_token['id'])
def validate_loads_for_import(loads):
for db_load in loads:
if db_load.state == constants.IMPORTED_LOAD_STATE:
raise exception.InventoryException(_("Imported load exists."))
def execute(*cmd, **kwargs):
"""Helper method to execute command with optional retry.
If you add a run_as_root=True command, don't forget to add the
corresponding filter to etc/inventory/rootwrap.d !
:param cmd: Passed to subprocess.Popen.
:param process_input: Send to opened process.
:param check_exit_code: Single bool, int, or list of allowed exit
codes. Defaults to [0]. Raise
exception.ProcessExecutionError unless
program exits with one of these code.
:param delay_on_retry: True | False. Defaults to True. If set to
True, wait a short amount of time
before retrying.
:param attempts: How many times to retry cmd.
:param run_as_root: True | False. Defaults to False. If set to True,
the command is run with rootwrap.
:raises exception.InventoryException: on receiving unknown arguments
:raises exception.ProcessExecutionError:
:returns: a tuple, (stdout, stderr) from the spawned process, or None if
the command fails.
"""
process_input = kwargs.pop('process_input', None)
check_exit_code = kwargs.pop('check_exit_code', [0])
ignore_exit_code = False
if isinstance(check_exit_code, bool):
ignore_exit_code = not check_exit_code
check_exit_code = [0]
elif isinstance(check_exit_code, int):
check_exit_code = [check_exit_code]
delay_on_retry = kwargs.pop('delay_on_retry', True)
attempts = kwargs.pop('attempts', 1)
run_as_root = kwargs.pop('run_as_root', False)
shell = kwargs.pop('shell', False)
if len(kwargs):
raise exception.InventoryException(
_('Got unknown keyword args to utils.execute: %r') % kwargs)
if run_as_root and os.geteuid() != 0:
cmd = (['sudo', 'inventory-rootwrap', CONF.rootwrap_config] +
list(cmd))
cmd = map(str, cmd)
while attempts > 0:
attempts -= 1
try:
LOG.debug(_('Running cmd (subprocess): %s'), ' '.join(cmd))
_PIPE = subprocess.PIPE # pylint: disable=E1101
if os.name == 'nt':
preexec_fn = None
close_fds = False
else:
preexec_fn = _subprocess_setup
close_fds = True
obj = subprocess.Popen(cmd,
stdin=_PIPE,
stdout=_PIPE,
stderr=_PIPE,
close_fds=close_fds,
preexec_fn=preexec_fn,
shell=shell)
result = None
if process_input is not None:
result = obj.communicate(process_input)
else:
result = obj.communicate()
obj.stdin.close() # pylint: disable=E1101
_returncode = obj.returncode # pylint: disable=E1101
LOG.debug(_('Result was %s') % _returncode)
if not ignore_exit_code and _returncode not in check_exit_code:
(stdout, stderr) = result
raise exception.ProcessExecutionError(exit_code=_returncode,
stdout=stdout,
stderr=stderr,
cmd=' '.join(cmd))
return result
except exception.ProcessExecutionError:
if not attempts:
raise
else:
LOG.debug(_('%r failed. Retrying.'), cmd)
if delay_on_retry:
greenthread.sleep(random.randint(20, 200) / 100.0)
finally:
# NOTE(termie): this appears to be necessary to let the subprocess
# call clean something up in between calls, without
# it two execute calls in a row hangs the second one
greenthread.sleep(0)