def load_config(self, context, ixia_config_file_name):
self.ixl.load_config(ixia_config_file_name)
self.ixl.repository.test.set_attributes(enableForceOwnership=False)
config_elements = self.ixl.repository.get_elements()
reservation_id = context.reservation.reservation_id
my_api = CloudShellSessionContext(context).get_api()
reservation_ports = {}
for port in get_reservation_resources(my_api, context.reservation.reservation_id,
'Generic Traffic Generator Port',
'PerfectStorm Chassis Shell 2G.GenericTrafficGeneratorPort',
'Ixia Chassis Shell 2G.GenericTrafficGeneratorPort'):
reservation_ports[get_family_attribute(my_api, port, 'Logical Name').Value.strip()] = port
perfectstorms = [ps.FullAddress for ps in get_reservation_resources(my_api, reservation_id,
'PerfectStorm Chassis Shell 2G')]
for name, element in config_elements.items():
if name in reservation_ports:
address = get_address(reservation_ports[name])
ip_address, module, port = address.split('/')
if ip_address in perfectstorms:
address = '{}/{}/{}'.format(ip_address, module, int(port) + 1)
self.logger.debug('Logical Port {} will be reserved on Physical location {}'.format(name, address))
element.reserve(address)
else:
self.logger.error('Configuration element "{}" not found in reservation elements {}'.
format(element, reservation_ports.keys()))
raise Exception('Configuration element "{}" not found in reservation elements {}'.
format(element, reservation_ports.keys()))
self.logger.info("Port Reservation Completed")
def load_config(self, context, stc_config_file_name):
"""
:param stc_config_file_name: full path to STC configuration file (tcc or xml)
"""
self.stc.load_config(stc_config_file_name)
config_ports = self.stc.project.get_ports()
reservation_id = context.reservation.reservation_id
my_api = CloudShellSessionContext(context).get_api()
reservation_ports = {}
for port in get_reservation_resources(
my_api, reservation_id, 'Generic Traffic Generator Port',
'PerfectStorm Chassis Shell 2G.GenericTrafficGeneratorPort',
'STC Chassis Shell 2G.GenericTrafficGeneratorPort'):
reservation_ports[get_family_attribute(
my_api, port, 'Logical Name').Value.strip()] = port
for name, port in config_ports.items():
if name in reservation_ports:
address = get_address(reservation_ports[name])
self.logger.debug(
'Logical Port {} will be reserved on Physical location {}'.
format(name, address))
port.reserve(address, force=True, wait_for_up=False)
else:
self.logger.error(
'Configuration port "{}" not found in reservation ports {}'
.format(port, reservation_ports.keys()))
raise Exception(
'Configuration port "{}" not found in reservation ports {}'
.format(port, reservation_ports.keys()))
self.logger.info("Port Reservation Completed")
def connect():
""" Create Xena manager object and connect to chassis. """
global xm
global chassis
global port1
global port2
global session
global sandbox_id
session = CloudShellAPISession('localhost', 'admin', 'admin', 'Global')
if 'SANDBOX_ID' in environ:
sandbox_id = environ['SANDBOX_ID']
else:
context = create_command_context(session, ['xena 2g/Module6/Port0', 'xena 2g/Module6/Port1'],
'Xena Controller', {})
sandbox_id = context.reservation.reservation_id
reserved_port1, reserved_port2 = get_reservation_resources(session, sandbox_id,
'Xena Chassis Shell 2G.GenericTrafficGeneratorPort')
port1 = get_address(reserved_port1)
port2 = get_address(reserved_port2)
chassis = port1.split('/')[0]
logger = logging.getLogger('log')
logger.setLevel('INFO')
logger.addHandler(logging.StreamHandler(sys.stdout))
xm = init_xena(logger, owner)
xm.session.add_chassis(chassis)
def load_config(self, context, xena_configs_folder):
reservation_id = context.reservation.reservation_id
my_api = CloudShellSessionContext(context).get_api()
reservation_ports = get_reservation_resources(
my_api, reservation_id,
'Xena Chassis Shell 2G.GenericTrafficGeneratorPort')
for reserved_port in reservation_ports:
config = get_family_attribute(my_api, reserved_port,
'Logical Name').Value.strip()
address = get_address(reserved_port)
self.logger.debug(
'Configuration {} will be loaded on Physical location {}'.
format(config, address))
chassis = my_api.GetResourceDetails(
reserved_port.Name.split('/')[0])
encripted_password = my_api.GetAttributeValue(
chassis.Name, 'Xena Chassis Shell 2G.Password').Value
password = CloudShellSessionContext(
context).get_api().DecryptPassword(encripted_password).Value
tcp_port = my_api.GetAttributeValue(
chassis.Name,
'Xena Chassis Shell 2G.Controller TCP Port').Value
if not tcp_port:
tcp_port = '22611'
ip, module, port = address.split('/')
self.xm.session.add_chassis(ip, int(tcp_port), password)
xena_port = XenaPort(self.xm.session.chassis_list[ip],
'{}/{}'.format(module, port))
xena_port.reserve(force=True)
xena_port.load_config(
path.join(xena_configs_folder, config) + '.xpc')
def test_load_config(self):
reservation_ports = get_reservation_resources(self.session, self.context.reservation.reservation_id,
'Generic Traffic Generator Port',
'PerfectStorm Chassis Shell 2G.GenericTrafficGeneratorPort',
'Ixia Chassis Shell 2G.GenericTrafficGeneratorPort')
set_family_attribute(self.session, reservation_ports[0], 'Logical Name', 'Traffic1@Network1')
set_family_attribute(self.session, reservation_ports[1], 'Logical Name', 'Traffic2@Network2')
self.driver.load_config(self.context, 'E:/workspace/python/PyIxLoad/ixload/test/configs/test_config_840.rxf')
def _load_config(self, config):
reservation_ports = get_reservation_resources(self.session, self.context.reservation.reservation_id,
'Generic Traffic Generator Port',
'PerfectStorm Chassis Shell 2G.GenericTrafficGeneratorPort',
'Ixia Chassis Shell 2G.GenericTrafficGeneratorPort')
set_family_attribute(self.session, reservation_ports[0], 'Logical Name', 'Traffic1@Network1')
set_family_attribute(self.session, reservation_ports[1], 'Logical Name', 'Traffic2@Network2')
self.session.ExecuteCommand(self.context.reservation.reservation_id, 'IxLoad Controller', 'Service',
'load_config', [InputNameValue('ixl_config_file_name', config)])
def test_load_config(self):
self.reservation_ports = get_reservation_resources(
self.session, self.context.reservation.reservation_id,
'Xena Chassis Shell 2G.GenericTrafficGeneratorPort')
set_family_attribute(self.session, self.reservation_ports[0],
'Logical Name', 'test_config')
set_family_attribute(self.session, self.reservation_ports[1],
'Logical Name', 'test_config')
self.driver.load_config(self.context, os.path.dirname(__file__))
def test_load_config(self):
self.reservation_ports = get_reservation_resources(
self.session, self.context.reservation.reservation_id,
'Xena Chassis Shell 2G.GenericTrafficGeneratorPort')
set_family_attribute(self.session, self.reservation_ports[0],
'Logical Name', 'test_config')
set_family_attribute(self.session, self.reservation_ports[1],
'Logical Name', 'test_config')
self._exec_command(
'load_config',
InputNameValue('xena_configs_folder', path.dirname(__file__)))
def _load_config(self, config, ports):
reservation_ports = get_reservation_resources(
self.session, self.context.reservation.reservation_id,
'Traffic Generator Test IP')
for index, name in ports.items():
set_family_attribute(self.session, reservation_ports[index],
'Logical Name', name)
self.session.ExecuteCommand(self.context.reservation.reservation_id,
'IxChariot Controller', 'Service',
'load_config',
[InputNameValue('ixc_config', config)])
def test_load_config(self):
reservation_ports = get_reservation_resources(
self.session, self.context.reservation.reservation_id,
'Generic Traffic Generator Port',
'PerfectStorm Chassis Shell 2G.GenericTrafficGeneratorPort',
'Ixia Chassis Shell 2G.GenericTrafficGeneratorPort')
set_family_attribute(self.session, reservation_ports[0],
'Logical Name', 'Port 1')
set_family_attribute(self.session, reservation_ports[1],
'Logical Name', 'Port 2')
self.driver.load_config(self.context,
path.join(path.dirname(__file__), config))
def _load_config(self, config):
reservation_ports = get_reservation_resources(
self.session, self.context.reservation.reservation_id,
'Generic Traffic Generator Port',
'STC Chassis Shell 2G.GenericTrafficGeneratorPort')
set_family_attribute(self.session, reservation_ports[0],
'Logical Name', 'Client 1')
set_family_attribute(self.session, reservation_ports[1],
'Logical Name', 'Server 1')
self.session.ExecuteCommand(
self.context.reservation.reservation_id, 'Avalanche Controller',
'Service', 'load_config',
[InputNameValue('avl_config_file_name', config)])
def _load_config(self, config_name, scenario):
config_file = path.join(path.dirname(__file__),
'{}.bbp'.format(config_name))
reservation_ports = get_reservation_resources(
self.session, self.context.reservation.reservation_id,
'ByteBlower Chassis Shell 2G.GenericTrafficGeneratorPort',
'ByteBlower Chassis Shell 2G.ByteBlowerEndPoint')
set_family_attribute(self.session, reservation_ports[0],
'Logical Name', 'WAN_PORT')
set_family_attribute(self.session, reservation_ports[1],
'Logical Name', 'PORT_45')
set_family_attribute(self.session, reservation_ports[2],
'Logical Name', 'PC1x2G')
self.driver.load_config(self.context, config_file, scenario)
def load_config(self, context, avl_config_file_name, avl_test_name):
self.avl.load_config(avl_config_file_name)
if avl_test_name:
self.test = self.avl.project.tests[avl_test_name]
else:
self.test = self.avl.project.tests.values()[0]
reservation_id = context.reservation.reservation_id
my_api = CloudShellSessionContext(context).get_api()
reservation_ports = {}
reservation_ports['client'] = {}
reservation_ports['server'] = {}
for port in get_reservation_resources(
my_api, reservation_id, 'Generic Traffic Generator Port',
'PerfectStorm Chassis Shell 2G.GenericTrafficGeneratorPort',
'STC Chassis Shell 2G.GenericTrafficGeneratorPort'):
side, index = get_family_attribute(
my_api, port, 'Logical Name').Value.strip().split(' ')
reservation_ports[side.lower()][int(index)] = port
locations = []
for index, association in self.test.client.associations.items():
if index in reservation_ports['client']:
address = get_address(reservation_ports['client'][index])
self.logger.debug(
'client association {} will be reserved on Physical location {}'
.format(index, address))
locations.append(address)
association.interface.set_port(address)
else:
self._association_not_found('client', index,
reservation_ports['client'])
for index, association in self.test.server.associations.items():
if index in reservation_ports['server']:
address = get_address(reservation_ports['server'][index])
self.logger.debug(
'server association {} will be reserved on Physical location {}'
.format(index, address))
locations.append(address)
association.interface.set_port(address)
else:
self._association_not_found('server', index,
reservation_ports['server'])
self._reserve_ports(*locations)
self.logger.info('Port Reservation Completed')
def test_run_sequencer(self):
reservation_ports = get_reservation_resources(
self.session, self.context.reservation.reservation_id,
'Generic Traffic Generator Port',
'PerfectStorm Chassis Shell 2G.GenericTrafficGeneratorPort',
'STC Chassis Shell 2G.GenericTrafficGeneratorPort')
set_family_attribute(self.session, reservation_ports[0],
'Logical Name', 'Port 1')
set_family_attribute(self.session, reservation_ports[1],
'Logical Name', 'Port 2')
self.driver.load_config(
self.context,
path.join(path.dirname(__file__), 'test_sequencer.tcc'))
self.driver.sequencer_command(self.context, 'Start')
self.driver.sequencer_command(self.context, 'Wait')
def negative_tests(self):
test_config = os.path.dirname(__file__).replace('\\', '/') + '/test_config.rxf'
reservation_ports = get_reservation_resources(self.session, self.context.reservation.reservation_id,
'Generic Traffic Generator Port'
'PerfectStorm Chassis Shell 2G.GenericTrafficGeneratorPort',
'Ixia Chassis Shell 2G.GenericTrafficGeneratorPort')
assert(len(reservation_ports) == 2)
set_family_attribute(self.session, reservation_ports[0], 'Logical Name', 'Traffic1@Network1')
set_family_attribute(self.session, reservation_ports[1], 'Logical Name', '')
self.assertRaises(Exception, self.driver.load_config, self.context, test_config)
set_family_attribute(self.session, reservation_ports[1], 'Logical Name', 'Traffic1@Network1')
self.assertRaises(Exception, self.driver.load_config, self.context, test_config)
set_family_attribute(self.session, reservation_ports[1], 'Logical Name', 'Port x')
self.assertRaises(Exception, self.driver.load_config, self.context, test_config)
# cleanup
set_family_attribute(self.session, reservation_ports[1], 'Logical Name', 'Traffic2@Network2')
def _load_config(self, config_name, scenario):
config_file = path.join(path.dirname(__file__),
'{}.bbp'.format(config_name))
reservation_ports = get_reservation_resources(
self.session, self.context.reservation.reservation_id,
'ByteBlower Chassis Shell 2G.GenericTrafficGeneratorPort',
'ByteBlower Chassis Shell 2G.ByteBlowerEndPoint')
set_family_attribute(self.session, reservation_ports[0],
'Logical Name', 'WAN_PORT')
set_family_attribute(self.session, reservation_ports[1],
'Logical Name', 'PORT_45')
set_family_attribute(self.session, reservation_ports[2],
'Logical Name', 'PC1x2G')
self.session.ExecuteCommand(
self.context.reservation.reservation_id, namespace, 'Service',
'load_config', [
InputNameValue('config_file_location', config_file),
InputNameValue('scenario', scenario)
])
def load_config(self, context, ixia_config_file_name):
self.ixn.new_config()
self.ixn.load_config(ixia_config_file_name)
config_ports = self.ixn.root.get_children('vport')
for port in config_ports:
port.release()
reservation_id = context.reservation.reservation_id
my_api = CloudShellSessionContext(context).get_api()
reservation_ports = {}
for port in get_reservation_resources(
my_api, reservation_id, 'Generic Traffic Generator Port',
'PerfectStorm Chassis Shell 2G.GenericTrafficGeneratorPort',
'Ixia Chassis Shell 2G.GenericTrafficGeneratorPort'):
reservation_ports[get_family_attribute(
my_api, port, 'Logical Name').Value.strip()] = port
for port in config_ports:
name = port.obj_name()
if name in reservation_ports:
address = get_address(reservation_ports[name])
self.logger.debug(
'Logical Port {} will be reserved on Physical location {}'.
format(name, address))
port.reserve(address, wait_for_up=False)
else:
self.logger.error(
'Configuration port "{}" not found in reservation ports {}'
.format(port, reservation_ports.keys()))
raise Exception(
'Configuration port "{}" not found in reservation ports {}'
.format(port, reservation_ports.keys()))
for port in config_ports:
port.wait_for_states(40, 'up')
self.logger.info("Port Reservation Completed")
def load_config(self, context, bbl_config_file_name, scenario):
self.project = bbl_config_file_name.replace('\\', '/')
self.scenario = scenario
return
reservation_id = context.reservation.reservation_id
my_api = CloudShellSessionContext(context).get_api()
# todo: geat ports from bbl.
config_ports = ['WAN_PORT', 'PORT_45', 'PC1x2G']
reservation_ports = {}
for port in get_reservation_resources(
my_api, reservation_id,
'ByteBlower Chassis Shell 2G.GenericTrafficGeneratorPort',
'ByteBlower Chassis Shell 2G.ByteBlowerEndPoint'):
reservation_ports[get_family_attribute(
my_api, port, 'Logical Name').Value.strip()] = port
for port in config_ports:
name = port.obj_name()
if name in reservation_ports:
address = get_address(reservation_ports[name])
self.logger.debug(
'Logical Port {} will be reserved on Physical location {}'.
format(name, address))
port.reserve(address, wait_for_up=False)
else:
self.logger.error(
'Configuration port "{}" not found in reservation ports {}'
.format(port, reservation_ports.keys()))
raise Exception(
'Configuration port "{}" not found in reservation ports {}'
.format(port, reservation_ports.keys()))
self.logger.info("Port Reservation Completed")
def negative_tests(self):
reservation_ports = get_reservation_resources(
self.session, self.context.reservation.reservation_id,
'Generic Traffic Generator Port',
'PerfectStorm Chassis Shell 2G.GenericTrafficGeneratorPort',
'Ixia Chassis Shell 2G.GenericTrafficGeneratorPort')
assert (len(reservation_ports) == 2)
set_family_attribute(self.session, reservation_ports[0],
'Logical Name', 'Port 1')
set_family_attribute(self.session, reservation_ports[1],
'Logical Name', '')
self.assertRaises(Exception, self.driver.load_config, self.context,
path.join(path.dirname(__file__), config))
set_family_attribute(self.session, reservation_ports[1],
'Logical Name', 'Port 1')
self.assertRaises(Exception, self.driver.load_config, self.context,
path.join(path.dirname(__file__), config))
set_family_attribute(self.session, reservation_ports[1],
'Logical Name', 'Port x')
self.assertRaises(Exception, self.driver.load_config, self.context,
path.join(path.dirname(__file__), config))
# cleanup
set_family_attribute(self.session, reservation_ports[1],
'Logical Name', 'Port 2')
def load_config(self, context, ixc_config):
self.session = self.connection.createSession('ixchariot')
self.session.startSession()
self.session.loadConfiguration(ixc_config)
reservation_id = context.reservation.reservation_id
my_api = CloudShellSessionContext(context).get_api()
src_resources = {}
dst_resources = {}
for ep in get_reservation_resources(my_api, reservation_id,
'Traffic Generator Test IP'):
logical_name = my_api.GetAttributeValue(
ep.Name, 'Logical Name').Value.strip()
for end in logical_name.split():
flow_end = end.split('-')[0].lower()
flow_index = int(end.split('-')[1]) if len(
end.split('-')) == 2 else 1
if flow_end in ['src', 'source']:
src_resources.setdefault(flow_index, []).append(ep.Name)
elif flow_end in ['dst', 'destination']:
dst_resources.setdefault(flow_index, []).append(ep.Name)
else:
raise Exception(
'Invalid logical name {} - {} not in [src, source, dst, destination]'
.format(logical_name, flow_end))
flows_url = self._get_flows_url()
flows = self.session.httpGet(flows_url)
ids = [f.id for f in flows]
if sorted(src_resources) != sorted(ids):
raise Exception(
'Src resource ids {} do not match flow IDs {}'.format(
src_resources, ids))
if sorted(dst_resources) != sorted(ids):
raise Exception(
'Dst resource ids {} do not match flow IDs {}'.format(
dst_resources, ids))
for id_ in ids:
network_url = '{}/{}/network/'.format(flows_url, id_)
self.session.httpDelete(network_url + 'sourceEndpoints')
self.session.httpDelete(network_url + 'destinationEndpoints')
for id_ in src_resources:
for src_ep in src_resources[id_]:
ep = self.ixchariotapi.createEndpoint(
src_ep.split('/')[2],
src_ep.split('/')[1])
self.session.httpPost('{}/{}/network/sourceEndpoints'.format(
flows_url, id_),
data=ep)
for id_ in dst_resources:
for src_ep in dst_resources[id_]:
ep = self.ixchariotapi.createEndpoint(
src_ep.split('/')[2],
src_ep.split('/')[1])
self.session.httpPost(
'{}/{}/network/destinationEndpoints'.format(
flows_url, id_),
data=ep)
# In case of multiple eps delay is required to make sure configuration completed (based on trial and error).
time.sleep(4)
self.logger.info("Load Configuration Completed")
return self.session.sessionId
