import sys import time ENABLE_CAPTURE = True # This loads the TestCenter library. from StcPython import StcPython stc = StcPython() stc.log("INFO", "Starting Test") # This line will show the TestCenter commands on stdout #stc.config("automationoptions", logto="stdout", loglevel="INFO") # Retrieve and display the current API version. print "SpirentTestCenter system version:\t", stc.get("system1", "version") # Physical topology szChassisIp1 = "10.29.0.49" szChassisIp2 = "10.29.0.45" txPortLoc = "//%s/%s/%s" % ( szChassisIp1, 1, 1) rxPortLoc = "//%s/%s/%s" % ( szChassisIp2, 1, 1) # Create the root project object print "Creating project ..." hProject = stc.create("project") # Create ports print "Creating ports ..." hPortTx = stc.create("port", under=hProject, location=txPortLoc, useDefaultHost=False) hPortRx = stc.create("port", under=hProject, location=rxPortLoc, useDefaultHost=False)
parent=hProject, resultParent=hProject, configType='analyzer', resultType='analyzerportresults', filterList='', viewAttributeList='totalframecount totalframerate totalbitrate', interval='1', filenamePrefix='analyzerportresults') # If sequencer is configured in XML, start it and wait for it to finish #stc.perform('sequencerStart') #rv = stc.waitUntilComplete() # this call is blocking. check rv for pass/fail # Start generators without using sequencer print("Starting generators\n") generator1 = stc.get(ports[0], 'children-Generator') generator2 = stc.get(ports[1], 'children-Generator') stc.perform('GeneratorStart', GeneratorList=generator1) stc.perform('GeneratorStart', GeneratorList=generator2) print("Wait 10 seconds..\n") time.sleep(10) # Check frames per second sb1 = stc.get(ports[0], 'children-StreamBlock') rx_results1 = stc.get(sb1, 'children-RxStreamSummaryResults') framerate1 = stc.get(rx_results1, 'FrameRate') sb2 = stc.get(ports[1], 'children-StreamBlock') rx_results2 = stc.get(sb2, 'children-RxStreamSummaryResults') framerate2 = stc.get(rx_results2, 'FrameRate')
# eg: os.environ['STC_PRIVATE_INSTALL_DIR'] = '/home/mjefferson/spirent/stc/stc4.59/' print "Loading the Spirent TestCenter API..." sys.path.append('/home/mjefferson/spirent/stc/stc4.61/API/Python') from StcPython import StcPython stc = StcPython() # Instruct the API to not display all commands to STDOUT. stc.config("AutomationOptions", logTo="stcapi.log", logLevel="INFO") stc.perform("LoadFromDatabaseCommand", DatabaseConnectionString="capturetest.tcc") # Remap port locations if necessary. for port, location in zip( stc.get("system1.project", "children-port").split(), port_locations): print "Remapping " + port + " to " + location stc.config(port, location=location) # Connect to the hardware. stc.perform("AttachPorts", AutoConnect="true", PortList=stc.get("system1.project", "children-port")) stc.apply() captureStart() # If the GeneratorList argument is not specified, then all generators is assumed. print "Starting traffic" stc.perform("GeneratorStartCommand")
if labserverip: # If you are using a lab server, connect to it now. print("Connecting to Lab Server") stc.perform("CSTestSessionConnect", host=labserverip, TestSessionName="sample", CreateNewTestSession="true") # Terminate the Lab Server session when the last client disconnects. stc.perform("TerminateBll", TerminateType="ON_LAST_DISCONNECT") # Instruct the API to not display all commands to STDOUT. stc.config("AutomationOptions", logTo="stcapi.log", logLevel="INFO") # Save the project handle for later. This is not strictly necessary. project = stc.get("system1", "children-project") # Create a port for each location specified. for location in locationlist: # If you are connecting to a single-speed port, this is all you need to do. # If you are connecting to a multi-speed port, you may need to create the appropriate phy object (e.g., Ethernet10GigFiber). port = stc.create("port", under=project, location=location) # Configure the port rate to 100% line-rate. stc.config(port + ".generator.generatorconfig", fixedload=100, loadunit="PERCENT_LINE_RATE") # Create a raw streamblock. Headers include: EthernetII, Vlan, IPv4, IPv6, Mpls, Tcp, UDP, PPP, GRE, etc. streamblock = stc.create("StreamBlock", under=port,
# You first need to either set the environment variable "STC_PRIVATE_INSTALL_DIR", # or change the StcPython.py file ("STC_PRIVATE_INSTALL_DIR") to point to your # installation. # eg: os.environ['STC_PRIVATE_INSTALL_DIR'] = '/home/mjefferson/spirent/stc/stc4.59/' print "Loading the Spirent TestCenter API..." sys.path.append('/home/mjefferson/spirent/stc/stc4.59/API/Python') from StcPython import StcPython stc = StcPython() # Instruct the API to not display all log entries to STDOUT. stc.config("AutomationOptions", logTo="stcapi.log", logLevel="INFO") # Create the configuration from scratch. print "Creating the configuration from scratch..." project = stc.get("system1", "children-project") # Start by creating two ports. port1 is the Tx port, and port2 is the Rx. port1 = stc.create("port", under=project, location="10.140.99.120/1/1") port2 = stc.create("port", under=project, location="10.140.99.121/1/1") # Create a single Emulated Device on each port. # The "IfStack" is the space-separated list of interface objects used by the device. # It is sorted top-down, meaning that the EthIIIf object will be the last element of the list. # eg: EthIIIf, VlanIf, IPv4If, IPv6If, GREIf, L2tpv2If, MplsIf, etc result = stc.perform("DeviceCreate", ParentList=project, DeviceType="Host", IfStack="Ipv4If VlanIf EthIIIf", IfCount="1 1 1", Port=port1)
def loadTestCenter(version): from StcPython import StcPython stc = StcPython(version) print "Spirent TestCenter version : %s" % stc.get("system1", "version")
# Note that a viable Tcl environment must be available for the library to run # and that the Python Tkinter package must be installed. # The version of the TestCenter library that will be loaded will be determined # by normal Tcl package management. The easiest way to change versions will be # to set the TCLLIBPATH environment variable to point to the desired version # just like would be done in a normal Tcl installation. from StcPython import StcPython stc = StcPython() stc.log("INFO", "Starting Test") # This line will show the TestCenter commands on stdout #stc.config("automationoptions", logto="stdout", loglevel="INFO") # Retrieve and display the current API version. print("SpirentTestCenter system version:\t", stc.get("system1", "version")) # Physical topology szChassisIp = "192.168.22.253" iTxSlot = 2 iTxPort = 1 iRxSlot = 2 iRxPort = 2 # Create the root project object print("Creating project ...") hProject = stc.create("project") # Create ports print("Creating ports ...") hPortTx = stc.create("port",
class StcDriver(API): def __init__(self): #super(API, self).__init__() self.handle = StcPython() main.log.info("STC component initialized") def connect(self,**connectargs): for key in connectargs: vars(self)[key] = connectargs[key] self.name = self.options['name'] main.log.info("Component name is "+self.name) connect_result = super(API,self).connect() main.log.info("Main dir "+main.logdir) self.logFileName = main.logdir+"/"+self.name+".session" main.log.info("Session log file is "+self.logFileName) self.handle.config('automationoptions', loglevel='info',logto=self.logFileName) main.log.info("Connected successfully") return main.TRUE def apply(self): try : main.log.info("apply the action") return self.handle.apply() except : main.log.error("Apply failed because of Exception"+str(sys.exc_info()[0])) return { 'result' : main.FALSE , 'error' : sys.exc_info()[0]} def create(self,objectTypeString,**arguments) : try : main.log.info("creating arguments") #return { result : main.TRUE,return value : self.handle.create(objectTypeString,**arguments) } return self.handle.create(objectTypeString,**arguments) #return ReturnValue(main.TRUE,self.handle.create(objectTypeString,**arguments)) except : main.log.error("Operation "+str(objectTypeString)+" failed because of exception "+str(sys.exc_info()[0])) return { 'result' : main.FALSE, 'error' : sys.exc_info()[0] } def config(self,handleString,**attributes) : try : main.log.info("Configure Port locations") self.handle.config(handleString,**attributes) #return { result : main.TRUE, return value : slef.handle.config(handleString,**attributes)} return self.handle.config(handleString,**attributes) #return ReturnValue(main.TRUE,self.handle.config(handleString,**attributes)) except : main.log.error("Operation "+str(handleString)+" failed because of exception "+str(sys.exc_info()[0])) return { 'result' : main.FALSE, 'error' : sys.exc_info()[0] } def get(self,handleString, attribute) : try : main.log.info("Getting attributes for "+str(handleString)) #return { result : main.TRUE , return value : self.handle.get(handleString,attribute)} return self.handle.get(handleString, attribute) #return ReturnValue(main.TRUE,self.handle.get(handleString, attribute)) except : main.log.error("operation"+str(handleString)+"failed because of exception"+str(sys.exc_info()[0])) return { 'result' :main.FALSE , 'error': sys.exc_info()[0]} def perform(self,commandNameString, **attribute) : try : main.log.info("Performing action "+str(commandNameString)) #return { result : main.TRUE , return value : self.handle.perform(commandNameString,**attribute)} return self.handle.perform(commandNameString, **attribute) #return ReturnValue(main.TRUE , self.handle.perform(commandNameString,**attribute)) except : main.log.error("Operation "+str(commandNameString)+" failed because of exception "+str(sys.exc_info()[0])) return { 'result' : main.FALSE, 'error' : sys.exc_info()[0] } def subscribe(self,**inputParams) : try : main.log.info("subscribe the result") #return { result : main.TRUE , return value : self.handle.subscribe(**inputParams)} return self.handle.subscribe(**inputParams) #return ReturnValue(main.TRUE,self.handle.subscribe(**inputParams)) except : main.log.error("Operation failed because of exception "+str(sys.exc_info()[0])) return { 'result' : main.FALSE , 'error' : sys.exc_info()[0] } def disconnect(self,hostNameString) : try : main.log.info("disconnect") #return { result : main.TRUE ,return value : self.handle.disconnect(hostNameString)} return self.handle.disconnect(str(hostNameString)) #return ReturnValue(main.TRUE,self.handle.disconnect(hostNameString)) except : main.log.error("Operation failed because of exception "+str(sys.exc_info()[0])) return { 'result' : main.FALSE, 'error' : sys.exc_info()[0] } def sleep(self,numberSecondsInteger) : try : main.log.info("sleep time is") #return { result : main.TRUE , return value : self.handle.sleep(numberSecondsInteger)} return self.handle.sleep(numberSecondsInteger) #return ReturnValue(main.TRUE,self.handle.sleep(numberSecondsInteger)) except : main.log.error("Operation failed because of exception "+str(sys.exc_info()[0])) return { 'result' : main.FALSE, 'error' : sys.exc_info()[0] } def unsubscribe(self,resultDataSetHandleString) : try : main.log.info("unsubscribe the ports"+str(resultDataSetHandleString)) return self.handle.unsubscribe(str(resultDataSetHandleString)) #return { result : main.TRUE , return value : self.handle.unsubscribe(resultDataSetHandleString)} #return ReturnValue(main.TRUE,self.handle.unsubscribe(resultDataSetHandleString)) except : main.log.error("unsubscribe"+str(resultDataSetHandleString)+" failed because of exception "+str(sys.exc_info()[0])) return { 'result' : main.FALSE, 'error' : sys.exc_info()[0] } def delete(self,handleString) : try : main.log.info("Deleting ports"+str(handleString)) return self.handle.delete(str(handleString)) #return ReturnValue(main.TRUE,self.handle.delete(handleString)) except : main.log.error("Deletion of "+str(handleString)+"failed because of exception "+str(sys.exc_info()[0])) return { 'result' : main.FALSE, 'error' : sys.exc_info()[0] } def parseresults(self,Attribute,CsvFile) : try : main.log.info("parsing the CSV file for the traffic results") totalrows = len(open('/home/sudheer-570/Desktop/sk/TestON/bin/Untitled/'+CsvFile).readlines()) fp = open("/home/sudheer-570/Desktop/sk/TestON/bin/Untitled/"+CsvFile,'Ur') data_list = [] attributes=[] attribute_values=[] for line in fp: data_list.append(line.strip().split(',')) attribute_values=data_list[totalrows-1] attributes=data_list[totalrows-3] for index in range (0,100) : if attributes[index]==Attribute: main.log.info("Given Attribute Name is:'"+Attribute+"'") main.log.info("Attribute value is:'"+attribute_values[index]+"'") result = attribute_values[index] if result == '0' : main.log.info("Traffic is not generated on this attribute :"+Attribute) return main.FALSE else : return result except : main.log.error("operation failed because of"+str(sys.exc_info()[0])) return { 'result' : main.FALSE, 'error' : sys.exc_info()[0] }
chassisAddress = '172.33.42.4' slot = 4 port = 3 print "using //%s/%s/%s" % (chassisAddress, slot, port) #stc.connect('172.33.42.4') #stc.reserve('//172.33.42.4/4/3') print 'Create a Project - root' project = stc.create('project') print 'Get Project attributes' projectAtt = stc.get(project, 'name') print projectAtt print 'Create Ports under', project port1 = stc.create('port', under=project) print 'Configure Port locations' stc.config(port1, location="//%s/%s/%s" % (chassisAddress, slot, port)) print 'Creating StreamBlock on Port 1' streamBlock = stc.create('streamBlock', under=port1) generator = stc.get(port1, 'children-generator') print 'Attaching Ports...' stc.perform('AttachPorts', portList=[port1], autoConnect='TRUE')
from StcPython import StcPython stc = StcPython() labserverip = "192.168.130.207" sessionname = "test" username = "******" # Connect to an existing Lab Server session... print("Connecting to the Lab Server...") stc.perform("CSTestSessionConnect", host=labserverip, TestSessionName=sessionname, OwnerId=username, CreateNewTestSession="false") project = stc.get("system1", "children-project") # # Load from a configuration file, instead of connecting to an existing session. # print("DEBUG ONLY!") # stc.perform("LoadFromDatabaseCommand", DatabaseConnectionString="streamblock.tcc") # project = stc.get("system1", "children-project") # # Connect to the hardware. # stc.perform("AttachPorts", AutoConnect="true", PortList=stc.get(project, "children-port")) # stc.apply() stc.perform("GeneratorStart") time.sleep(5) rds = sbrds()
import sys sys.path.append('/home/mjefferson/spirent/stc/stc4.61/API/Python/') from StcPython import StcPython stc = StcPython() port_traffic1 = stc.create("port", under="project1") port_traffic2 = stc.create("port", under="project1") # NOTE: The FrameConfig PDUs are case-sensitive. # Examples are: EthernetII, Vlan, IPv4, IPv6, Mpls, Tcp, UDP, PPP, Gre, etc. There are many more. # Default: "EthernetII IPv4"} streamblock1 = stc.create("StreamBlock", under=port_traffic1, FrameConfig="EthernetII IPv4") stc.get(streamblock1) stc.config(streamblock1 + ".ethernet:EthernetII", srcMac="00:11:94:00:00:02", dstMac="00:12:94:00:00:02") stc.config(streamblock1 + ".ipv4:IPv4", sourceAddr="192.168.11.2", destAddr="192.168.12.2", gateway="192.168.11.1", prefixlength="24", destprefixlength="24") streamblock2 = stc.create("StreamBlock", under=port_traffic2, FrameConfig="EthernetII IPv4") stc.get(streamblock2) stc.config(streamblock2 + ".ethernet:EthernetII", srcMac="00:12:94:00:00:02",
############################################################################### #### #### Main #### ############################################################################### print("Connecting to Lab Server") stc.perform("CSTestSessionConnect", host=labserverip, TestSessionName=sessionname, OwnerId=username, CreateNewTestSession="false") project = stc.get("system1", "children-project") # Subscribe to port results. portrds = getRDS("GeneratorPortResults") if portrds == "": print("Subscribing to port results...") # Port results. These result objects are stored under the generator and analyzer objects. rds = stc.subscribe(Parent=project, ConfigType="Generator", resulttype="GeneratorPortResults") stc.create("ResultQuery", under=rds, ResultRootList=project, ConfigClassId="Analyzer", ResultClassId="AnalyzerPortResults")
# You first need to either set the environment variable "STC_PRIVATE_INSTALL_DIR", # or change the StcPython.py file ("STC_PRIVATE_INSTALL_DIR") to point to your # installation. # eg: os.environ['STC_PRIVATE_INSTALL_DIR'] = '/home/mjefferson/spirent/stc/stc4.59/' print "Loading the Spirent TestCenter API..." sys.path.append('/home/mjefferson/spirent/stc/stc4.59/API/Python') from StcPython import StcPython stc = StcPython() # Instruct the API to not display all commands to STDOUT. stc.config("AutomationOptions", logTo="stcapi.log", logLevel="INFO") # Create the configuration from scratch. print "Creating the configuration from scratch..." project = stc.get("system1", "children-project") # Start by creating two ports. port1 is the Tx port, and port2 is the Rx. port1 = stc.create("port", under=project, location="10.140.99.120/1/1") port2 = stc.create("port", under=project, location="10.140.99.121/1/1") # Create a single Emulated Device on each port. # The "IfStack" is the space-separated list of interface objects used by the device. # It is sorted top-down, meaning that the EthIIIf object will be the last element of the list. # eg: EthIIIf, VlanIf, IPv4If, IPv6If, GREIf, L2tpv2If, MplsIf, etc # The "IfCount" is a space-separated list indicating how many interface object instances to create for each # element of the IfStack. This list is ordered in the same way as the IfStack. # eg: IfStack="Ipv4If VlanIf EthIIIf", IfCount="2 2 1" will create two IPv4If, two VlanIf and one EthIIIf object. result = stc.perform("DeviceCreate", ParentList=project,
# Note that a viable Tcl environment must be available for the library to run # and that the Python Tkinter package must be installed. # The version of the TestCenter library that will be loaded will be determined # by normal Tcl package management. The easiest way to change versions will be # to set the TCLLIBPATH environment variable to point to the desired version # just like would be done in a normal Tcl installation. from StcPython import StcPython stc = StcPython() stc.log("INFO", "Starting Test") # This line will show the TestCenter commands on stdout #stc.config("automationoptions", logto="stdout", loglevel="INFO") # Retrieve and display the current API version. print "SpirentTestCenter system version:\t", stc.get("system1", "version") # Physical topology szChassisIp = "192.168.22.253" iTxSlot = 2 iTxPort = 1 iRxSlot = 2 iRxPort = 2 # Create the root project object print "Creating project ..." hProject = stc.create("project") # Create ports print "Creating ports ..." hPortTx = stc.create("port", under=hProject, location="//%s/%s/%s" % (szChassisIp, iTxSlot, iTxPort), useDefaultHost="False")
def main(): parser = argparse.ArgumentParser() # Required parameters requirednamed = parser.add_argument_group("required named arguments") requirednamed.add_argument("--lab_server_addr", required=True, help="The IP address of the Spirent Lab Server", dest="lab_server_addr") requirednamed.add_argument("--license_server_addr", required=True, help="The IP address of the Spirent License Server", dest="license_server_addr") requirednamed.add_argument("--east_chassis_addr", required=True, help="The TestCenter chassis IP address to use for the east test port", dest="east_chassis_addr") requirednamed.add_argument("--east_slot_num", type=positive_int, required=True, help="The TestCenter slot number to use for the east test port", dest="east_slot_num") requirednamed.add_argument("--east_port_num", type=positive_int, required=True, help="The TestCenter port number to use for the east test port", dest="east_port_num") requirednamed.add_argument("--west_chassis_addr", required=True, help="The TestCenter chassis IP address to use for the west test port", dest="west_chassis_addr") requirednamed.add_argument("--west_slot_num", type=positive_int, required=True, help="The TestCenter slot number to use for the west test port", dest="west_slot_num") requirednamed.add_argument("--west_port_num", type=positive_int, required=True, help="The TestCenter port number to use for the west test port", dest="west_port_num") # Optional parameters optionalnamed = parser.add_argument_group("optional named arguments") optionalnamed.add_argument("--test_session_name", required=False, default="RFC2544 East-West Throughput", help="The friendly name to identify the Spirent Lab Server test session", dest="test_session_name") optionalnamed.add_argument("--results_dir", required=False, default="./Results", help="The directory to copy results to", dest="results_dir") optionalnamed.add_argument("--csv_results_file_prefix", required=False, default="Rfc2544Tput", help="The prefix for the CSV results files", dest="csv_results_file_prefix") optionalnamed.add_argument("--num_trials", type=positive_int, required=False, default=1, help="The number of trials to execute during the test", dest="num_trials") optionalnamed.add_argument("--trial_duration_sec", type=positive_int, required=False, default=60, help="The duration of each trial executed during the test", dest="trial_duration_sec") optionalnamed.add_argument("--traffic_pattern", required=False, choices=["BACKBONE", "MESH", "PAIR"], default="PAIR", help="The traffic pattern between endpoints", dest="traffic_pattern") optionalnamed.add_argument("--search_mode", required=False, choices=["COMBO", "STEP", "BINARY"], default="BINARY", help="The search mode used to find the throughput rate", dest="search_mode") optionalnamed.add_argument("--learning_mode", required=False, choices=["AUTO", "L2_LEARNING", "L3_LEARNING", "NONE"], default="AUTO", help="The learning mode used during the test, default = 'NONE'", dest="learning_mode") optionalnamed.add_argument("--rate_lower_limit_pct", type=percent_float, required=False, default=1.0, help="The minimum percent line rate that will be used during the test", dest="rate_lower_limit_pct") optionalnamed.add_argument("--rate_upper_limit_pct", type=percent_float, required=False, default=99.0, help="The maximum percent line rate that will be used during the test", dest="rate_upper_limit_pct") optionalnamed.add_argument("--rate_initial_pct", type=percent_float, required=False, default=99.0, help="If Search Mode is BINARY, the percent line rate that will be used at the start of the test", dest="rate_initial_pct") optionalnamed.add_argument("--rate_step_pct", type=percent_float, required=False, default=10.0, help="If SearchMode is STEP, the percent load increase per step", dest="rate_step_pct") optionalnamed.add_argument("--resolution_pct", type=percent_float, required=False, default=1.0, help="The minimum percentage of load adjustment between iterations", dest="resolution_pct") optionalnamed.add_argument("--frame_size_list", type=lambda s: [int(item) for item in s.split(',')], required=False, default=[64, 128, 256], help="A comma-delimited list of frame sizes", dest="frame_size_list") optionalnamed.add_argument("--acceptable_frame_loss_pct", type=percent_float, required=False, default=0.0, help="The maximum acceptable frame loss percent in any iteration", dest="acceptable_frame_loss_pct") optionalnamed.add_argument("--east_intf_addr", required=False, default="192.85.1.3", help="The address to assign to the first emulated device interface on the first east port", dest="east_intf_addr") optionalnamed.add_argument("--east_intf_gateway_addr", required=False, default="192.85.1.53", help="The gateway address to assign to the first emulated device interface on the first east port", dest="east_intf_gateway_addr") optionalnamed.add_argument("--west_intf_addr", required=False, default="192.85.1.53", help="The address to assign to the first emulated device interface on the first west port", dest="west_intf_addr") optionalnamed.add_argument("--west_intf_gateway_addr", required=False, default="192.85.1.53", help="The gateway address to assign to the first emulated device interface on the first west port", dest="west_intf_gateway_addr") parser.add_argument("-v", "--verbose", required=False, default=False, help="More output during operation when present", action="store_true", dest="verbose") args = parser.parse_args() if args.verbose: print("Make sure results directory exists") create_dir(args.results_dir) # Load Spirent Test Center library from StcPython import StcPython stc = StcPython() tx_port_loc = "//%s/%s/%s" % (args.east_chassis_addr, args.east_slot_num, args.east_port_num) rx_port_loc = "//%s/%s/%s" % (args.west_chassis_addr, args.west_slot_num, args.west_port_num) # This line will write the TestCenter commands to a log file stc.config("automationoptions", logto="test-op", loglevel="DEBUG") # Retrieve and display the current API version. if args.verbose: print ("SpirentTestCenter system version: %s" % stc.get("system1", "version")) create_session(stc, args.lab_server_addr, args.test_session_name) try: device_list = [] if args.verbose: print("Bring up license server") license_mgr = stc.get("system1", "children-licenseservermanager") if args.verbose: print("license_mgr = %s" % license_mgr) stc.create("LicenseServer", under=license_mgr, server=args.license_server_addr) # Create the root project object if args.verbose: print ("Creating project ...") project = stc.get("System1", "children-Project") # Create ports if args.verbose: print ("Creating ports ...") east_chassis_port = stc.create("port", under=project, location=tx_port_loc, useDefaultHost="False") west_chassis_port = stc.create("port", under=project, location=rx_port_loc, useDefaultHost="False") if args.verbose: print ("Creating devices...") # Create emulated genparam for east port east_device_gen_params = stc.create("EmulatedDeviceGenParams", under=project, Port=east_chassis_port) # Create the DeviceGenEthIIIfParams object stc.create("DeviceGenEthIIIfParams", under=east_device_gen_params) # Configuring Ipv4 interfaces stc.create("DeviceGenIpv4IfParams", under=east_device_gen_params, Addr=args.east_intf_addr, Gateway=args.east_intf_gateway_addr) # Create Devices using the Device Wizard device_gen_config = stc.perform("DeviceGenConfigExpand", DeleteExisting="No", GenParams=east_device_gen_params) # Append to the device list device_list.append(device_gen_config['ReturnList']) # Create emulated genparam for west port west_device_gen_params = stc.create("EmulatedDeviceGenParams", under=project, Port=west_chassis_port) # Create the DeviceGenEthIIIfParams object stc.create("DeviceGenEthIIIfParams", under=west_device_gen_params) # Configuring Ipv4 interfaces stc.create("DeviceGenIpv4IfParams", under=west_device_gen_params, Addr=args.west_intf_addr, Gateway=args.west_intf_gateway_addr) # Create Devices using the Device Wizard device_gen_config = stc.perform("DeviceGenConfigExpand", DeleteExisting="No", GenParams=west_device_gen_params) # Append to the device list device_list.append(device_gen_config['ReturnList']) if args.verbose: print(device_list) # Create the RFC 2544 throughput test if args.verbose: print ("Set up the RFC2544 throughput test...") stc.perform("Rfc2544SetupThroughputTestCommand", AcceptableFrameLoss=args.acceptable_frame_loss_pct, Duration=args.trial_duration_sec, FrameSizeList=args.frame_size_list, LearningMode=args.learning_mode, NumOfTrials=args.num_trials, RateInitial=args.rate_initial_pct, RateLowerLimit=args.rate_lower_limit_pct, RateStep=args.rate_step_pct, RateUpperLimit=args.rate_upper_limit_pct, Resolution=args.resolution_pct, SearchMode=args.search_mode, TrafficPattern=args.traffic_pattern) # Save the configuration stc.perform("SaveToTcc", Filename="2544.tcc") # Connect to the hardware... stc.perform("AttachPorts", portList=stc.get("system1.project", "children-port"), autoConnect="TRUE") # Apply configuration. if args.verbose: print("Apply configuration...") stc.apply if args.verbose: print("Starting the sequencer...") stc.perform("SequencerStart") # Wait for sequencer to finish print("Starting test... Please wait for the test to complete...") stc.waitUntilComplete() print("The test has completed... Saving results...") # Determine what the results database filename is... lab_server_resultsdb = stc.get("system1.project.TestResultSetting", "CurrentResultFileName") if args.verbose: print("The lab server results database is %s" % lab_server_resultsdb) stc.perform("CSSynchronizeFiles", DefaultDownloadDir=args.results_dir) resultsdb = args.results_dir + lab_server_resultsdb.split("/Results")[1] print("The local summary DB file has been saved to %s" % resultsdb) # The returns the "RFC2544ThroughputTestResultDetailedSummaryView" table view from the results database. # There are other views available. resultsdict = stc.perform("QueryResult", DatabaseConnectionString=resultsdb, ResultPath="RFC2544ThroughputTestResultDetailedSummaryView") if args.verbose: print("resultsdict[\"Columns\"]: %s" % resultsdict["Columns"]) print("resultsdict[\"Output\"]: %s" % resultsdict["Output"]) if args.verbose: print("Result paths: %s" % stc.perform("GetTestResultSettingPaths")) # Write results to csv if args.verbose: print("Writing CSV file to results directory %s" % args.results_dir) write_query_results_to_csv(args.results_dir, args.csv_results_file_prefix, resultsdict) except Exception, e: print("Exception: %s" % str(e)) # destroy_session(stc, args.lab_server_addr, args.test_session_name) raise
OwnerId="matt", CreateNewTestSession="true") # Terminate the Lab Server session when the last client disconnects. stc.perform("TerminateBll", TerminateType="ON_LAST_DISCONNECT") if tcc_configuration: print "Loading TCC configuration ", tcc_configuration, ' loading it now' stc.perform("LoadFromDatabaseCommand", DatabaseConnectionString=tcc_configuration) # Re-enable logging. stc.config("AutomationOptions", logTo="stcapi.log", logLevel="INFO") project = stc.get("system1", "children-project") print "Project = ", project # This is an example of DDN notation. ports = stc.get("system1.project", "children-port").split(" ") #if stc.get("system1.project", "children-port") != "": # stc.config("system1.project.port(3)", name="blaw") port_traffic1 = ports[0] port_traffic2 = ports[1] # Find the Emulated Devices with the names "Traffic1" and "Traffic2". result = stc.perform("GetObjects", ClassName="EmulatedDevice",
# You first need to either set the environment variable "STC_PRIVATE_INSTALL_DIR", # or change the StcPython.py file ("STC_PRIVATE_INSTALL_DIR") to point to your # installation. # eg: os.environ['STC_PRIVATE_INSTALL_DIR'] = '/home/mjefferson/spirent/stc/stc4.59/' print "Loading the Spirent TestCenter API..." sys.path.append('/home/mjefferson/spirent/stc/stc4.59/API/Python') from StcPython import StcPython stc = StcPython() # Instruct the API to not display all log entries to STDOUT. stc.config("AutomationOptions", logTo="stcapi.log", logLevel="INFO") # Create the configuration from scratch. print "Creating the configuration from scratch..." project = stc.get("system1", "children-project") # Start by creating two ports. port1 is the Tx port, and port2 is the Rx. port1 = stc.create("port", under=project, location="10.140.99.120/1/1") ############################################################################### #### #### Method 1 : DeviceCreateCommand #### ############################################################################### # This is generally the easiest method. Simply execute a single command to # generate the device. There are many options available for the command that # allow you to customize what gets created. # Create three Emulated Devices (CreateCount=3), with each device having 8 unique
# Point to the StcPython.py file in your Spirent TestCenter installation. # You first need to either set the environment variable "STC_PRIVATE_INSTALL_DIR", # or change the StcPython.py file ("STC_PRIVATE_INSTALL_DIR") to point to your # installation. # eg: os.environ['STC_PRIVATE_INSTALL_DIR'] = '/home/mjefferson/spirent/stc/stc4.59/' print "Loading the Spirent TestCenter API..." sys.path.append('/home/mjefferson/spirent/stc/stc4.62/API/Python') from StcPython import StcPython stc = StcPython() # Instruct the API to not display all log entries to STDOUT. stc.config("AutomationOptions", logTo="stcapi.log", logLevel="INFO") # The project object always exists (no need to create it). project = stc.get("system1", "children-project") # Create a single port that we want to enable routing emulation on. port1 = stc.create("port", under=project, location="10.140.99.120/1/1") # Create an emulated device associated with the port. result = stc.perform("DeviceCreate", ParentList=project, DeviceType="Router", IfStack="Ipv4If EthIIIf", IfCount="1 1", Port=port1) emulateddevice = result["ReturnList"] ############################################################################### #### #### OSPF #### ############################################################################### # Enable OSPF on the emulated device and create a 2x3 Router LSA topology.