print "Printing connection variables ... " print "test_name = %s" % filename print 'chassis_ip = %s' % chassis_ip print "tcl_server = %s " % tcl_server print "ixnetwork_tcl_server = %s" % ixnetwork_tcl_server print "port_list = %s " % port_list print "file_param = %s " % file_param ###################################### ## CONNECT WITHOUT SESSION RESUME ## ###################################### connect_result = ixiangpf.connect( ixnetwork_tcl_server=ixnetwork_tcl_server, tcl_server=tcl_server, device=chassis_ip, port_list=port_list_str, break_locks=1, reset=1, ) if connect_result['status'] != '1': print "FAIL:" print connect_result['log'] quit() print " Printing connection result" pprint(connect_result) ports = connect_result['vport_list'].split() top_1 = ixiangpf.topology_config( topology_name="{Topology 1}",
print( '\tVerifyPortState: %s is not up yet. Verifying %d/%d seconds' % (assignedPort, timer, stopTime)) time.sleep(1) if timer == stopTime and portState != 'up': print('\nPort can\'t come up. Exiting test') return 1 connect_status = ixia_ngpf.connect(reset=1, ixnetwork_tcl_server=ixNetworkTclServer, device=ixChassisIp, port_list=portList, return_detailed_handles=0, user_name='admin', user_password='******', ixnetwork_license_servers=[licenseServerIp], ixnetwork_license_type=licenseMode, close_server_on_disconnect=1, break_locks=1) # Connect to existing session ID ''' connect_status = ixia_ngpf.connect( ixnetwork_tcl_server = ixNetworkTclServer, session_resume_keys = 0, user_name = 'admin', user_password = '******', session_id = 34 )
chassis = ['10.219.117.101'] tcl_server = '10.219.117.101' port_list = [['1/1', '1/2']] vport_name_list = [['1/1/1', '1/1/2']] guard_rail = 'none' # # this should match up w/ your port_list above # ixnHLT['path_list'] = [['//vport:<1>', '//vport:<2>']] # # _result_ = ixiangpf.connect( reset=1, device=chassis, port_list=port_list, ixnetwork_tcl_server='localhost', tcl_server=tcl_server, guard_rail=guard_rail, return_detailed_handles=0 ) # Check status if _result_['status'] != IxiaHlt.SUCCESS: ixnHLT_errorHandler('connect', _result_) porthandles = [] for (ch, ch_ports, ch_vport_paths) in zip(chassis, port_list, ixnHLT['path_list']): ch_porthandles = [] for (port, path) in zip(ch_ports, ch_vport_paths): try: ch_key = _result_['port_handle'] for ch_p in ch.split('.'): ch_key = ch_key[ch_p]
ixnetwork_tcl_server = 'localhost' port_list = '9/1 9/9' # ############################################################################# # CONNECT AND PORT HANDLES # ############################################################################# print('\n\nConnect to IxNetwork Tcl Server and get port handles...\n\n') connect_status = ixiangpf.connect( reset=1, device=chassis_ip, port_list=port_list, ixnetwork_tcl_server=ixnetwork_tcl_server, tcl_server=chassis_ip, ) if connect_status['status'] != IxiaHlt.SUCCESS: ixnHLT_errorHandler('connect', connect_status) port_handle = connect_status['vport_list'] port_0 = port_handle.split(' ')[0] port_1 = port_handle.split(' ')[1] # #############################################################################
chassis_ip = '10.87.123.247' ixnetwork_tcl_server = '10.87.132.18' port_list = '4/7 4/8 4/1 4/2' # ############################################################################# # CONNECT AND PORT HANDLES # ############################################################################# print('\n\nConnect to IxNetwork Tcl Server and get port handles...\n\n') connect_status = ixiangpf.connect( device=chassis_ip, port_list=port_list, ixnetwork_tcl_server=ixnetwork_tcl_server, tcl_server=chassis_ip, # config_file = '/root/scripts/configfile', config_file=configfile, ) if connect_status['status'] != IxiaHlt.SUCCESS: ixnHLT_errorHandler('connect', connect_status) #connect_status = ixiangpf.connect( # ixnetwork_tcl_server = ixnetwork_tcl_server, #) #if connect_status['status'] != IxiaHlt.SUCCESS: # ixnHLT_errorHandler('connect', connect_status) ############################################################################# # ACTION - get_all_qt_handles # #############################################################################
'ip_src_mode': 'increment', 'ip_src_step': '0.0.0.1', 'ip_src_count': '1', 'ip_dst_addr': '1.1.1.1', 'ip_dst_mode':'increment', 'ip_dst_step': '0.0.0.1', 'ip_dst_count': '1', 'rate_percent': '10', 'frame_size': '1000', 'bidirectional': '0', 'number_of_packets_per_stream': 50000 } connect_result = ixia_ngpf.connect ( ixnetwork_tcl_server = ixnetwork_tcl_server, username = username, break_locks = '1' ) PrintDict(connect_result) ConfigQuickFlowGroup(**trafficItem1) #ConfigQuickFlowGroup(**trafficItem2) RegenerateAllTrafficItemsPy() StartTrafficNgpfHlPy() time.sleep(15) traffic_stats = GetStatsPy(getStatsBy='Port Statistics') PrintDict(traffic_stats)
if hasattr(v, '__iter__'): PrintDict(v, nested_level + 1, output) else: print >> output, '%s%s' % ((nested_level + 1) * spacing, v) print >> output, '%s]' % ((nested_level) * spacing) else: print >> output, '%s%s' % (nested_level * spacing, obj) if resume == 1: # Connect to the existing configuration to resume running traffic. print '\nResuming existing configuration ...' connectStatus = ixia_ngpf.connect ( ixnetwork_tcl_server = ixNetworkTclServer, tcl_server = tclServer, username = userName, break_locks = '1', ) if resume == 0 and reassignPorts == 0: # Load config file and use the saved config's ports. print '\nLoading config file:', configFile connectStatus = ixia_ngpf.connect ( ixnetwork_tcl_server = ixNetworkTclServer, tcl_server = tclServer, username = userName, break_locks = 1, config_file = configFile, session_resume_keys = 1, )
print >> output, '%s' % (nested_level * spacing) elif type(obj) == list: print >> output, '%s[' % ((nested_level) * spacing) for v in obj: if hasattr(v, '__iter__'): print_dict(v, nested_level + 1, output) else: print >> output, '%s%s' % ((nested_level + 1) * spacing, v) print >> output, '%s]' % ((nested_level) * spacing) else: print >> output, '%s%s' % (nested_level * spacing, obj) connect_status = ixia_ngpf.connect(reset=1, device=chassis_ip, port_list=port_list, ixnetwork_tcl_server=ixnetwork_tcl_server, tcl_server=chassis_ip, close_server_on_disconnect='0') print_dict(connect_status) if connect_status['status'] != '1': print '\nError: Failed to connect\n' port_handle = connect_status['vport_list'] print '\nport handles', port_handle print 'port1', port_1 print 'port2', port_2 topology_1_status = ixia_ngpf.topology_config(topology_name='Topology 1', port_handle=port_1)
chassis_ip = py.ports[0][0] tcl_server = chassis_ip ixnetwork_tcl_server = str(py.ixTclServer) + ':' + str(py.ixTclPort) port_list = [port1, port2] # END CONNECTION VARS # ############################################################################# # CONNECT AND PORT HANDLES # ############################################################################# print('\n\nConnect to IxNetwork Tcl Server and get port handles...\n\n') connect_status = ixiangpf.connect( reset=1, vport_count=2, ixnetwork_tcl_server=ixnetwork_tcl_server, tcl_server=chassis_ip, ) if connect_status['status'] != IxiaHlt.SUCCESS: ixnHLT_errorHandler('connect', connect_status) port_handle = connect_status['vport_list'] port_0 = port_handle.split(' ')[0] port_1 = port_handle.split(' ')[1] print(''' # ############################################################################# # DHCPv4 Client CONFIG # ############################################################################# ''')
class Ixia(TrafficGen): """ IXIA emulation class """ def __init__(self, system_data=None, chassis=None, appserver=None, license_server=None, ixia_lib_path=None): """ IXIA abstraction layer for HLTAPI -- Workflow 1 -- :param system_data *MANDATORY* Dictionary of IXIA information Example: system_data = system: primary: appserver: wf-appserver2.englab.juniper.net controllers: unknown: domain: englab.juniper.net hostname: wf-ixchassis2 mgt-intf-name: mgt0 mgt-ip: 10.9.1.107 osname: IxOS license_server: sv8-pod1-ixlic1.englab.juniper.net make: ixia model: xgs12 name: wf-ixchassis2 osname: IxOS -- Workflow 2 -- :param chassis *MANDATORY* Name of chassis :param appserver *MANDATORY* Name of tcl server :param license_server *MANDATORY* Name of chassis :return: ixia object """ self.virtual = False self.port_list = None self.session_info = None self.handle_to_port_map = None self.port_to_handle_map = None self.intf_to_port_map = None self.major_minor_version = None self.physical_port_type = 'fiber' self.user_functions = dict() self.connect_args = dict() self.cleanup_session_args = None self.port_order = None self.interfaces = None self.port = 8009 self.connect_to_current_session = False self.connect_to_current_session_args = dict() # args just for connecting to current session atexit.register(self.cleanup) self.min_version = None self.username, self.password = credentials.get_credentials(os='Ixia') self.port_type = dict() # Ixia API handles self._ixiangpf = None self._ixiaixnet = None if ixia_lib_path: self.lib_path = ixia_lib_path else: environment = yaml.safe_load(open(os.path.join(os.path.dirname(credentials.__file__), "environment.yaml"))) self.lib_path = environment['ixia-lib-path'] if system_data: sys_pri = system_data['system']['primary'] controller_key = list(sys_pri['controllers'].keys())[0] self.chassis = sys_pri['controllers'][controller_key]['mgt-ip'] # Instantiate host object for logging host_args = dict() if 'name' in sys_pri: host_args['host'] = sys_pri['name'] else: raise TobyIxiaException("Missing 'name' from 'primary' system stanza") if 'osname' in sys_pri['controllers'][controller_key]: host_args['os'] = sys_pri['controllers'][controller_key]['osname'] else: raise TobyIxiaException("Missing 'osname' from controller " + controller_key + " stanza") super(Ixia, self).__init__(**host_args) # connect user fv- knob information and materialize kwargs for Ixia connect() call if 'appserver' in sys_pri: self.connect_args['ixnetwork_tcl_server'] = sys_pri['appserver'] if 'appserver-port' in sys_pri: self.connect_args['ixnetwork_tcl_server'] = sys_pri['appserver'] + ':' + str(sys_pri['appserver-port']) self.port = sys_pri['appserver-port'] if 'appserver-username' in sys_pri: self.connect_args['user_name'] = sys_pri['appserver-username'] if 'appserver-password' in sys_pri: self.connect_args['user_password'] = sys_pri['appserver-password'] if 'return-detailed-handles' in sys_pri: if sys_pri['return-detailed-handles'] == 'disable': self.connect_args['return_detailed_handles'] = 0 if 'config-file' in sys_pri: self.connect_args['config_file'] = sys_pri['config-file'] else: self.connect_args['reset'] = 1 if sys_pri['model'].lower().startswith('ixvm') or sys_pri['model'].lower().startswith('vixia'): self.virtual = True self.model = sys_pri['model'].lower() self.log(level='INFO', message="IXIA Type= Virtual") if 'license_server' in sys_pri: self.connect_args['ixnetwork_license_servers'] = sys_pri['license_server'] if 'license_type' in sys_pri: if sys_pri['license_type'].startswith('tier'): self.connect_args['ixnetwork_license_type'] = 'mixed_' + sys_pri['license_type'] else: self.connect_args['ixnetwork_license_type'] = sys_pri['license_type'] else: self.log(level='INFO', message="IXIA Type= Physical") if 'connect-args' in sys_pri and type(sys_pri['connect-args']) is dict: self.connect_args.update(sys_pri['connect-args']) if 'cleanup-session-args' in sys_pri and type(sys_pri['cleanup-session-args']) is dict: self.cleanup_session_args = sys_pri['cleanup-session-args'] if 'port-order' in sys_pri: self.port_order = sys_pri['port-order'] if 'connect-to-current-session' in sys_pri and sys_pri['connect-to-current-session'] == 'enable': self.connect_to_current_session = True self.connect_to_current_session_args['ixnetwork_tcl_server'] = self.connect_args['ixnetwork_tcl_server'] # adding only connect-args for current session (no other arguments so can preserve session) if 'connect-args' in sys_pri and type(sys_pri['connect-args']) is dict: self.connect_to_current_session_args.update(sys_pri['connect-args']) if 'min-version' in sys_pri and type(sys_pri['min-version']) is str: self.min_version = sys_pri['min-version'] self.log(level='info', message="Ixia Minimum Chassis Version is set to: "+ sys_pri['min-version']) # Ensure mandatory connect() args are satisfied if 'ixnetwork_tcl_server' not in self.connect_args: raise TobyIxiaException("Missing appserver information (ixnetwork_tcl_server). This may be provided via 'fv-ixia-appserver'" "knob, or via 'fv-ixia-connect-args'.", host_obj=self) if sys_pri['model'].lower().startswith('ixvm') or sys_pri['model'].lower().startswith('vixia'): if 'ixnetwork_license_servers' not in self.connect_args: raise TobyIxiaException("Missing VM licensing information (ixnetwork_license_servers)." + \ "This may be provided via 'fv-ixia-license-server' knob, or via 'fv-ixia-connect-args'.", host_obj=self) if 'ixnetwork_license_type' not in self.connect_args: self.connect_args['ixnetwork_license_type'] = 'mixed_tier1' elif chassis and appserver: self.chassis = chassis self.appserver = appserver if license_server: self.license_server = license_server else: raise TobyIxiaException("Missing either system_data (Workflow 1) or chassis/appserver" "/license_server (Workflow 2) parameters", host_obj=self) self.intf_status = None self.log(level='info', message="CHASSIS= " + self.chassis) self.log(level='info', message="APPSERVER= " + self.connect_args['ixnetwork_tcl_server']) self.wait = 1 self.telnet_handle = None self.version = self._get_version() if self.min_version: if(float(self.version) < float(self.min_version)): raise TobyIxiaChassisConnectException("Ixia Minimum Chassis Version Check Failed", host_obj=self) if self.virtual: result = self._configure_promiscuous() if not result: self.log(level='WARN', message="Unable to set Promiscuous mode on IXIA virtual chassis") else: self.log(level='info', message="Successfully set Promiscuous mode on IXIA virtual chassis") if self.chassis_type is not None: if self.model.startswith('vixia') and re.search('Virtual Load Module', self.chassis_type, re.I): self.log(level='WARN', message="Virtual ixia chassis type is not correct as virtual modeli defined in params") self.ixia_lib_version = self._get_lib_version() self._set_envs() # Import core modules for native IXIA APIs # disable import-error because dynamic ENV changes based on IXIA version make it possible to import ok from ixiatcl import IxiaTcl # pylint: disable=import-error from ixiahlt import IxiaHlt # pylint: disable=import-error from ixiangpf import IxiaNgpf # pylint: disable=import-error # from ixiaerror import IxiaError # pylint: disable=import-error self.ixiatcl = IxiaTcl() self.ixiahlt = IxiaHlt(self.ixiatcl) self._ixiangpf = IxiaNgpf(self.ixiahlt) # Import extended ixia modules with functions # from jnpr/toby/trafficgen/ixia current_dir = os.path.dirname(os.path.abspath( inspect.getfile(inspect.currentframe()))) user_module_dir = re.sub(r"jnpr\/toby.*", "jnpr/toby/trafficgen/ixia", current_dir) sys.path.append(user_module_dir) file_list = list(filter(lambda x: os.path.isfile(os.path.join(user_module_dir, x)), os.listdir(user_module_dir))) for file_name in file_list: if file_name.endswith('.py') and not file_name.startswith('__'): module = re.sub(r"\.py$", "", file_name) obj = __import__(module) function_list = [o for o in inspect.getmembers(obj) if inspect.isfunction(o[1])] for function_tuple in function_list: function_name, function = function_tuple if function_name in self.user_functions: raise TobyIxiaException("Duplicate functions in user contributed modules", host_obj=self) self.user_functions[function_name] = function def _configure_promiscuous(self): """ To enable promiscuous mode for Ixia Virtual Test Appliance """ try: cmd = 'set promiscuous-mode all enable' if (self.version): match = re.match(r'(\d+.\d+).*', self.version) if match and float(match.group(1)) >= 8.50: cmd = 'set promiscuous-mode all all enable' pexp = pexpect.spawn('ssh -l StrictHostKeyChecking=no %s@%s' % (self.username, self.chassis)) pexp.expect('password:'******'#') pexp.sendline(cmd) pexp.expect('#') output = pexp.before pexp.sendline('exit') if re.search(r'Promiscuous mode was successfully set|promiscuous mode.*enabled', output.decode('utf-8'), re.IGNORECASE): return True else: return False except Exception: self.log(level="ERROR", message="Unable to connect to IXIA virtual Chassis") def _get_version(self): """ Get Chassis OS Version of IXIA TC : :return: ixia chassisversion """ version = None chassis_type = None try: # Trying to get the ixia version with out login to the box using SSH retvalue = os.popen( 'ssh -o PasswordAuthentication=no -o StrictHostKeyChecking=no ' + self.username + '@' + self.chassis + ' 2>&1 | grep "Welcome to Ixia\\|IxOS Version\\|Connection refused"').readlines() if retvalue and len(retvalue) > 0: search_obj = re.search(r'Version:\s+(\d+\.\d+\.\d+\.\d+)', retvalue[1]) if search_obj: version = re.sub(r'Version:\s+', '', search_obj.group(0)) chassis_type = self._find_chassis_type(retvalue[0]) elif re.search(r'Connection refused', retvalue[0], re.IGNORECASE): self.log(level="INFO", message="Could not initiate ssh connection to box") raise Exception("Could not initiate ssh connection to box %s" % self.chassis) if version is None: #Trying to get the ixia version by login to the box using SSH ssh_cl = paramiko.client.SSHClient() ssh_cl.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh_cl.connect(hostname=self.chassis, username=self.username, password=self.password, allow_agent=False, look_for_keys=False) channel = None data = '' try: channel = ssh_cl.invoke_shell(width=160) time.sleep(2) except: transport = ssh_cl.get_transport() channel = transport.open_session() if channel.recv_ready(): data = channel.in_buffer.empty() try: data = data.decode('utf-8') except UnicodeDecodeError: data = data.decode('iso-8859-1') ver_re = re.compile(r'IxOS Version.*:\s+(\d+\.\d+\.\d+\.\d+)', re.IGNORECASE) ver_old_re = re.compile(r'enter chassis', re.IGNORECASE) version = "" banner_out = "" command_response = '' if ver_re.search(str(data)): banner_out = str(data) ver_search = ver_re.search(banner_out) if ver_search: version = ver_search.group(1) chassis_type = self._find_chassis_type(banner_out) else: self.log(level="INFO", message="Connect response does not have version info: %s" % banner_out) try: channel.exec_command('show chassis installed-versions') except: transport = ssh_cl.get_transport() channel = transport.open_session() channel.exec_command('show chassis installed-versions') time.sleep(2) if channel.recv_ready(): command_response = channel.recv(1024) version = re.search(r'Chassis:\s+\*?((\d+\.){3}\d+)', command_response.decode('utf-8'), re.IGNORECASE).group(1) chassis_type = self._find_chassis_type(banner_out) elif ver_old_re.search(str(data)): channel.send('enter chassis\n') channel.send('show ixos active-version\n') time.sleep(2) if channel.recv_ready(): command_response = channel.recv(5102) match = re.search(r'IxOS active version:.*?(\d+\.\d+\.\d+\.\d+)', command_response.decode('utf-8'), re.IGNORECASE) if match: version = match.group(1) chassis_type = self._find_chassis_type(command_response) else: self.log(level="INFO", message="Connect response does not have version info: %s" % banner_out) try: channel.exec_command('show ixos active-version') except: transport = ssh_cl.get_transport() channel = transport.open_session() channel.exec_command('show ixos active-version') time.sleep(2) if channel.recv_ready(): command_response = channel.recv(1024) match = re.search(r'IxOS active version:\s+IxOS\s+(\d+\.\d+\.\d+\.\d+)', command_response.decode('utf-8'), re.IGNORECASE) if match: version = match.group(1) chassis_type = self._find_chassis_type(command_response) ssh_cl.exec_command('exit') if version is not None: self.log(level="INFO", message="Ixos version: %s \n" % version) else: self.log(level="INFO", message="Could not get the ixia verion using ssh connection") raise Exception("Could not get the ixia verion using ssh connection to box %s" % self.chassis) except Exception as ex: self.log(level="INFO", message="Toby was not able to find version using ssh due to: %s" % ex.__str__()) #Trying to get the ixia version with out login to the box using Telnet self.log(level="INFO", message="Trying telnet for chassis %s" % self.chassis) try: telnet_handle = telnetlib.Telnet(self.chassis) banner_out = telnet_handle.read_until(b"Ixia>") time.sleep(10) cmd = "package require IxTclHal;version cget -ixTclHALVersion\n" cmd = cmd.encode('ascii') telnet_handle.write(cmd) match_results = telnet_handle.expect([br"\d+\.\d+\.\d+\.\d+"]) version = match_results[1].group(0).decode('ascii') self.log(level="INFO", message="Ixos version: %s \n" % version) chassis_type = self._find_chassis_type(banner_out) telnet_handle.close() except Exception as ex: self.log(level="ERROR", message="Toby was not able to find version info using telnet connection due to: %s" % ex.__str__()) #self.log(level="ERROR", message="Could not get the version info using telnet connection") if not version: if not check_device_reachabiliy(self, self.chassis): raise TobyIxiaChassisConnectException("IXIA chassis is not pingable") else: raise TobyIxiaException("Unable to detect IXIA version", host_obj=self) self.log(level='info', message='CHASSIS VERSION: ' + version) self.major_minor_version = re.search(r'^\d+\.\d+', version).group(0) if not self.major_minor_version: raise TobyIxiaException("Unable to derive major and minor version from " + version, host_obj=self) if float(self.major_minor_version) < 8.20: raise TobyIxiaException("Unsupported version " + self.major_minor_version + ". Minimum version supported: 8.20", host_obj=self) self.chassis_type = chassis_type return version def _find_chassis_type(self, response): """ Find Chassis type based :return: ixia chassis type """ chassis_type = None search_obj = re.search(r'Welcome to Ixia (Virtual Chassis|Virtual Test Appliance|Virtual Load Module)', str(response), re.I) if search_obj: chassis_type = search_obj.group(1) self.log(level='info', message='Virtual chassis type: %s' % chassis_type) return chassis_type def _set_envs(self): """ Set ENVs required for IXIA TC """ if self.version is None: self._get_version() ixia_lib_path_prefix = self.lib_path + '/' + self.ixia_lib_version + '/lib' os.environ['TCLLIBPATH'] = ixia_lib_path_prefix sys.path.append(ixia_lib_path_prefix + '/hltapi/library/common/ixiangpf/python') sys.path.append(ixia_lib_path_prefix + '/PythonApi') self.log(level="info", message="ADDED_TO_PATH= " + os.environ['TCLLIBPATH']) self.log(level="info", message="ADDED_TO_PYTHONPATH= " + ixia_lib_path_prefix + '/hltapi/library/common/ixiangpf/python') self.log(level="info", message="ADDED_TO_PYTHONPATH= " + ixia_lib_path_prefix + '/PythonApi') def _get_lib_version(self): """ Needed to determine which IXIA library folder to use. """ ixia_lib_ver = None try: best_match = None ixia_lib_vers = list(filter(lambda x: os.path.isdir(os.path.join( self.lib_path, x)), os.listdir(self.lib_path))) for possible_lib_ver in ixia_lib_vers: if re.search(r'\d+\.\d+\.\d+\.\d+', possible_lib_ver): if possible_lib_ver == self.version: ixia_lib_ver = possible_lib_ver break elif re.search(r'^' + self.major_minor_version, possible_lib_ver): best_match = possible_lib_ver if best_match and not ixia_lib_ver: ixia_lib_ver = best_match except: raise TobyIxiaException( "Unable to find appropriate IXIA lib version in " + self.lib_path + " for Ixia version " + self.version, host_obj=self) if not ixia_lib_ver: raise TobyIxiaException("Unable to find appropriate IXIA lib version in " + self.lib_path + " for Ixia version " + self.version, host_obj=self) self.log(level="INFO", message="IXIA LIB AVAILABLE = " + str(ixia_lib_ver)) return ixia_lib_ver def add_interfaces(self, interfaces): """ Get interfaces{} block from yaml to use fv- knobs therein """ self.interfaces = interfaces def add_intf_to_port_map(self, intf_to_port_map): """ Add attribute to ixia object which contains params intf to port mappings """ self.intf_to_port_map = intf_to_port_map def _initialize_ports(self): # next, initialize the port via interface_config fiber_port_handles = [] copper_port_handles = [] ge_port_handles = [] xe_port_handles = [] for intf in self.interfaces: if 'physical-port-type' in self.interfaces[intf] and self.interfaces[intf]['physical-port-type'] == 'copper': copper_port_handles.insert(0, self.get_port_handle(intf)) else: # fiber fiber_port_handles.insert(0, self.get_port_handle(intf)) if self.port_type: if re.search(r'^Novus', self.port_type[self.interfaces[intf]['name']], re.IGNORECASE): if 'type' in self.interfaces[intf] and 'ge' in self.interfaces[intf]['type']: ge_port_handles.insert(0, self.get_port_handle(intf)) elif 'type' in self.interfaces[intf] and 'xe' in self.interfaces[intf]['type']: xe_port_handles.insert(0, self.get_port_handle(intf)) if len(copper_port_handles): self.log("Invoking interface_config for copper ports: " + str(copper_port_handles)) result = self._ixiangpf.interface_config(port_handle=copper_port_handles, phy_mode='copper') self.log('INFO', "Invokation of interface_config result: " + str(result)) if len(fiber_port_handles): self.log("Invoking interface_config for fiber ports: " + str(fiber_port_handles)) result = self._ixiangpf.interface_config(port_handle=fiber_port_handles, phy_mode='fiber') self.log('INFO', "Invokation of interface_config result: " + str(result)) if len(ge_port_handles): self.log("Invoking interface_config for nova card GE ports: " + str(ge_port_handles)) result = self._ixiangpf.interface_config(port_handle=ge_port_handles, autonegotiation='1', speed='ether1000') self.log('INFO', "Invokation of interface_config result: " + str(result)) if len(xe_port_handles): self.log("Invoking interface_config for nova card XE ports: " + str(xe_port_handles)) result = self._ixiangpf.interface_config(port_handle=xe_port_handles, autonegotiation='0', speed='ether10Gig') self.log('INFO', "Invokation of interface_config result: " + str(result)) def invoke(self, command, *args, **kwargs): """ Pass-through for ixnetwork.py functions (ixnetwork.py? or something else?) """ lib = 'ngpf' if re.search(r'^IxNet::', command): lib = 'ixnet' command = command.replace('IxNet::', '', 1) # Initialize IxNet if not set up already if not self._ixiaixnet: from IxNetwork import IxNet # pylint: disable=import-error self._ixiaixnet = IxNet() self._connect_ixnet() if 'port_handle' in kwargs.keys(): port_handle = kwargs['port_handle'] if isinstance(port_handle, six.string_types): port_handle = port_handle.split(' ') if port_handle[0] in self.intf_to_port_map.keys(): new_port_handle = list() for intf in port_handle: new_port_handle.append(self.port_to_handle_map[self.intf_to_port_map[intf]]) kwargs['port_handle'] = ' '.join(new_port_handle) # User contributed module if command in self.user_functions: self.log(level="info", message="Invoking Juniper IXIA function " + command + " with parameters " + str(kwargs)) result = self.user_functions[command](self, **kwargs) self.log(level="info", message="Invocation of Juniper IXIA function " + command + " completed with result: " + str(result)) return result # ngpf method elif lib == 'ngpf': self.log(level="info", message="Invoking IXIA ngpf method " + command + " with parameters " + str(kwargs)) ixia_method = getattr(self._ixiangpf, command) result = ixia_method(**kwargs) if result['status'] == '0': raise TobyIxiaException("Invocation of IXIA method " + command + " failed with result: " + str(result), host_obj=self) else: self.log(level="debug", message="Invocation of IXIA method " + command + " succeeded with result: " + str(result)) return result # ixnet method elif lib == 'ixnet': ixnet_args = kwargs.get('ixnet_args', None) if not ixnet_args and len(args) > 0: # args came in via python *args instead of via kwargs(ixnet_args) ixnet_args = args self.log("INFO", message="Invoking IXIA ixnet API '" +command + "' with parameters " + str(ixnet_args)) ixia_method = getattr(self._ixiaixnet, command) if ixnet_args: result = ixia_method(*ixnet_args) else: result = ixia_method() self.log("INFO", message="Invocation of IXIA API '" + command + "' completed with result: " + str(result)) return result def _connect_ixnet(self): tcp_port = self.session_info['connection']['port'] client_version = self.session_info['connection']['client_version'] self.log('INFO', "Invoking ixnet connect() on tcp port " + tcp_port + " with client version " + client_version) connect_status = self._ixiaixnet.connect(self.connect_args['ixnetwork_tcl_server'], '-port', tcp_port, '-version', client_version) self.log('INFO', "Ixnet connect status: " + str(connect_status)) def connect(self, port_list=None): """ Connect to IXIA chassis :param port_list (*REQUIRED): port list , ex: '1/9 1/10 1/11' :return: ixia connection object """ if not port_list and not self.connect_to_current_session: raise TobyIxiaException("Missing port_list parameter", host_obj=self) connect_status = None #reorder port list if required - useful when config_file is being loaded and ports need to pair up exactly if self.port_order: duplicate_port_check = {} new_port_list = [] interfaces = self.port_order.split(':') for intf in interfaces: if intf in duplicate_port_check: raise TobyIxiaException("duplicate port " + intf + " found in port_list [fv-ixia-port-list]", host_obj=self) if intf in self.intf_to_port_map: new_port_list.append(self.intf_to_port_map[intf]) duplicate_port_check[intf] = 1 else: raise TobyIxiaException("IXIA Port " + intf + " specified in ordered port list does not exist", host_obj=self) if len(port_list) != len(new_port_list): raise TobyIxiaException("IXIA port ordered list [fv-ixia-port-list] does not match number of interfaces present", host_obj=self) port_list = new_port_list if self.connect_to_current_session: self.log(level="INFO", message="Connecting to existing IXIA session via ngpf(HLTAPI) with the following arguments: " + str(self.connect_to_current_session_args)) connect_status = self._ixiangpf.connect(**self.connect_to_current_session_args) else: ports = " ".join(port_list) self.connect_args['port_list'] = ports self.connect_args['device'] = self.chassis self.log(level="INFO", message="Connecting to IXIA via ngpf(HLTAPI) with parameters " + str(self.connect_args)) connect_status = self._ixiangpf.connect(**self.connect_args) self.log(level="INFO", message="IXIA Connection status: " + str(connect_status)) if connect_status['status'] != '1': error_message = "Not able to connect to IXIA, " if not check_appserver_reachabiliy(self, self.connect_args['ixnetwork_tcl_server'], self.port): error_message += "Failed to connect to appserver %s using port %s" % (self.connect_args['ixnetwork_tcl_server'], self.port) else : if 'log' in connect_status: error_message = error_message + " : " + connect_status['log'] raise TobyIxiaAppserverConnectException(error_message, host_obj=self) self.session_info = connect_status try: root = self._invokeIxNet('getRoot') vports = self._invokeIxNet('getList', root, 'vport') for tr in vports: l1config = self._invokeIxNet('getList', tr, 'l1Config') port_detail = self._invokeIxNet('getAttribute', tr, '-connectionStatus') match1 = port_detail.split(";") interface_name = match1[1].lstrip("0").strip() + "/" + match1[2].split()[0].lstrip("0").strip() card_type = self._invokeIxNet('getAttribute', l1config[0], '-currentType') if interface_name and card_type: self.port_type[interface_name] = card_type except: self.log(level="INFO", message="Unable to get card type of IXIA virtual Chassis ports") if port_list: if self.connect_to_current_session: result = self._ixiangpf.session_info(mode='get_session_keys', session_keys_include_filter='connect.vport_list') port_handle_list = result['vport_list'].split(' ') else: port_handle_list = connect_status['vport_list'].split(' ') self.port_list = port_list self.port_to_handle_map = dict(zip(port_list, port_handle_list)) self.handle_to_port_map = dict(zip(port_handle_list, port_list)) if not self.connect_to_current_session: self._initialize_ports() def get_port_handle(self, intf): """ Use IXIA object information to get port handle keys """ intf = intf.lower() if intf in self.intf_to_port_map.keys(): port = self.intf_to_port_map[intf] if port in self.port_to_handle_map.keys(): return self.port_to_handle_map[port] else: raise TobyIxiaException("No such params interface " + intf, host_obj=self) def cleanup(self): """ Destructor to clean up session """ print("Cleaning up Ixia port handles via cleanup_session() IXIA call") if self.handle_to_port_map: if self.cleanup_session_args: if 'port_handle' not in self.cleanup_session_args: self.cleanup_session_args['port_handle'] = self.handle_to_port_map.keys() print("Clean up session args : "+str(self.cleanup_session_args)) result = self._ixiangpf.cleanup_session(**self.cleanup_session_args) else: result = self._ixiangpf.cleanup_session() if result['status'] == '0': print("Ixia cleanup failed. Ixia API response: " + str(result)) else: print("Ixia cleanup successful") def _invokeIxNet(self, command, *args): """ To Execute Low Level APIs on the Existing Session. """ self.log(level="info", message="Invoking IXIA ixNet method " + command + " with parameters " + str(args)) ixnet = self._ixiangpf.ixnet ixia_method = getattr(ixnet, command) try: result = ixia_method(*args) self.log(level="info", message="Invocation of IXIA method " + command + " succeeded with result: " + str(result)) return result except Exception as e: raise TobyException("Invocation of IXIA method " + command + " failed with result: " + str(e), host_obj=self)
print 'chassis_ip = %s' % chassis_ip print "tcl_server = %s " % tcl_server print "ixnetwork_tcl_server = %s" % ixnetwork_tcl_server print "port_list = %s " % port_list ###################################### ## CONNECT WITHOUT SESSION RESUME ## ###################################### connect_result = ixiangpf.connect( ixnetwork_tcl_server = ixnetwork_tcl_server, tcl_server = tcl_server, device = chassis_ip, port_list = port_list, break_locks = 1, reset = 1, master_device = master_chassis, chain_sequence = chain_seq, chain_cables_length = chain_cables_length, ) if connect_result['status'] != '1': print "FAIL:" print connect_result['log'] quit() print " Printing connection result" pprint(connect_result) check_master = connect_result['connection']['chassis'][chassis_ip[0]]['is_master_chassis'] check_slave1 = connect_result['connection']['chassis'][chassis_ip[1]]['is_master_chassis']
errors = 0 print "Printing connection variables ... " print "test_name = %s" % filename print 'chassis_ip = %s' % chassis_ip print "tcl_server = %s " % tcl_server print "ixnetwork_tcl_server = %s" % ixnetwork_tcl_server print "port_list = %s " % port_list print "config_file = %s" % config_file #===============================> CONNECTION <========================================== print "Connecting to localhost ..." connect_result = ixiangpf.connect( ixnetwork_tcl_server=ixnetwork_tcl_server, tcl_server=tcl_server, device=chassis_ip, port_list=port_list, break_locks=1, config_file=config_file, ) if connect_result['status'] != '1': ErrorHandler('connect', connect_result) print "\nPrinting connection result\n" pprint(connect_result) ports = connect_result['vport_list'].split() print "\nRetrieving all QuickTest handles present in the config ...\n" test_control_status = ixiahlt.test_control(action='get_all_qt_handles')
chassis_ip = '10.87.123.247' ixnetwork_tcl_server = '10.87.132.18' port_list = '4/7 4/8 4/1 4/2' # ############################################################################# # CONNECT AND PORT HANDLES # ############################################################################# print('\n\nConnect to IxNetwork Tcl Server and get port handles...\n\n') connect_status = ixiangpf.connect( device = chassis_ip, port_list = port_list, ixnetwork_tcl_server = ixnetwork_tcl_server, tcl_server = chassis_ip, # config_file = '/root/scripts/configfile', config_file = configfile, ) if connect_status['status'] != IxiaHlt.SUCCESS: ixnHLT_errorHandler('connect', connect_status) #connect_status = ixiangpf.connect( # ixnetwork_tcl_server = ixnetwork_tcl_server, #) #if connect_status['status'] != IxiaHlt.SUCCESS: # ixnHLT_errorHandler('connect', connect_status) #############################################################################