def _refresh(self):
from ixnetwork.IxnQuery import IxnQuery
self._multivalue = IxnQuery(self._ixnhttp, self._multivalue_href) \
.node('multivalue', properties=['availablePatterns', 'count', 'format', 'pattern', 'source']) \
.node('singleValue', properties=['*']) \
.node('counter', properties=['*']) \
.node('alternate', properties=['*']) \
.node('random', properties=['*']) \
.node('repeatableRandom', properties=['*']) \
.node('repeatableRandomRange', properties=['*']) \
.node('valueList', properties=['*']) \
.node('string', properties=['*']) \
.node('custom', properties=['*']) \
.node('nest', properties=['*']) \
.node('increment', properties=['*']) \
.go()
def release_ports(ixnhttp):
query_vport = IxnQuery(ixnhttp, '/').node('vport',
properties=['name']).go()
for vport in query_vport.vport:
vport_name = vport.attributes.name.value
print('\nReleasing port name:', vport_name)
print('\t', vport.href)
vport.operations.releaseport({'arg1': [vport.href]})
def verify_port_state(port_state, timeout=70):
"""Verify that all vport objects are at a certain state
:param: port_state: up | down | busy | versionMismatch
:param: timeout: timeout in seconds
:raises: Exception: if after timeout seconds all vport objects state property is not reached
"""
start = int(time.time())
# setup the state query
state_query = IxnQuery(ixnhttp, '/') \
.node('vport', properties=['state'], where=[{'property': 'state', 'regex': '^(?!.*?up).*'}])
while len(state_query.go().vport) > 0:
if int(time.time()) - start > timeout:
raise Exception(
'all vport objects did not reach state up in %s seconds' %
(timeout))
time.sleep(2)
def status(self):
"""Get the status of the mappings"""
query_result = IxnQuery(self._ixnhttp, '/').node(
'vport', properties=['name', 'connectionStatus']).go()
status = []
for vport in query_result.vport:
if vport.href in self._payload['arg3']:
status.append('%s: %s' %
(vport.attributes.name.value,
vport.attributes.connectionStatus.value))
return status
def hosts(self):
emulation_hosts = []
for key in self.session_ids.keys():
class_name = None
for piece in key.split('/')[::-1]:
if piece.isdigit() is False:
class_name = piece
break
emulation_host = IxnQuery(self._ixnhttp, key).node(class_name, properties=['*']).go()
emulation_hosts.append(emulation_host)
return emulation_hosts
def __init__(self, ixnhttp, query_result):
self._ixnhttp = ixnhttp
from ixnetwork.IxnQuery import IxnQuery
setattr(self, 'id',
query_result.id if hasattr(query_result, 'id') else None)
setattr(self, 'href', query_result.href)
setattr(self, 'attributes', lambda: None)
setattr(self, 'operations', lambda: None)
setattr(self, 'query', IxnQuery(self._ixnhttp, query_result.href))
self._meta_data = self._ixnhttp._get_meta_data(query_result.href)
self._add_attributes(query_result)
self._add_operations(query_result)
self._process_child_instances(query_result)
def _get_topology(self, vport_name):
vport_query_result = IxnQuery(self._ixnhttp, '/') \
.node('vport', properties=['name'], where=[{'property': 'name', 'regex': vport_name}]) \
.go()
if len(vport_query_result.vport) == 1:
vport_href = vport_query_result.vport[0].href
topology_query_result = self._ixnhttp.root.query.clear() \
.node('topology', properties=['name', 'vports', 'portCount'], where=[{'property': 'vports', 'regex': vport_href}]) \
.node('deviceGroup', properties=['multiplier']) \
.go()
if len(topology_query_result.topology) == 1:
topology = topology_query_result.topology[0]
self._port_offset = topology.attributes.vports.value.index(vport_href) + 1
self._port_count = topology.attributes.portCount.value
self._sessions_per_port = topology.deviceGroup[0].attributes.multiplier.value
return topology
else:
raise Exception('virtual port with name of %s does not exist in any topology' % vport_name)
else:
raise Exception('virtual port with name of %s does not exist' % vport_name)
def map(self, vport_name, chassis_ip, card_id, port_id):
"""Map an existing virtual port to a chassis/card/port"""
if vport_name is None:
href = self._ixnhttp.root.create_vport().href
else:
query_result = IxnQuery(self._ixnhttp,
'/').node('vport',
properties=['name'],
where=[{
'property': 'name',
'regex': vport_name
}]).go()
if len(query_result.vport) != 1:
raise Exception('vport %s does not exist on the server' %
vport_name)
href = query_result.vport[0].href
self._payload['arg1'].append({
'arg1': chassis_ip,
'arg2': card_id,
'arg3': port_id
})
self._payload['arg3'].append(href)
return self
# get an IxnHttp instance using the samples Config object
ixnhttp = Config.get_IxnHttp_instance(use_gui=True)
# management objects
config_mgmt = IxnConfigManagement(ixnhttp)
# clear the current configuration
config_mgmt.new_config()
# create two virtual ports using the low level http interface
ixnhttp.post('/vport', [{'name': 'eth-1'}, {'name': 'eth-2'}])
# get all the virtual ports using the query
query_result = IxnQuery(ixnhttp, '/') \
.node('vport', properties=['*']) \
.go()
# using the returned query_result print the vport names
print('All virtual port names')
for vport in query_result.vport:
print(vport.attributes.name.value)
# get the eth-2 virtual port using the query
query_result = IxnQuery(ixnhttp, '/') \
.node('vport', properties=['*'], where=[{'property': 'name', 'regex': 'eth-2'}]) \
.node('^(l1Config|ethernet|ethernetvm|atm)$', properties=['*']) \
.go()
# using the returned query_result print the vport names
print('One virtual port name')
'/topology/deviceGroup/ethernet/pppoxserver',
'/topology/deviceGroup/ethernet/ptp',
'/topology/deviceGroup/ethernet/lacp',
'/topology/deviceGroup/ethernet/staticLag',
]
config_mgmt = IxnConfigManagement(ixnhttp)
for class_path in class_paths:
config_mgmt.new_config()
href = ixnhttp.root.href
for class_path_piece in class_path.split('/')[1:]:
try:
metadata = ixnhttp.help('%s/%s' % (href, class_path_piece))
href = process_node(ixnhttp, href, metadata, classes)
except Exception as e:
print(e.message)
query_result = IxnQuery(ixnhttp,
'/topology/1').node('.*', properties=['*']).go()
process_query_result(ixnhttp, query_result, classes)
filename = '%s/../ixnetwork/IxnEmulationHosts.py' % os.path.dirname(
os.path.realpath(__file__))
with open(filename, 'w') as fid:
fid.write('from ixnetwork.IxnEmulationHost import IxnEmulationHost\n\n')
keys = classes.keys()
keys.sort()
for key in keys:
fid.write(classes[key])
fid.flush()
def root(self):
if self.current_session is not None and self._root is None:
self._root = IxnQuery(self, '/').go()
return self._root
class IxnMultivalue(object):
"""An internal class that exposes a SDM multivalue using SDM meta data.
"""
SINGLE_VALUE = 'singleValue'
COUNTER = 'counter'
ALTERNATE = 'alternate'
RANDOM = 'random'
REPEATABLE_RANDOM = 'repeatableRandom'
REPEATABLE_RANDOM_RANGE = 'repeatableRandomRange'
VALUE_LIST = 'valueList'
STRING = 'string'
CUSTOM = 'custom'
NEST = 'nest'
def __init__(self, ixnhttp, multivalue_href):
self._ixnhttp = ixnhttp
self._multivalue_href = multivalue_href
self._multivalue = None
def _refresh(self):
from ixnetwork.IxnQuery import IxnQuery
self._multivalue = IxnQuery(self._ixnhttp, self._multivalue_href) \
.node('multivalue', properties=['availablePatterns', 'count', 'format', 'pattern', 'source']) \
.node('singleValue', properties=['*']) \
.node('counter', properties=['*']) \
.node('alternate', properties=['*']) \
.node('random', properties=['*']) \
.node('repeatableRandom', properties=['*']) \
.node('repeatableRandomRange', properties=['*']) \
.node('valueList', properties=['*']) \
.node('string', properties=['*']) \
.node('custom', properties=['*']) \
.node('nest', properties=['*']) \
.node('increment', properties=['*']) \
.go()
@property
def href(self):
"""Get the href of the multivalue
:returns: str:
"""
return self._multivalue_href
@property
def pattern(self):
"""Get the current pattern of the multivalue
:returns: str: singleValue|counter|alternate|random|repeatableRandom|repeatableRandomRange|valueList|string|custom
"""
if self._multivalue is None:
self._refresh()
return self._multivalue.attributes.pattern.value
@property
def available_patterns(self):
"""Get all available patterns for the multivalue
:returns: list[str]: a list of one or more of singleValue|counter|alternate|random|repeatableRandom|repeatableRandomRange|valueList|string|custom
"""
if self._multivalue is None:
self._refresh()
return self._multivalue.attributes.availablePatterns.value
@property
def format(self):
"""Get the format of values that can be get/set in this object
:returns: str: the format of the value
"""
if self._multivalue is None:
self._refresh()
return self._multivalue.attributes.format.value
@property
def count(self):
"""Get the total number of values represented by this multivalue
:returns: number: the count of values
"""
if self._multivalue is None:
self._refresh()
return self._multivalue.attributes.count.value
@property
def source(self):
"""Get the source node/attribute of this multivalue
:returns: str: source node/attribute
"""
if self._multivalue is None:
self._refresh()
return self._multivalue.attributes.source.value
def get_values(self, start_index=0, count=None):
"""Get values represented by this multivalue
start_index: 0 based offset in the list of values
count: default is all values
:returns: list[str]: a list of string values represented by this multivalue
"""
if self._multivalue is None:
self._refresh()
if count is None:
count = self.count
if count > self.count:
count = self.count
values = self._multivalue.operations.getvalues({
'arg1': self._multivalue_href,
'arg2': start_index,
'arg3': count
})
return values.result
def dump(self):
"""Print a summary of this multivalue object"""
if self._multivalue is None:
self._refresh()
print('source:\t%s' % self.source)
print('\tpatt:\t%s available:%s' %
(self.pattern, "|".join(self.available_patterns)))
print('\tcount:\t%s' % self.count)
print('\tformat:\t%s' % self.format)
print('\tvalues:\t%s...' % ' '.join(self.get_values(0, 3)))
@property
def single_value(self):
"""Get the single value
:returns: str or None: A valid singlevalue or None if the pattern is not singleValue
"""
if self._multivalue.attributes.pattern.value == IxnMultivalue.SINGLE_VALUE:
return self._multivalue.singleValue.attributes.value.value
return None
@single_value.setter
def single_value(self, value):
"""Changes the pattern to singleValue and sets the value"""
if self._multivalue is None:
self._refresh()
if self.pattern == IxnMultivalue.SINGLE_VALUE:
self._multivalue.singleValue.attributes.value.value = value
self._multivalue.singleValue.update()
else:
self._multivalue.create_child('singleValue',
payload={'value': value})
self._refresh()
@property
def alternate(self):
"""Get the alternate value
:returns: str or None: A valid alternate value or None if the pattern is not alatenate
"""
if self._multivalue.attributes.pattern.value == IxnMultivalue.ALTERNATE:
return self._multivalue.alternate.attributes.value.value
return None
@alternate.setter
def alternate(self, value):
"""Changes the pattern to alternate and sets the value"""
if self._multivalue is None:
self._refresh()
if self.pattern == IxnMultivalue.ALTERNATE:
self._multivalue.alternate.attributes.value.value = value
self._multivalue.alternate.update()
else:
self._multivalue.create_alternate(payload={'value': value})
self._refresh()
def get_counter(self):
"""Get the counter variables
:returns: counter object or None: A valid counter object or None if the pattern is not counter
"""
if self._multivalue.pattern.value == IxnMultivalue.COUNTER:
return self._multivalue.counter
return None
def set_counter(self, start=None, step=None, direction=None):
"""Changes the pattern to counter and sets the values"""
if self._multivalue is None:
self._refresh()
if self.pattern != IxnMultivalue.COUNTER:
self._multivalue.create_child('counter')
self._refresh()
if start is not None:
self._multivalue.counter.attributes.start.value = start
if step is not None:
self._multivalue.counter.attributes.step.value = step
if direction is not None:
self._multivalue.counter.attributes.direction.value = direction
self._multivalue.counter.update()
self._refresh()
def _refresh_check(self, expected_pattern):
if self._multivalue is None:
self._refresh()
if self.pattern is not 'counter':
self._multivalue.create_child('counter')
self._refresh()
@property
def value_list(self):
"""Get the value list
:returns: str or None: A valid singlevalue or None if the pattern is not singleValue
"""
if self._multivalue.attributes.pattern.value == IxnMultivalue.VALUE_LIST:
return self._multivalue.valueList.attributes.values.value
return None
@value_list.setter
def value_list(self, values):
if self._multivalue is None:
self._refresh()
if self.pattern != IxnMultivalue.VALUE_LIST:
self._multivalue.create_child('valueList')
self._refresh()
self._multivalue.valueList.attributes.values.value = values
self._multivalue.valueList.update()
def set_custom(self, start_value=None, step_value=None):
""" Change the pattern to Custom using only start and step """
if self._multivalue is None:
self._refresh()
if self.pattern != IxnMultivalue.CUSTOM:
payload = {}
if start_value is not None:
payload['start'] = start_value
if step_value is not None:
payload['step'] = step_value
custom_object = self._multivalue.create_child(IxnMultivalue.CUSTOM,
payload=payload)
else:
if start_value is not None:
self._multivalue.custom.start.value = start_value
if step_value is not None:
self._multivalue.custom.step.value = step_value
custom_object = self._multivalue.custom.update()
self._multivalue_href = custom_object.href
self._refresh()
return self
@property
def get_increment(self):
return self._multivalue.increment
def set_custom_increment(self, value=None, count=None, href=None):
"""
This will work on top of custom or increment node
It will modify value and count when call with href
"""
self._refresh()
if href is None:
if len(self.get_increment) >= 1:
self._multivalue_href = self.get_increment[0].href
self._refresh()
if value is not None:
self._multivalue.attributes.value.value = value
if count is not None:
self._multivalue.attributes.count.value = count
self._multivalue.update()
else:
payload = {}
if value is not None:
payload['value'] = value
if count is not None:
payload['count'] = count
increment_object = self._multivalue.create_child(
'increment', payload=payload)
self._multivalue_href = increment_object.href
else:
self._multivalue_href = href
self._refresh()
if value is not None:
self._multivalue.attributes.value.value = value
if count is not None:
self._multivalue.attributes.count.value = count
self._multivalue.update()
self._refresh()
return self
def set_custom_basic(self, start_value, step_value, repeat_each_value,
sequence_length):
""" This is a high level utility function to create custom basic pattern"""
# set default value to 1 if value <0
repeat_each_value = repeat_each_value if repeat_each_value <= 0 else 1
sequence_length = sequence_length if sequence_length <= 0 else 1
null_value = self.set_custom(
start_value=start_value)._multivalue.attributes.step.value
self.set_custom_increment(step_value,
sequence_length).set_custom_increment(
null_value, repeat_each_value)
def set_random(self):
"""Set the multivalue pattern to random."""
if self._multivalue is None:
self._refresh()
if self.pattern != IxnMultivalue.RANDOM:
self._multivalue.create_child('random')
self._refresh()
def set_repeatable_random(self,
count=None,
fixed=None,
mask=None,
seed=None):
"""Changes the pattern to repetableRandom and sets the values"""
if self._multivalue is None:
self._refresh()
if self.pattern != IxnMultivalue.REPEATABLE_RANDOM:
payload = {}
if count is not None:
payload['count'] = count
if fixed is not None:
payload['fixed'] = fixed
if mask is not None:
payload['mask'] = mask
if seed is not None:
payload['seed'] = seed
self._multivalue.create_child(IxnMultivalue.REPEATABLE_RANDOM,
payload=payload)
self._refresh()
else:
if count is not None:
self._multivalue.repeatableRandom.attributes.count.value = count
if fixed is not None:
self._multivalue.repeatableRandom.attributes.fixed.value = fixed
if mask is not None:
self._multivalue.repeatableRandom.attributes.mask.value = mask
if seed is not None:
self._multivalue.repeatableRandom.attributes.seed.value = seed
self._multivalue.repeatableRandom.update()
self._refresh()
def get_repeatable_random(self):
"""Get the repeatableRandom variables
:returns: A valid repeatableRandom object or None if the pattern is not repeatableRandom
"""
if self._multivalue.pattern.value == IxnMultivalue.REPEATABLE_RANDOM:
return self._multivalue.repeatableRandom
return None
def set_repeatable_random_range(self,
min=None,
max=None,
step=None,
seed=None):
"""Changes the pattern to repeatableRandomRange and sets the values"""
if self._multivalue is None:
self._refresh()
if self.pattern != IxnMultivalue.REPEATABLE_RANDOM_RANGE:
payload = {}
if min is not None:
payload['min'] = min
if max is not None:
payload['max'] = max
if step is not None:
payload['step'] = step
if seed is not None:
payload['seed'] = seed
self._multivalue.create_child(
IxnMultivalue.REPEATABLE_RANDOM_RANGE, payload=payload)
self._refresh()
else:
if min is not None:
self._multivalue.repeatableRandomRange.attributes.min.value = min
if max is not None:
self._multivalue.repeatableRandomRange.attributes.max.value = max
if step is not None:
self._multivalue.repeatableRandomRange.attributes.step.value = step
if seed is not None:
self._multivalue.repeatableRandomRange.attributes.seed.value = seed
self._multivalue.repeatableRandomRange.update()
self._refresh()
def get_repeatable_random_range(self):
"""Get the repeatableRandomRange variables
:returns: A valid repeatableRandomRange object or None if the pattern is not repeatableRandomRange
"""
if self._multivalue.pattern.value == IxnMultivalue.REPEATABLE_RANDOM_RANGE:
return self._multivalue.repeatableRandomRange
return None
try:
if api_server_type in ['windows', 'windowsConnectionMgr']:
ixnhttp = IxnHttp(api_server_ip, api_server_rest_port, secure=False)
sessions = ixnhttp.sessions()
ixnhttp.current_session = sessions[0]
if api_server_type == 'linux':
ixnhttp = IxnHttp(api_server_ip, api_server_rest_port, secure=True)
ixnhttp.auth(username, password)
ixnhttp.create_session()
# CONFIG LICENSE SERVER
# New session needs to know where the license server is located.
query_license = IxnQuery(ixnhttp, '/') \
.node('globals') \
.node('licensing', properties=['licensingServers', 'tier', 'mode']) \
.go()
print('\nConfigure license server:', license_server_ip, license_mode,
license_tier)
query_license.globals.licensing.attributes.licensingServers.value = [
license_server_ip
]
query_license.globals.licensing.attributes.mode.value = license_mode
query_license.globals.licensing.attributes.tier.value = license_tier
query_license.globals.licensing.update()
if enable_trace: ixnhttp.trace = True
# LOAD CONFIG FILE
config_mgmt = IxnConfigManagement(ixnhttp)
if os.path.exists(config_file) is False:
import os, sys, time, traceback
from ixnetwork.IxnHttp import IxnHttp
from ixnetwork.IxnConfigManagement import IxnConfigManagement
from ixnetwork.IxnPortManagement import IxnPortManagement
from ixnetwork.IxnStatManagement import IxnStatManagement
from ixnetwork.IxnQuery import IxnQuery
# load a configuration in the gui, assign ports, start protocols, start traffic
# then run this script to create a custom layer23TrafficFlow view
ixnhttp = IxnHttp('10.200.22.48', rest_port=12345)
ixnhttp.current_session = ixnhttp.sessions()[0]
# get the statistics object
query_result = IxnQuery(ixnhttp, '/').node('statistics').go()
# create a view
custom_view_caption = "A Custom View"
payload = {
'caption': custom_view_caption,
'type': 'layer23TrafficFlow',
'visible': True
}
custom_view = query_result.statistics.create_child('view', payload=payload)
# create layer23TrafficFlowFilter payload
layer23_traffic_flow_filter = IxnQuery(ixnhttp, custom_view.href) \
.node('layer23TrafficFlowFilter', properties=['*']) \
.go().layer23TrafficFlowFilter
# add port filter names to the payload
ixnhttp = IxnHttp(api_server_ip, api_server_rest_port)
if enable_trace: ixnhttp.trace = True
if api_server_type in ['windows', 'windowsConnectionMgr']:
sessions = ixnhttp.sessions()
ixnhttp.current_session = sessions[0]
if api_server_type == 'linux':
print('\nCreating new session on Linux API server:', api_server_ip)
ixnhttp.auth(username, password)
ixnhttp.create_session()
# CONFIG LICENSE SERVER
# New session needs to know where the license server is located.
query_license = IxnQuery(ixnhttp, '/') \
.node('globals') \
.node('licensing', properties=['licensingServers', 'tier', 'mode']) \
.go()
print('\nConfigure license server:', license_server_ip, license_mode,
license_tier)
query_license.globals.licensing.attributes.licensingServers.value = [
license_server_ip
]
query_license.globals.licensing.attributes.mode.value = license_mode
query_license.globals.licensing.attributes.tier.value = license_tier
query_license.globals.licensing.update()
# CREATE A BLANK CONFIG
config_mgmt = IxnConfigManagement(ixnhttp)
config_mgmt.new_config()
# CONNECT CHASSIS:
def find(self, host_names, vport_name, parent_host, match_properties):
self.session_ids = {}
self._port_offset = None
self._port_count = None
self._sessions_per_port = None
start_host = None
if vport_name is not None:
start_host = self._get_topology(vport_name)
elif parent_host is not None:
start_host = IxnQuery(self._ixnhttp, list(parent_host.session_ids)[0]).go()
parent_session_ids = parent_host.session_ids
else:
raise Exception('A vport_name or parent_host is required')
start_host.query.clear()
host_name_to_get = host_names.pop()
properties = ['count', 'name']
for key in match_properties.keys():
if key not in properties:
properties.append(key)
start_host.query.node(host_name_to_get, properties=properties)
for host_name in host_names:
if not host_name in start_host.href:
start_host.query.node(host_name)
host_query_result = start_host.query.go()
hosts = []
self._get_host_from_query_result(host_names, host_name_to_get, host_query_result, hosts)
if parent_host is not None:
for host in hosts:
for key in parent_session_ids:
if host.href.startswith(key):
self.session_ids[host.href] = {'name': host.attributes.name.value, 'session_ids': parent_session_ids[key]['session_ids']}
return
for host in hosts:
self.session_ids[host.href] = {'name': host.attributes.name.value, 'session_ids': []}
if len(match_properties.keys()) == 0:
start = (self._port_offset - 1) * self._sessions_per_port + 1
end = start + self._sessions_per_port - 1
self.session_ids[host.href]['session_ids'] = '%s-%s' % (start, end)
else:
for key in match_properties.keys():
value = getattr(host.attributes, key)
if value.is_multivalue:
match = match_properties[key]
if isinstance(match, list) is False:
match = [match]
for session_id in value.get_session_ids(match, self._port_count, self._port_offset):
if session_id not in self.session_ids[host.href]:
self.session_ids[host.href]['session_ids'].append(session_id)
elif value.value == match_properties[key]:
# self.session_ids[host.href] = '1-%s' % host.attributes.count.value
self.session_ids[host.href]['session_ids'] = range(1, host.attributes.count.value + 1)
else:
break
for key in self.session_ids:
if isinstance(self.session_ids[key], list):
if len(self.session_ids[key]['session_ids']) == 0:
self.session_ids[key]['session_ids'] = None
# else:
# self.session_ids[key] = self._session_ids_to_range(self.session_ids[key])
return self
