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'