def __init__(self, options, action):
self.options = Options(options)
self.action = action
if options.env:
venv_dir = options.env
bin_dir = os.path.join(venv_dir, 'bin')
else:
bin_dir = os.path.dirname(os.path.realpath(inspect.stack()[-1][1]))
venv_dir = os.path.dirname(bin_dir)
LOG.info('Using sandbox directory: %s', venv_dir)
params = Options()
params.display = options.display
jar_file = os.path.join(bin_dir, SELENIUM_JAR)
params.jar = "-jar %s" % jar_file
assert os.path.exists(jar_file), '%s not found' % jar_file
var_run = os.path.join(venv_dir, 'var', 'run')
var_log = os.path.join(venv_dir, 'var', 'log')
if not os.path.exists(var_run):
os.makedirs(var_run)
if not os.path.exists(var_log):
os.makedirs(var_log)
params.dirs = dict(run=var_run, log=var_log, bin=bin_dir)
params.pids = dict(xvfb='xvfb.pid',
selenium='selenium.pid',
selenium_node='selenium_node.pid',
selenium_hub='selenium_hub.pid')
params.logs = dict(xvfb='xvfb.log',
selenium='selenium.log',
selenium_node='selenium_node.log',
selenium_hub='selenium_hub.log')
if self.options.hub:
params.hub = "-hub http://%s:4444/grid/register" % self.options.hub
if not self.options.role:
self.options.role = 'node'
else:
params.hub = ''
if self.options.role:
if self.options.role == 'hub':
self.options.no_xvfb = True
if self.options.role == 'node' and not self.options.hub:
raise ValueError('--hub needs to be specified')
params.role = "-role %s" % self.options.role
else:
params.role = ''
self.params = params
super(SeleniumRC, self).__init__()
def __init__(self, options, address=None, params=None):
self.options = Options(options)
self.params = ' '.join(params or [])
self.sshparams = Options(device=self.options.device,
address=address, timeout=self.options.timeout,
username=self.options.username,
password=self.options.password)
super(Extractor, self).__init__()
def __init__(self, options, address=None, ucs_name=None):
self.options = Options(options)
self.ucs_name = ucs_name
self.sshparams = Options(device=self.options.device,
address=address, timeout=self.options.timeout,
username=self.options.username,
password=self.options.password)
super(UcsTool, self).__init__()
def __init__(self, options, address=None, filename=None):
self.options = Options(options)
self.filename = filename
self.sshparams = Options(device=self.options.device,
address=address, timeout=self.options.timeout,
username=self.options.username,
password=self.options.password,
port=self.options.port)
super(Tool, self).__init__()
def __init__(self, options, address=None, params=None):
self.options = Options(options)
self.params = params
self.icparams = Options(device=self.options.device,
address=address,
timeout=self.options.timeout,
username=self.options.username,
password=self.options.password,
port=self.options.port)
self.icparams.debug = 1 if options.verbose else 0
super(EmpyTester, self).__init__()
def __init__(self, options, address=None):
self.options = Options(options)
self.sshparams = Options(device=self.options.device,
address=address, timeout=self.options.timeout,
username=self.options.root_username,
password=self.options.root_password)
self.icparams = Options(device=self.options.device,
address=address, timeout=self.options.timeout,
username=self.options.admin_username,
password=self.options.admin_password)
super(Big3dUtil, self).__init__()
def by_em_api(self, filename, hfiso=None):
devices = []
devices.append(Options(address=self.address,
username=self.options.admin_username,
password=self.options.admin_password))
options = Options(device=self.options.em_device,
address=self.options.em_address,
admin_username=self.options.em_admin_username,
admin_password=self.options.em_admin_password,
root_username=self.options.em_root_username,
root_password=self.options.em_root_password,
essential_config=self.options.essential_config,
image=filename, hfimage=hfiso)
macro = EMInstallSoftware(devices, options)
self.has_essential_config = macro.has_essential_config
return macro.run()
def __init__(self, options, address=None, *args, **kwargs):
self.options = Options(options)
self.has_essential_config = None
self.address = address
LOG.info('Doing: %s', self.address or options.device)
super(InstallSoftware, self).__init__(*args, **kwargs)
def parse_spec(specs, alias=None):
bits = specs.split('@', 1)
groups = None
if len(bits) > 1:
groups = set(bits[1].split(','))
bits = bits[0].split(',')
if len(bits[0].split(':')) > 1:
address, port = bits[0].split(':')
else:
address, port = bits[0], DEFAULT_PORTS['https']
cred = Options()
if len(bits) == 1:
cred.common = DeviceCredential(default_username,
default_password)
device = DeviceAccess(address, {ADMIN_ROLE: cred})
elif len(bits) == 2:
cred.common = DeviceCredential(default_username, bits[1])
device = DeviceAccess(address, {ADMIN_ROLE: cred})
elif len(bits) == 3:
cred.common = DeviceCredential(bits[1], bits[2])
device = DeviceAccess(address, {ADMIN_ROLE: cred})
else:
raise ValueError('Invalid specs: %s', specs)
device.ports['https'] = port
device.set_groups(groups)
return device
def __init__(self, devices, options, *args, **kwargs):
self.devices = devices
self.options = Options(options)
self.options.setdefault('build_path', cm.ROOT_PATH)
self.has_essential_config = None
super(EMInstallSoftware, self).__init__(*args, **kwargs)
def run(self, tmp=None, task_vars=None):
if task_vars is None:
task_vars = dict()
for arg in self._task.args:
if arg not in self.VALID_ARGS:
return {"failed": True, "msg": "'%s' is not a valid option in f5_config" % arg}
result = super(ActionModule, self).run(tmp, task_vars)
result['_ansible_verbose_override'] = True
options = Options()
address = self._task.args.get('address')
if VAR_F5TEST_CONFIG in task_vars:
irack = task_vars[VAR_F5TEST_CONFIG].irack
if irack:
options.irack_address = irack.address
options.irack_username = irack.username
options.irack_apikey = irack.apikey
options.update(self._task.args)
macro = TmosConfig(address=address, specs=options)
result['output'] = macro.run()
return result
def main():
import optparse
import sys
usage = """%prog [options] <url> [url]...
Examples:
%prog https://10.11.41.73/1MB https://10.11.41.69/1MB -v
"""
formatter = optparse.TitledHelpFormatter(indent_increment=2,
max_help_position=60)
p = optparse.OptionParser(usage=usage, formatter=formatter,
version="HTTP/S Traffic Generator %s" % __version__)
p.add_option("-v", "--verbose", action="store_true",
help="Debug logging")
# p.add_option("-s", "--stats", action="store_true", default=False,
# help="Show statistics when done (default: no)")
p.add_option("-k", "--keepalive", action="store_true", default=False,
help="Reuse HTTP/1.1 connections for subsequent requests")
p.add_option("-c", "--concurrency", metavar="INTEGER",
default=1, type="int",
help="Number of parallel threads (default: 10)")
p.add_option("-n", "--requests", metavar="INTEGER",
default=10, type="int",
help="Total number of requests (default: 10)")
p.add_option("-r", "--rate", metavar="INTEGER",
default=100, type="int",
help="Maximum bandwidth in Kbytes per sec (default: 100 KB/s)")
p.add_option("-d", "--dns", metavar="ADDRESS",
default=None, type="string",
help="Use this DNS server to resolve hostnames.")
# p.add_option("-p", "--pattern", metavar="STRING",
# default="0:10", type="string",
# help="[Threads delta:Sleep]... (default: 1:300:-1:300)")
p.add_option("-t", "--timeout", metavar="SECONDS", type="float",
default=DEFAULT_TIMEOUT, help="Timeout (default: %d)" % DEFAULT_TIMEOUT)
p.add_option("-l", "--limit", metavar="SECONDS", type="int",
default=DEFAULT_LIMIT, help="Run limit (default: %d)" % DEFAULT_LIMIT)
options, args = p.parse_args()
if options.verbose:
level = logging.DEBUG
else:
level = logging.INFO
logging.getLogger('f5test').setLevel(logging.INFO)
logging.getLogger('f5test.macros').setLevel(logging.INFO)
LOG.setLevel(level)
logging.basicConfig(level=level)
if not args:
p.print_version()
p.print_help()
sys.exit(2)
cs = TrafficGen(options=Options(options), urls=args)
cs.run()
def run(self, tmp=None, task_vars=None):
if task_vars is None:
task_vars = dict()
for arg in self._task.args:
if arg not in self.VALID_ARGS:
return {"failed": True, "msg": "'%s' is not a valid option for f5_unmerge" % arg}
result = super(ActionModule, self).run(tmp, task_vars)
#result['_ansible_verbose_override'] = True
options = Options()
options.port = self._task.args.get('port')
options.username = self._task.args.get('username')
options.password = self._task.args.get('password')
options.verbose = self._task.args.get('verbose')
options.timeout = int(self._task.args.get('timeout', 60))
address = self._task.args.get('address')
filename = self._task.args.get('filename')
macro = Tool(options, address, filename)
result['output'] = macro.run()
return result
def __init__(self, options, emaddress=None, bigipaddress=None):
self.options = Options(options)
self.emparams = Options(device=self.options.emdevice,
address=emaddress, timeout=self.options.timeout,
username=self.options.em_root_username,
password=self.options.em_root_password)
self.emicparams = Options(device=self.options.emdevice,
address=emaddress, timeout=self.options.timeout,
username=self.options.em_admin_username,
password=self.options.em_admin_password)
self.bigipparams = Options(device=self.options.bigipdevice,
address=bigipaddress, timeout=self.options.timeout,
username=self.options.bigip_admin_username,
password=self.options.bigip_admin_password)
super(DeviceCloner, self).__init__()
def setUp(self):
super(SplitTestCase, self).setUp()
name = re.sub('\.phase\d+.', '\._\.', self.id())
cl = self.get_data(CHECKLIST)
cl.setdefault(name, Options())
self.c = cl[name]
if self.c._has_failed:
raise SkipTest('Test failed in preceding phase. Skipping.')
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, authorities=None, peers=None, groups=None):
self.options = Options(options)
self.authorities_spec = list(authorities or [])
self.peers_spec = list(peers or [])
self.cas = []
self.peers = []
self.groups_specs = groups or [DEFAULT_DG]
self.sync_device = None # Used only when do_config_all() is called.
super(FailoverMacro, self).__init__()
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 wait_for_conflicts():
resp = self.api.get(task.selfLink)
if (resp.status not in ('STARTED',) and
resp.currentStep in ('PENDING_CONFLICTS', 'PENDING_CHILD_CONFLICTS')):
LOG.info('Conflicts detected, setting resolution: %s' % resolution)
payload = Options(status='STARTED',
conflicts=resp.conflicts[:])
for conflict in payload.conflicts:
conflict.resolution = resolution
resp = self.api.patch(task.selfLink, payload=payload)
return resp
def __init__(self, options, method, address=None, params=None):
self.options = Options(options)
self.method = method
if isinstance(params, basestring):
self.params = []
if params.strip():
for name, value in parser(params):
self.params.append("%s=%r" % (name, value))
else:
self.params = params or []
self.icparams = Options(device=self.options.device,
address=address,
timeout=self.options.timeout,
username=self.options.username,
password=self.options.password,
port=self.options.port)
self.icparams.debug = 1 if options.verbose else 0
super(Ictester, self).__init__()
def __init__(self, options, urls):
options.setdefault('timeout', DEFAULT_TIMEOUT)
options.setdefault('limit', DEFAULT_LIMIT)
options.setdefault('concurrency', 1)
options.setdefault('rate', 100)
options.setdefault('requests', 1)
options.setdefault('keepalive', False)
self.options = Options(options)
self.urls = urls
self.stats = Options()
self.stats.requests = {}
self.stats.requests.successful = 0
self.stats.requests.failed = 0
self.stats.time = {}
self.stats.time.delta = 0
self.stats.time.req_per_sec = 0
self.stats.data = {}
self.stats.data.total = 0
super(TrafficGen, self).__init__()
def add_float_selfips(self, device, param):
# TODO: Need to put logic here to check if an IP is within a network
node_name = param.node_name
graph_name = param.graph_name
contract_name = param.contract_name
network_folder = self.find('*[@key="Network"]')
# Add external float selfip
param = Options(key="ExternalSelfIP", name="ExternalFloat",
node_name=node_name,
graph_name=graph_name,
contract_name=contract_name)
folder_params = FolderInst(param)
params = []
params.append(Options(key="Floating", name="Floating", value='YES'))
params.append(Options(key="PortLockdown", name="PortLockdown",
value='DEFAULT'))
params.append(Options(key="SelfIPAddress", name="SelfIPAddress",
value=device.specs.external.float1))
params.append(Options(key="SelfIPNetmask", name="SelfIPNetmask",
value=device.specs.external.netmask))
folder_params.add_params(params)
network_folder.append(folder_params)
# Add internal float selfip
param = Options(key="InternalSelfIP", name="InternalFloat",
node_name=node_name,
graph_name=graph_name,
contract_name=contract_name)
folder_params = FolderInst(param)
params = []
params.append(Options(key="Floating", name="Floating", value='YES'))
params.append(Options(key="PortLockdown", name="PortLockdown",
value='DEFAULT'))
params.append(Options(key="SelfIPAddress", name="SelfIPAddress",
value=device.specs.internal.float1))
params.append(Options(key="SelfIPNetmask", name="SelfIPNetmask",
value=device.specs.internal.netmask))
folder_params.add_params(params)
network_folder.append(folder_params)
def set_network_relation(self, param):
network_name = self.find('*[@key="Network"]').get('name')
param = Options(key="NetworkRelation", name="NetworkRelation",
node_name=param.node_name,
graph_name=param.graph_name,
contract_name=param.contract_name)
network_relation = FolderInst(param)
config = ET.Element('vnsCfgRelInst')
config.set('name', 'NetworkRel')
config.set('key', 'NetworkRel')
config.set('targetName', network_name)
network_relation.append(config)
self.append(network_relation)
def __init__(self, name, options=None, *args, **kwargs):
super(BridgeDomain, self).__init__('fvBD', *args, **kwargs)
o = Options(options)
if o.context:
self.set('name', name)
context = ET.Element('fvRsCtx')
context.set('tnFvCtxName', options.context)
self.append(context)
if o.subnet:
subnet = ET.Element('fvSubnet', attrib={'scope': 'private'})
subnet.set('ip', options.subnet)
self.append(subnet)
def prep(self):
super(GetDiscoveredServicesList, self).prep()
# This doesn't work in v5.5.0
#f = Options(filter="product eq 'BIG-IP' and address eq '%s'" % self.device.get_discover_address())
f = Options(filter="product eq 'BIG-IP' and deviceUri eq 'https://%s:443'" % self.device.get_discover_address())
resp = self.api.get(MachineIdResolver.URI, odata_dict=f)
items = resp['items']
for item in items:
LOG.debug("Looking for {0} EQ to {1}".format(self.device.get_discover_address(), item.address))
if self.device.get_discover_address() == item.address:
self.resp = item
break
if self.resp is None:
LOG.warning("No machineid reference found for {0}".format(self.device.get_discover_address()))
def set_connections(self, tenant_name):
attrib = Options(unicastRoute='yes', connType='external', adjType='L2')
graph_name = self.get('name')
node_name = self.find('vnsAbsNode').get('name')
provider_name = self.find('vnsAbsTermNodeProv').get('name')
consumer_name = self.find('vnsAbsTermNodeCon').get('name')
connectors = self.findall('*vnsAbsFuncConn')
for connector in connectors:
if 'mConn-external' in connector.find('vnsRsMConnAtt').get('tDn'):
external_connector_name = connector.get('name')
elif 'mConn-internal' in connector.find('vnsRsMConnAtt').get(
'tDn'):
internal_connector_name = connector.get('name')
# Add external connection
external_connection = ET.Element('vnsAbsConnection', attrib=attrib)
external_connection.set('name', 'C1')
tdn = 'uni/tn-%s/AbsGraph-%s/AbsNode-%s/AbsFConn-%s' % (
tenant_name, graph_name, node_name, external_connector_name)
connection_to_connector = ET.Element('vnsRsAbsConnectionConns')
connection_to_connector.set('tDn', tdn)
external_connection.append(connection_to_connector)
tdn = 'uni/tn-%s/AbsGraph-%s/AbsTermNodeCon-%s/AbsTConn' % (
tenant_name, graph_name, consumer_name)
connection_to_connector = ET.Element('vnsRsAbsConnectionConns')
connection_to_connector.set('tDn', tdn)
external_connection.append(connection_to_connector)
# Add internal connection
internal_connection = ET.Element('vnsAbsConnection', attrib=attrib)
internal_connection.set('name', 'C2')
tdn = 'uni/tn-%s/AbsGraph-%s/AbsNode-%s/AbsFConn-%s' % (
tenant_name, graph_name, node_name, internal_connector_name)
connection_to_connector = ET.Element('vnsRsAbsConnectionConns')
connection_to_connector.set('tDn', tdn)
internal_connection.append(connection_to_connector)
tdn = 'uni/tn-%s/AbsGraph-%s/AbsTermNodeProv-%s/AbsTConn' % (
tenant_name, graph_name, provider_name)
connection_to_connector = ET.Element('vnsRsAbsConnectionConns')
connection_to_connector.set('tDn', tdn)
internal_connection.append(connection_to_connector)
self.append(external_connection)
self.append(internal_connection)
def __init__(self, address, specs, *args, **kwargs):
self.specs = specs
options = Options(ssh_port=int(specs.get('ssh_port', 22)),
ssl_port=int(specs.get('ssl_port', 443)),
partitions=int(specs.get('partitions', DEFAULT_PARTITIONS)),
node_start=specs.get('node_start', DEFAULT_NODE_START),
node_count=int(specs.get('node_count', DEFAULT_NODES)),
pool_count=int(specs.get('pool_count', DEFAULT_POOLS)),
pool_members=int(specs.get('pool_members', DEFAULT_MEMBERS)),
vip_start=specs.get('vip_start'),
vip_count=int(specs.get('vip_count', DEFAULT_VIPS)),
username=specs.get('username'),
password=specs.get('password'),
license=specs.get('license'),
provision=specs.get('provision'),
clean=specs.get('clean', False),
timeout=specs.get('timeout'),
verify=specs.get('verify'),
verbose=specs.get('verbose'),
hostname=specs.get('hostname'),
mgmtip=specs.get('mgmtip'),
mgmtgw=specs.get('mgmtgw'),
selfip_internal=specs.get('selfip_internal'),
selfip_external=specs.get('selfip_external'),
vlan_internal_name=specs.get('vlan_internal_name',
'internal'),
vlan_external_name=specs.get('vlan_external_name',
'external'),
vlan_internal=specs.get('vlan_internal'),
vlan_external=specs.get('vlan_external'),
irack_address=specs.get('irack_address'),
irack_username=specs.get('irack_username'),
irack_apikey=specs.get('irack_apikey'),
no_irack=specs.get('no_irack', False),
force_license=specs.get('force_license', False),
license_only=specs.get('license_only', False)
)
super(TmosConfig, self).__init__(options, address, *args, **kwargs)
import os
import socket
import sys
import random
from f5test.interfaces.rest.emapi import EmapiInterface
from f5test.interfaces.rest.core import AUTH
from f5test.interfaces.rest.emapi.objects.bigip import AuthzRoles
from f5test.interfaces.rest.emapi.objects.shared import Echo
__version__ = '1.0'
LOG = logging.getLogger(__name__)
F5TEST_SUBJECT = Options(CN='NotSet',
emailAddress='*****@*****.**',
OU='Enterprise Manager',
O='F5 Networks',
L='Seattle',
ST='Washington',
C='US'
)
MAXINT = 4294967295
DEFAULT_TIMEOUT = 300
ROOTCA_CRT = """-----BEGIN CERTIFICATE-----
MIICxTCCAi6gAwIBAgIBATANBgkqhkiG9w0BAQUFADCBnTEWMBQGA1UEAxMNRjUg
RU0gVGVzdGluZzEcMBoGCSqGSIb3DQEJARYNZW10ZXN0QGY1LmNvbTEbMBkGA1UE
CxMSRW50ZXJwcmlzZSBNYW5hZ2VyMRQwEgYDVQQKEwtGNSBOZXR3b3JrczEQMA4G
A1UEBxMHU2VhdHRsZTETMBEGA1UECBMKV2FzaGluZ3RvbjELMAkGA1UEBhMCVVMw
HhcNMTAwMzA1MDIyMjAxWhcNMjAwMzAyMDIyMjAxWjCBnTEWMBQGA1UEAxMNRjUg
RU0gVGVzdGluZzEcMBoGCSqGSIb3DQEJARYNZW10ZXN0QGY1LmNvbTEbMBkGA1UE
CxMSRW50ZXJwcmlzZSBNYW5hZ2VyMRQwEgYDVQQKEwtGNSBOZXR3b3JrczEQMA4G
def __init__(self, options, ifc=None):
self.options = Options(options)
self.ifc = ifc
self._ourifc = False
super(LicenseGenerator, self).__init__()
from f5test.interfaces.selenium import SeleniumInterface
from f5test.interfaces.selenium.driver import By
import getpass
import logging
import os
import pprint
__version__ = '0.3'
LOG = logging.getLogger(__name__)
DEFAULT_USER = os.environ.get('LOGNAME')
BANNED_FEATURES = set(('Appliance Mode', 'TrustedIP Subscription',
'IP Intelligence Subscription', 'IPI Subscription',
'App Mode', '1 Gbps - 3 Gbps Upgrade'))
MAP = Options()
MAP.eval = {}
MAP.eval.bigip = {}
MAP.eval.bigip['VE'] = 'F5-BIG-LTM-VE-1G-LIC'
MAP.eval.bigip['VE3'] = 'F5-BIG-LTM-VE-3G-LIC'
MAP.eval.bigip['AWS'] = 'F5-BIG-LTM-AWS-1G-LIC'
#MAP.eval.bigip['POOL'] = 'F5-BIG-LTMPL2-1G-100-LIC'
MAP.eval.bigip['1600'] = 'F5-BIG-LTM-1600-4G-LIC'
MAP.eval.bigip['2000'] = 'F5-BIG-LTM-2000S-LIC'
MAP.eval.bigip['2200'] = 'F5-BIG-LTM-2200S-LIC'
MAP.eval.bigip['3600'] = 'F5-BIG-LTM-3600-4G-LIC'
MAP.eval.bigip['3900'] = 'F5-BIG-LTM-3900-8G-LIC'
MAP.eval.bigip['4000'] = 'F5-BIG-LTM-4200V-LIC'
MAP.eval.bigip['5000'] = 'F5-BIG-LTM-5200V-LIC'
MAP.eval.bigip['6400'] = 'F5-BIG-LTM-6400-LIC'
MAP.eval.bigip['6800'] = 'F5-BIG-LTM-6800-LIC'
