def __init__(self, options, address=None, address_iq=None, *args, **kwargs):
self.context = O()
self.options = O(options)
self.options.setifnone('timeout', DEFAULT_TIMEOUT)
self.options.setifnone('skip_ping', False)
if self.options.device:
self.device = ConfigInterface().get_device(options.device)
self.address = self.device.address
else:
self.device = None
self.address = address
self.options.setifnone('username', DEFAULT_ROOT_USERNAME)
self.options.setifnone('password', DEFAULT_ROOT_PASSWORD)
self.options.setifnone('admin_username', DEFAULT_ADMIN_USERNAME)
self.options.setifnone('admin_password', DEFAULT_ADMIN_PASSWORD)
if self.options.device_biq:
self.device_biq = ConfigInterface().get_device(options.device_biq)
self.address_biq = self.device_biq.address
else:
self.device_biq = None
self.address_biq = address_iq
self.options.setifnone('username_iq', DEFAULT_ROOT_USERNAME)
self.options.setifnone('password_iq', DEFAULT_ROOT_PASSWORD)
super(ScaleCheck, self).__init__(*args, **kwargs)
def run(self):
configifc = ConfigInterface()
config = configifc.open()
if not config.paths:
LOG.info('Test runner sanity skipped.')
return
assert config.paths.build, 'CM Build path is not set in the config'
assert config.paths.logs, 'Logs path is not set in the config'
sample = os.path.join(config.paths.build, 'bigip')
if not os.path.exists(sample):
raise StageError("%s does not exist" % sample)
sample = config.paths.get('logs')
sample = os.path.expanduser(sample)
sample = os.path.expandvars(sample)
if not os.access(sample, os.W_OK):
raise StageError("Logs dir: %s is not writable" % sample)
stats = os.statvfs(sample)
if not (stats.f_bsize * stats.f_bavail) / 1024**2 > 100:
raise StageError("Logs dir: %s has not enough space left" % sample)
LOG.info('Test runner sanity check passed!')
def __init__(self, options, address=None):
self.options = Options(options)
self.address = ConfigInterface().get_device_address(options.device) \
if self.options.device else address
if self.options.alias is None:
self.options.alias = []
super(WebCert, self).__init__()
def __init__(self, options, address=None):
self.options = Options(options)
if self.options.device:
self.address = ConfigInterface().get_device_address(options.device)
else:
self.address = address
LOG.info('Doing: %s', self.address)
super(KeySwap, self).__init__()
def __init__(self, options, address=None, *args, **kwargs):
self.context = O()
self.options = O(options)
self.options.setifnone('node_count', DEFAULT_NODES)
self.options.setifnone('pool_count', DEFAULT_POOLS)
self.options.setifnone('pool_members', DEFAULT_MEMBERS)
self.options.setifnone('vip_count', DEFAULT_VIPS)
self.options.setifnone('node_start', DEFAULT_NODE_START)
self.options.setifnone('partitions', DEFAULT_PARTITIONS)
self.options.setifnone('timeout', DEFAULT_TIMEOUT)
if self.options.device:
self.device = ConfigInterface().get_device(options.device)
self.address = self.device.address
else:
self.device = None
self.address = address
self.options.setifnone('username', DEFAULT_ROOT_USERNAME)
self.options.setifnone('password', DEFAULT_ROOT_PASSWORD)
# can.* shortcuts to check for certain features based on the version
self.can = O()
def can_tmsh(v):
return (v.product.is_bigip and v >= 'bigip 11.0.0' or
v.product.is_em and v >= 'em 2.0.0' or
v.product.is_bigiq)
self.can.tmsh = can_tmsh
def can_provision(v):
return (v.product.is_bigip and v >= 'bigip 10.0.1' or
v.product.is_em and v >= 'em 2.0.0' or
v.product.is_bigiq)
self.can.provision = can_provision
def can_lvm(sshifc):
return not sshifc('/usr/lib/install/lvmtest').status
self.can.lvm = can_lvm
self.has = O()
def has_asm(s):
return bool(SCMD.tmsh.get_provision(ifc=s).asm)
self.has.asm = has_asm
def has_lvm(s):
return not s('/usr/lib/install/lvmtest').status
self.has.lvm = has_lvm
super(ConfigPlacer, self).__init__(*args, **kwargs)
def set_defaults(self):
if self.options.device:
device = ConfigInterface().get_device(self.options.device)
self.address = device.get_address()
self.options.admin_username = device.get_admin_creds().username
self.options.admin_password = device.get_admin_creds().password
self.options.root_username = device.get_root_creds().username
self.options.root_password = device.get_root_creds().password
self.options.ssl_port = device.ports.get('https', 443)
self.options.ssh_port = device.ports.get('ssh', 22)
self.options.setdefault('admin_username', ADMIN_USERNAME)
self.options.setdefault('admin_password', ADMIN_PASSWORD)
self.options.setdefault('root_username', ROOT_USERNAME)
self.options.setdefault('root_password', ROOT_PASSWORD)
self.options.setdefault('build_path', cm.ROOT_PATH)
def process_stages(stages, section, context, stop_on_error=True):
if not stages:
LOG.debug('No stages found.')
return
# Replicate the "_enabled" flag.
carry_flag(stages)
# Build the stage map with *ALL* defined stage classes in this file.
stages_map = {}
for value in list(globals().values()):
if inspect.isclass(value) and issubclass(value,
Stage) and value != Stage:
stages_map[value.name] = value
# Focus only on our stages section
for key in section.split('.'):
stages = stages.get(key, Options())
# Sort stages by priority attribute and stage name.
stages = sorted(iter(stages.items()),
key=lambda x: (isinstance(x[1], dict) and x[1].get(
PRIORITY_KEY, DEFAULT_PRIORITY), x[0]))
config = ConfigInterface().config
# Group stages of the same type. The we spin up one thread per stage in a
# group and wait for threads within a group to finish.
sg_dict = {}
sg_list = []
for name, specs in stages:
if not specs or name.startswith('_'):
continue
assert TYPE_KEY in specs, "%s stage is invalid. No type specified." % name
specs = Options(specs)
key = specs.get(GROUP_KEY, "{0}-{1}".format(name, specs[TYPE_KEY]))
group = sg_dict.get(key)
if not group:
sg_dict[key] = []
sg_list.append(sg_dict[key])
sg_dict[key].append((name, specs))
LOG.debug("sg_list: %s", sg_list)
for stages in sg_list:
q = Queue()
pool = []
for stage in stages:
description, specs = stage
if not specs or not to_bool(specs.get(ENABLE_KEY)):
continue
LOG.info("Processing stage: %s", description)
# items() reverts <Options> to a simple <dict>
specs = Options(specs)
if not stages_map.get(specs[TYPE_KEY]):
LOG.warning("Stage '%s' (%s) not defined.", description,
specs[TYPE_KEY])
continue
stage_class = stages_map[specs[TYPE_KEY]]
parameters = specs.get(PARAMETERS_KEY) or Options()
parameters._context = context
devices = expand_devices(specs)
if devices is None:
stage_class(parameters).run()
elif devices == []:
LOG.error("Stage %s requires devices but found none" %
description)
else:
if not devices:
LOG.warning('No devices found for stage %s', description)
if specs.get('shuffle', False):
random.shuffle(devices)
for device in devices:
stage = stage_class(device, parameters)
name = '%s :: %s' % (
description, device.alias) if device else description
t = MacroThread(stage, q, name=name)
t.start()
pool.append(t)
if not stage_class.parallelizable or not specs.get(
'parallelizable', True):
t.join()
# Cap the number parallel threads
if len(pool) >= specs.get('threads', MAX_THREADS):
list(map(lambda x: x.join(), pool))
pool[:] = []
LOG.debug('Waiting for threads...')
for t in pool:
t.join()
if not q.empty():
stages = []
while not q.empty():
ret = q.get(block=False)
thread, exc_info = ret.popitem()
stages.append((thread, exc_info))
LOG.error('Exception while "%s"', thread.getName())
for line in traceback.format_exception(*exc_info):
LOG.error(line.strip())
if stop_on_error:
raise StageError(stages)