def __init__(self, pool_count, pool_member_count, bigip, node_names,
node_addresses, node_selflinks, *args, **kwargs):
""" Object initialization.
@param pool_count: The number of ADC pools to create.
@param pool_member_count: The number of members per ADC pool to
create.
@param bigip: BIG-IP device, as returned by MachineIdResolver.
@param node_names: List of Node Names to use to link up with
the pool members.
@param node_addresses: List of Node IP Addresses to use to link
up with the pool members.
@param node_selflinks: List of Node Selflinks to use to link up
with the pool members.
"""
super(CreateAdcPoolObjects, self).__init__(*args, **kwargs)
self.pool_count = pool_count
self.pool_member_count = pool_member_count
self.bigip = bigip
self.object_counter = 0
self.context = ContextHelper(__name__)
self.cfgifc = self.context.get_config()
self.node_names = node_names
self.node_addresses = node_addresses
self.node_selflinks = node_selflinks
self.ip_gen = ipv4_address_generator()
def __init__(self, sshifc, data, mode, root=None):
super(CoreCollector,
self).__init__(name='CoreCollector@%s' % sshifc.address)
self.sshifc = sshifc
self.data = data
self.mode = mode
self.root = root
self.context = ContextHelper(__name__)
self.session = self.context.get_config().get_session()
def __init__(self, obj_type='Object', parent_id='name', *args, **kwargs):
"""
Arguments are not necessary, but can help communicate information about the object at a glance.
@param obj_type: Type of the object for which the name is being generated. e.g. 'Pool'
@param parent_id: Unique identifier of the parent object, e.g. machineId, IP address, etc.
@return: generated name
"""
super(GenerateObjectName, self).__init__(*args, **kwargs)
self.obj_type = obj_type
self.parent_id = parent_id
self.context = ContextHelper(__name__)
self.session = self.context.get_config().get_session().name
def __init__(self, handle, type=None):
#self.handle = handle
self.handle = 0
self.type = type
context = ContextHelper()
self.cfgifc = context.get_config()
rr = self.cfgifc.get_ranges()
self.pools = self.cfgifc.get_respools()
self.value_to_item = {}
for device in self.cfgifc.get_devices(KIND_TMOS_BIGIP):
#f5ite/bigip.1/mgmt/ip
self._handle_vars['f5ite/{}.{}/mgmt/ip'.format(
*device.alias.split('-'))] = device.address
def __init__(self, node_count, bigip, *args, **kwargs):
""" Object initialization.
@param node_count: The number of ADC nodes to create.
@param bigip: BIG-IP device, as returned by MachineIdResolver.
"""
super(CreateAdcNodeObjects, self).__init__(*args, **kwargs)
self.node_count = node_count
self.bigip = bigip
self.object_counter = 0
self.context = ContextHelper(__name__)
self.cfgifc = self.context.get_config()
self.ip_gen = ipv4_address_generator()
def reset_all(self):
group = RCMD.device.DEFAULT_ALLBIGIQS_GROUP
for device in [self.default] + self.peers:
with SSHInterface(device=device) as sshifc:
LOG.info('Wiping storage on {0}'.format(device))
SCMD.ssh.generic(SCMD.bigiq.ha.HA_WIPE_COMMAND, ifc=sshifc)
with EmapiInterface(device=device, auth=AUTH.BASIC) as rstifc:
RCMD.system.wait_restjavad([self.default] + self.peers, ifc=rstifc)
# For IPv6 runs where localhost will get reset to IPv4.
for device in [self.default] + self.peers:
with EmapiInterface(device=device, auth=AUTH.BASIC) as rstifc:
resp = rstifc.api.get(DeviceResolver.DEVICES_URI % group)
selfip_expect = device.get_discover_address()
selfips_actual = [x.address for x in resp['items']]
if selfip_expect not in selfips_actual:
LOG.info(
"selfip mismatch. Setting {0}".format(selfip_expect))
self_addr = IPAddress(selfip_expect)
payload = NetworkDiscover()
payload.discoveryAddress = self_addr.format(ipv6_full)
rstifc.api.put(NetworkDiscover.URI, payload=payload)
DeviceResolver.wait(rstifc.api, group)
# For BZ workarounds..
bigips = []
context = ContextHelper()
default_bigiq = context.get_icontrol(device=self.default).version
session = context.get_config().get_session().name
for device in context.get_config().get_devices():
v = context.get_icontrol(device=device).version
if v.product.is_bigip and v >= 'bigip 11.3.0':
bigips.append(device)
if default_bigiq > 'bigiq 4.3.0' and default_bigiq < 'bigiq 4.5.0':
with EmapiInterface(device=self.default,
auth=AUTH.BASIC) as rstifc:
RCMD.device.clean_dg_certs(bigips, ifc=rstifc)
with EmapiInterface(device=self.default,
auth=AUTH.BASIC) as rstifc:
RCMD.system.bz_help1([self.default] + self.peers, ifc=rstifc)
if default_bigiq > 'bigiq 4.3.0' and default_bigiq < 'bigiq 4.5.0':
with SSHInterface(device=self.default) as sshifc:
SCMD.bigiq.ha.wait_ha_peer(self.peers,
session=session,
ifc=sshifc)
def configure(self, options, noseconfig):
""" Call the super and then validate and call the relevant parser for
the configuration file passed in """
super(Cores, self).configure(options, noseconfig)
self.data = ContextHelper().set_container(PLUGIN_NAME)
self.enabled = not (noseconfig.options.with_qkview.upper()
== QKVIEW.NEVER)
# There's really no point in collecting just quickviews without other logs
# For now, disable this plugin if --no-logcollect is present.
self.enabled = self.enabled and not (noseconfig.options.no_logcollect)
self.data.cores = {}
self.blocked_contexts = {}
def __init__(self, vip_count, bigip, pool_names, pool_selflinks, *args,
**kwargs):
""" Object initialization.
@param vip_count: The number of ADC VIPs to create.
@param bigip: BIG-IP device, as returned by MachineIdResolver.
@param pool_names: Names of the Pools previously created.
@param pool_selflinks: List of Pool Selflinks to use to link up
with the VIPs.
"""
super(AdcVipObjectsCreate, self).__init__(*args, **kwargs)
self.vip_count = vip_count
self.bigip = bigip
self.object_counter = 0
self.context = ContextHelper(__name__)
self.cfgifc = self.context.get_config()
self.pool_names = pool_names
self.pool_selflinks = pool_selflinks
self.ip_gen = ipv4_address_generator()
def setup(self):
super(HAPromoteStage, self).setup()
LOG.info('Promotion stage for: %s', self.default)
self.default.specs.default = False
self.peer.specs.default = True
LOG.info("old default = %s", self.default)
LOG.info("new default = %s", self.peer)
# if this is active/standby, promote, otherwise, not needed.
if self.ha_passive:
# Prepare command to send to promote
payload = Options()
payload.command = 'SET_PRIMARY'
LOG.info("Picking up the list of peers from the new primary")
context = ContextHelper(__name__)
rest = context.get_icontrol_rest(device=self.peer).api
resp = rest.get(DeviceResolver.DEVICES_URI %
DEFAULT_ALLBIGIQS_GROUP)
# Look for the machine id of the peer to promote
for item in resp['items']:
if item.address == self.peer.get_discover_address():
payload.machineId = item.machineId
LOG.info("Promoting peer to primary from peer")
rest.post(FailoverState.URI, payload=payload)
# wait for restjavad to go down...
wait(lambda: rest.get(DeviceResolver.DEVICES_URI %
DEFAULT_ALLBIGIQS_GROUP)['items'],
negated=True,
progress_cb=lambda ret:
'Waiting for restjavad on {0} to go down.'.format(self.default
))
# wait for it to come back up
RCMD.system.wait_restjavad([self.peer])
def configure(self, options, noseconfig):
""" Call the super and then validate and call the relevant parser for
the configuration file passed in """
super(CoresStop, self).configure(options, noseconfig)
self.context = ContextHelper()
self.enabled = noseconfig.options.stop_on_core
def run_playbooks(playbook, tags=[], context=None, options=None):
"""
@param playbook: The playbook(s) to be run.
@type playbook: str or iterable
@param tags: Run only plays tagged with these (or)
@type tags: list
@param context: The nose context where the playbook(s) will be executed
@type context: instance
"""
cfgifc = ContextHelper().get_config()
LOG.debug('In run_playbooks(%s)...', playbook)
# Really not liking how variables are called constants and how there are N
# ways of assigning them.
C.DEFAULT_ROLES_PATH = [os.path.expanduser('~/.ansible/roles'),
os.path.join(HERE, 'roles')]
C.RETRY_FILES_ENABLED = False
C.DEFAULT_HASH_BEHAVIOUR = 'merge'
C.ANSIBLE_PIPELINING = True
action_loader.add_directory(os.path.join(HERE, 'action_plugins'))
lookup_loader.add_directory(os.path.join(HERE, 'lookup_plugins'))
loader = DataLoader()
inventory = InventoryManager(loader=loader, sources='/dev/null')
variable_manager = VariableManager(loader, inventory)
o = OptionsStrict(connection='smart', forks=10, become=None,
become_method=None, become_user=None, check=False,
listhosts=False, listtasks=False, listtags=False,
syntax=False, module_path=[os.path.join(HERE, 'library')],
diff=False, # tags=tags,
verbosity=1, timeout=1,
)
if options.logger_level:
display.logger_level = options.pop('logger_level')
if options:
o.update(options)
passwords = dict(vault_pass='******')
display.verbosity = o.verbosity
inventory.add_group('all')
a = inventory.groups['all']
a.set_variable(VAR_F5TEST_CONFIG, cfgifc.api)
a.set_variable('f5test_itemd', {})
if context:
tmp = nose_selector(context)
address = test_address(context)
a.set_variable('f5test_module', tmp.replace(':', '.'))
# ITE compatibility: templates can refer to metadata values (e.g. TCID)
if hasattr(context, ITE_METADATA):
a.set_variable('f5test_itemd', getattr(context, ITE_METADATA))
if address[1]:
name = address[1].rsplit('.')[-1]
a.set_variable('f5test_module_name', name)
a.set_variable('playbook_name', os.path.splitext(os.path.basename(playbook))[0])
for device in cfgifc.get_devices(KIND_ANY):
prev = a
name = ''
for sub_kind in device.kind.bits:
name += sub_kind
inventory.add_group(name)
prev.add_child_group(inventory.groups[name])
prev = inventory.groups[name]
name += '.'
fingerprint = cfgifc.get_session().get_fingerprint(hash=True)
for tag in tags:
a.set_variable(tag, True)
session = cfgifc.get_session()
a.set_variable('f5test_session', OptionsStrict(name=session.name,
name_md5=session.name_md5))
a.set_variable('f5test_respools', session.get_respool_handler().pools)
a.set_variable('f5test_utils', JinjaUtils())
a.set_variable('f5test_ranges', session.get_respool_handler().ranges)
a.set_variable('machine_fingerprint', fingerprint)
# Colon must mean something for Ansible
if device.alias != 'localhost':
inventory.add_host(device.alias, str(device.kind).replace(':', '.'))
h = inventory.get_host(device.alias)
h.set_variable('f5test_device', device)
h.set_variable('f5test_kind', device.kind)
h.set_variable('f5test_mgmt_address', device.get_address())
h.set_variable('f5test_port_https', device.ports['https'])
h.set_variable('f5test_username', device.get_admin_creds().username)
h.set_variable('f5test_password', device.get_admin_creds().password)
h.set_variable('ansible_host', device.get_discover_address())
h.set_variable('ansible_ssh_port', device.ports['ssh'])
h.set_variable('ansible_user', device.get_root_creds().username)
h.set_variable('ansible_ssh_pass', device.get_root_creds().password)
for spec, v in device.specs.get(HOST_VARS, {}).items():
h.set_variable(spec, v)
for group in device.groups:
inventory.add_group(group)
g = inventory.groups[group]
a.add_child_group(g)
g.add_host(h)
names = [playbook] if isinstance(playbook, str) else playbook
for g, v in cfgifc.api.get(GROUP_VARS, {}).items():
group = inventory.groups.get(g)
if group:
group.vars.update(v)
# Look for playbooks relative to caller's base directory
frame = inspect.stack()[1]
module = inspect.getmodule(frame[0])
here = os.path.dirname(os.path.abspath(module.__file__))
playbooks = [x if os.path.isabs(x) else os.path.join(here, FIXTURES_DIR, x)
for x in names]
executor = PlaybookExecutor(
playbooks=playbooks,
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=o,
passwords=passwords)
options = OptionsStrict(rc=-1, failed=[])
cb = MyCallback(options=options)
executor._tqm._callback_plugins.append(cb)
try:
options.rc = executor.run()
finally:
shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
# p.vips.sync()
return options
