vstf/vstf/agent/spirent/tools.py

   1 ##############################################################################
   2 # Copyright (c) 2015 Huawei Technologies Co.,Ltd and others.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9
  10
  11 import time
  12 from spirent import stcPython
  13
  14 class Spirent_Tools(object):
  15     baseAPI = stcPython()
  16     def __init__(self):
  17         """This class provide API of Spirent
  18
  19         """
  20         super(Spirent_Tools, self).__init__()
  21
  22     def send_packet(self,flow):
  23         try:
  24             #import pdb
  25             #pdb.set_trace()
  26             flow = eval(flow)
  27             #stc init action
  28             self.baseAPI.stc_perform(' ResetConfig -config system1')
  29             self.baseAPI.stc_init()
  30             #create project
  31             project = self.baseAPI.stc_create_project()
  32             #create port
  33             port_handle = self.baseAPI.stc_create_port(project)
  34             #config port
  35             slot = flow['send_port'].split('/')[0]
  36             port = flow['send_port'].split('/')[1]
  37             self.baseAPI.stc_config_port_location(port_handle,flow['tester_ip'],slot,port)
  38             #create streamblock
  39             streamblock_handle = self.baseAPI.stc_create_streamblock(
  40                                                                  port_name  = port_handle,
  41                                                                  ExpectedRxPort = '',
  42                                                                  vlan_tag = flow['vlan'],
  43                                                                  srcMac = flow['src_mac'],
  44                                                                  dstMac = flow['dst_mac'],
  45                                                                  sourceAddr = flow['src_ip'],
  46                                                                  destAddr =flow['dst_ip']
  47                                                                  )
  48             # attach port
  49             port_list = [port_handle]
  50             self.baseAPI.stc_attach_ports(port_list)
  51             #start streamblock
  52             streamblock_list = [streamblock_handle]
  53             flag = self.baseAPI.stc_streamblock_start(streamblock_list)
  54             return str(streamblock_list).strip('[]')
  55         except :
  56             print("[ERROR]create stream block and send packet failed.")
  57             return False
  58
  59     def mac_learning(self,flowA,flowB):
  60         try:
  61             #import pdb
  62             #pdb.set_trace()
  63             flowA = eval(flowA)
  64             flowB = eval(flowB)
  65             port_list = []
  66             streamblock_list = []
  67             #stc init action
  68             self.baseAPI.stc_perform(' ResetConfig -config system1')
  69             self.baseAPI.stc_init()
  70             #create project
  71             project = self.baseAPI.stc_create_project()
  72             #create port and config port
  73             for flow in [ flowA,flowB ]:
  74                 flow['port_handle'] = self.baseAPI.stc_create_port(project)
  75                 tmp_test_ip = flow['tester_ip']
  76                 tmp_slot = flow['send_port'].split('/')[0]
  77                 tmp_port = flow['send_port'].split('/')[1]
  78                 self.baseAPI.stc_config_port_location(flow['port_handle'],tmp_test_ip,tmp_slot,tmp_port)
  79                 #create streamblock
  80                 flow['streamblock'] = self.baseAPI.stc_create_streamblock(port_name  = flow['port_handle'],
  81                                                                      ExpectedRxPort = '',
  82                                                                      vlan_tag = flow['vlan'],
  83                                                                      srcMac = flow['src_mac'],
  84                                                                      dstMac = flow['dst_mac'],
  85                                                                      sourceAddr = flow['src_ip'],
  86                                                                      destAddr =flow['dst_ip'])
  87                 #create port and stream block list
  88                 port_list.append(flow['port_handle'])
  89                 streamblock_list.append(flow['streamblock'])
  90
  91             #attach port
  92             self.baseAPI.stc_attach_ports(port_list)
  93             #start streamblock
  94             flag = self.baseAPI.stc_streamblock_start(streamblock_list)
  95             # mac learning
  96             time.sleep(2)
  97             # stop stream block
  98             self.baseAPI.stc_streamblock_stop(streamblock_list)
  99             # delete streamblock and release port
 100             for flow in [ flowA,flowB ]:
 101                 tmp_test_ip = flow['tester_ip']
 102                 tmp_slot = flow['send_port'].split('/')[0]
 103                 tmp_port = flow['send_port'].split('/')[1]
 104                 self.baseAPI.stc_delete(flow['streamblock'])
 105                 self.baseAPI.stc_release('%s/%s/%s' %(tmp_test_ip,tmp_slot,tmp_port))
 106             # delete project
 107             self.baseAPI.stc_delete('project1')
 108             ret = self.baseAPI.stc_perform('ResetConfig -config system1')
 109             return True
 110         except :
 111             print("[ERROR]mac learning failed")
 112             return False
 113
 114     def stop_flow(self,streamblock_list,flow):
 115         flow = eval(flow)
 116         streamblock_list = streamblock_list.strip('\'').split(',')
 117         #stop streamblock list
 118         try :
 119             ret = self.baseAPI.stc_streamblock_stop(streamblock_list)
 120         except :
 121             print("[ERROR]Stop the streamblock list failed.")
 122             return False
 123         #delete streamblock
 124         try :
 125             for streamblock in streamblock_list :
 126                 ret = self.baseAPI.stc_delete(streamblock)
 127         except :
 128             print("[ERROR]delete stream block.")
 129             return False
 130         #release port
 131         try :
 132             slot = flow['send_port'].split('/')[0]
 133             port = flow['send_port'].split('/')[1]
 134             ret = self.baseAPI.stc_release('%s/%s/%s' %(flow['tester_ip'],slot,port))
 135         except :
 136             print("[ERROR]Release port failed")
 137             return False
 138         ##delete project
 139         try :
 140             ret = self.baseAPI.stc_delete('project1')
 141             ret = self.baseAPI.stc_perform('ResetConfig -config system1')
 142             return True
 143         except :
 144             print("[ERROR]Delete project1 failed.")
 145             return False
 146
 147     def run_rfc2544_throughput(self,forward_init_flows,reverse_init_flows):
 148         #import pdb
 149         #pdb.set_trace()
 150         #rebuild the flows
 151         forward_init_flows = eval(forward_init_flows)
 152         reverse_init_flows = eval(reverse_init_flows)
 153         #stc init action
 154         self.baseAPI.stc_perform(' ResetConfig -config system1')
 155         self.baseAPI.stc_init()
 156         #create project
 157         project = self.baseAPI.stc_create_project()
 158         #create sequencer
 159         seq_handle = self.baseAPI.stc_create('Sequencer -under %s' %(project))
 160         #create port handle
 161         forward_port_handle = self.baseAPI.stc_create_port(project)
 162         reverse_port_handle = self.baseAPI.stc_create_port(project)
 163         #create forward flow streamblock
 164         for key in forward_init_flows.keys():
 165             forward_init_flows[key]['port_handle'] = forward_port_handle
 166             tmp_test_ip = forward_init_flows[key]['tester_ip']
 167             tmp_slot    = forward_init_flows[key]['send_port'].split('/')[0]
 168             tmp_port    = forward_init_flows[key]['send_port'].split('/')[1]
 169             self.baseAPI.stc_config_port_location(forward_init_flows[key]['port_handle'],tmp_test_ip,tmp_slot,tmp_port)
 170             #create streamblock
 171             forward_init_flows[key]['streamblock'] = self.baseAPI.stc_create_streamblock(port_name  = forward_init_flows[key]['port_handle'],
 172                                                                                      vlan_tag   = forward_init_flows[key]['vlan'],
 173                                                                                      ExpectedRxPort = reverse_port_handle,
 174                                                                                      srcMac     = forward_init_flows[key]['src_mac'],
 175                                                                                      dstMac     = forward_init_flows[key]['dst_mac'],
 176                                                                                      sourceAddr = forward_init_flows[key]['src_ip'],
 177                                                                                      destAddr   = forward_init_flows[key]['dst_ip'])
 178         #create reverse flow streamblock
 179         for key in reverse_init_flows.keys():
 180             reverse_init_flows[key]['port_handle'] = reverse_port_handle
 181             tmp_test_ip = reverse_init_flows[key]['tester_ip']
 182             tmp_slot    = reverse_init_flows[key]['send_port'].split('/')[0]
 183             tmp_port    = reverse_init_flows[key]['send_port'].split('/')[1]
 184             self.baseAPI.stc_config_port_location(reverse_init_flows[key]['port_handle'],tmp_test_ip,tmp_slot,tmp_port)
 185             #create streamblock
 186             reverse_init_flows[key]['streamblock'] = self.baseAPI.stc_create_streamblock(port_name  = reverse_init_flows[key]['port_handle'],
 187                                                                                      vlan_tag   = reverse_init_flows[key]['vlan'],
 188                                                                                      ExpectedRxPort = forward_port_handle,
 189                                                                                      srcMac     = reverse_init_flows[key]['src_mac'],
 190                                                                                      dstMac     = reverse_init_flows[key]['dst_mac'],
 191                                                                                      sourceAddr = reverse_init_flows[key]['src_ip'],
 192                                                                                      destAddr   = reverse_init_flows[key]['dst_ip'])
 193         #Create the RFC 2544 throughput test
 194         throughput_config = self.baseAPI.stc_create('Rfc2544ThroughputConfig -under ',project,
 195                                                 '-AcceptableFrameLoss 0.01',
 196                                                 '-NumOfTrials 1',
 197                                                 '-DurationSeconds 60',
 198                                                 '-SearchMode BINARY',
 199                                                 '-RateLowerLimit 1',
 200                                                 '-RateUpperLimit 100',
 201                                                 '-RateInitial 10',
 202                                                 '-UseExistingStreamBlocks True',
 203                                                 '-EnableLearning False',
 204                                                 '-FrameSizeIterationMode CUSTOM',
 205                                                 '-CustomFrameSizeList "70 128 256 512 1024 1280 1518"',
 206                                                 '-LatencyType LIFO',
 207                                                 '-EnableJitterMeasurement TRUE'
 208                                                 )
 209         #import pdb
 210         #pdb.set_trace()
 211         # list streamblocks
 212         streamblock_list = '" '
 213         for key in forward_init_flows.keys():
 214             streamblock_list = streamblock_list+forward_init_flows[key]['streamblock']+' '
 215         for key in reverse_init_flows.keys():
 216             streamblock_list = streamblock_list+reverse_init_flows[key]['streamblock']+' '
 217         streamblock_list = streamblock_list+'"'
 218
 219         throughput_sbProfile= self.baseAPI.stc_create('Rfc2544StreamBlockProfile -under '+throughput_config+' -Active TRUE -LocalActive TRUE')
 220         self.baseAPI.stc_config(throughput_sbProfile,'-StreamBlockList '+streamblock_list)
 221         self.baseAPI.stc_perform('ExpandBenchmarkConfigCommand','-config ',throughput_config)
 222
 223         #attach the port before testing
 224         port_list = [ forward_port_handle,reverse_port_handle]
 225         self.baseAPI.stc_attach_ports(port_list)
 226
 227         #stc apply and begin to sequence test
 228         self.baseAPI.stc_apply()
 229         self.baseAPI.stc_perform("SequencerStart")
 230
 231         #wait until complete
 232         self.baseAPI.stc_waituntilcomplete()
 233
 234         #get result db
 235         resultsdb = self.baseAPI.stc_get("system1.project.TestResultSetting", "-CurrentResultFileName")
 236         results_dict = self.baseAPI.stc_perform('QueryResult','-DatabaseConnectionString',resultsdb,'-ResultPath RFC2544ThroughputTestResultDetailedSummaryView')
 237         #print results_dict
 238         return True,results_dict
 239
 240     def run_rfc2544_frameloss(self,forward_init_flows,reverse_init_flows):
 241         #import pdb
 242         #pdb.set_trace()
 243         #rebuild the flows
 244         forward_init_flows = eval(forward_init_flows)
 245         reverse_init_flows = eval(reverse_init_flows)
 246         #stc init action
 247         self.baseAPI.stc_perform(' ResetConfig -config system1')
 248         self.baseAPI.stc_init()
 249         #create project
 250         project = self.baseAPI.stc_create_project()
 251         #create sequencer
 252         seq_handle = self.baseAPI.stc_create('Sequencer -under %s' %(project))
 253         #create port handle
 254         forward_port_handle = self.baseAPI.stc_create_port(project)
 255         reverse_port_handle = self.baseAPI.stc_create_port(project)
 256         #create forward flow streamblock
 257         for key in forward_init_flows.keys():
 258             forward_init_flows[key]['port_handle'] = forward_port_handle
 259             tmp_test_ip = forward_init_flows[key]['tester_ip']
 260             tmp_slot    = forward_init_flows[key]['send_port'].split('/')[0]
 261             tmp_port    = forward_init_flows[key]['send_port'].split('/')[1]
 262             self.baseAPI.stc_config_port_location(forward_init_flows[key]['port_handle'],tmp_test_ip,tmp_slot,tmp_port)
 263             #create streamblock
 264             forward_init_flows[key]['streamblock'] = self.baseAPI.stc_create_streamblock(port_name  = forward_init_flows[key]['port_handle'],
 265                                                                                      vlan_tag   = forward_init_flows[key]['vlan'],
 266                                                                                      ExpectedRxPort = reverse_port_handle,
 267                                                                                      srcMac     = forward_init_flows[key]['src_mac'],
 268                                                                                      dstMac     = forward_init_flows[key]['dst_mac'],
 269                                                                                      sourceAddr = forward_init_flows[key]['src_ip'],
 270                                                                                      destAddr   = forward_init_flows[key]['dst_ip'])
 271         #create reverse flow streamblock
 272         for key in reverse_init_flows.keys():
 273             reverse_init_flows[key]['port_handle'] = reverse_port_handle
 274             tmp_test_ip = reverse_init_flows[key]['tester_ip']
 275             tmp_slot    = reverse_init_flows[key]['send_port'].split('/')[0]
 276             tmp_port    = reverse_init_flows[key]['send_port'].split('/')[1]
 277             self.baseAPI.stc_config_port_location(reverse_init_flows[key]['port_handle'],tmp_test_ip,tmp_slot,tmp_port)
 278             #create streamblock
 279             reverse_init_flows[key]['streamblock'] = self.baseAPI.stc_create_streamblock(port_name  = reverse_init_flows[key]['port_handle'],
 280                                                                                      vlan_tag   = reverse_init_flows[key]['vlan'],
 281                                                                                      ExpectedRxPort = forward_port_handle,
 282                                                                                      srcMac     = reverse_init_flows[key]['src_mac'],
 283                                                                                      dstMac     = reverse_init_flows[key]['dst_mac'],
 284                                                                                      sourceAddr = reverse_init_flows[key]['src_ip'],
 285                                                                                      destAddr   = reverse_init_flows[key]['dst_ip'])
 286         #Create the RFC 2544 frameloss test
 287         frameloss_config = self.baseAPI.stc_create('Rfc2544FrameLossConfig -under ',project,
 288                                                 '-NumOfTrials 1 ',
 289                                                 '-DurationSeconds 60 ',
 290                                                 '-LoadUnits PERCENT_LINE_RATE ',
 291                                                 '-LoadType CUSTOM '
 292                                                 '-CustomLoadList 100 '
 293                                                 '-UseExistingStreamBlocks True ',
 294                                                 '-EnableLearning False ',
 295                                                 '-FrameSizeIterationMode CUSTOM ',
 296                                                 '-CustomFrameSizeList "70 128 256 512 1024 1280 1518"',
 297                                                 '-LatencyType LIFO',
 298                                                 '-EnableJitterMeasurement TRUE'
 299                                                 )
 300         #import pdb
 301         #pdb.set_trace()
 302         # list streamblocks
 303         streamblock_list = '" '
 304         for key in forward_init_flows.keys():
 305             streamblock_list = streamblock_list+forward_init_flows[key]['streamblock']+' '
 306         for key in reverse_init_flows.keys():
 307             streamblock_list = streamblock_list+reverse_init_flows[key]['streamblock']+' '
 308         streamblock_list = streamblock_list+'"'
 309
 310         frameloss_sbProfile= self.baseAPI.stc_create('Rfc2544StreamBlockProfile -under '+frameloss_config+' -Active TRUE -LocalActive TRUE')
 311         self.baseAPI.stc_config(frameloss_sbProfile,'-StreamBlockList '+streamblock_list)
 312         self.baseAPI.stc_perform('ExpandBenchmarkConfigCommand','-config ',frameloss_config)
 313
 314         #attach the port before testing
 315         port_list = [ forward_port_handle,reverse_port_handle]
 316         self.baseAPI.stc_attach_ports(port_list)
 317
 318         #stc apply and begin to sequence test
 319         self.baseAPI.stc_apply()
 320         self.baseAPI.stc_perform("SequencerStart")
 321
 322         #wait until complete
 323         self.baseAPI.stc_waituntilcomplete()
 324
 325         #get result db
 326         resultsdb = self.baseAPI.stc_get("system1.project.TestResultSetting", "-CurrentResultFileName")
 327         results_dict = self.baseAPI.stc_perform('QueryResult','-DatabaseConnectionString',resultsdb,'-ResultPath RFC2544FrameLossTestResultDetailedSummaryView')
 328         #import pdb
 329         #pdb.set_trace()
 330         return True,results_dict
 331
 332     def run_rfc2544_latency(self,forward_init_flows,reverse_init_flows):
 333         pass
 334