blob: ae2b89ccff00cb20f1a0b61ebe35cb1b6e3f2a19 [file] [log] [blame]
Devin Lim142b5342017-07-20 15:22:39 -07001"""
Jeremy Ronquillo23fb2162017-09-15 14:59:57 -07002Copyright 2016 Open Networking Foundation ( ONF )
Devin Lim142b5342017-07-20 15:22:39 -07003
4Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
5the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
6or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>
7
8 TestON is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 2 of the License, or
Jeremy Ronquillo23fb2162017-09-15 14:59:57 -070011 ( at your option ) any later version.
Devin Lim142b5342017-07-20 15:22:39 -070012
13 TestON is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with TestON. If not, see <http://www.gnu.org/licenses/>.
20"""
Devin Lim58046fa2017-07-05 16:55:00 -070021import time
22import re
23import imp
24import json
You Wang5da39c82018-04-26 22:55:08 -070025from core import utilities
Jeremy Ronquillo23fb2162017-09-15 14:59:57 -070026
27
Devin Lim58046fa2017-07-05 16:55:00 -070028class Topology:
29
30 def __init__( self ):
31 self.default = ''
Devin Lim142b5342017-07-20 15:22:39 -070032
Devin Lim58046fa2017-07-05 16:55:00 -070033 """
34 These functions can be used for topology comparisons
35 """
Devin Lim142b5342017-07-20 15:22:39 -070036 def getAll( self, function, needRetry=False, kwargs={}, inJson=False ):
Devin Lim58046fa2017-07-05 16:55:00 -070037 """
Devin Lim142b5342017-07-20 15:22:39 -070038 Description:
39 get all devices/links/hosts/ports of the onosCli
40 Required:
41 * function - name of the function
42 * needRetry - it will retry if this is true.
43 * kwargs - kwargs of the function
44 * inJson - True if want it in Json form
45 Returns:
46 Returns the list of the result.
Devin Lim58046fa2017-07-05 16:55:00 -070047 """
Devin Lim142b5342017-07-20 15:22:39 -070048 returnList = []
Devin Lim58046fa2017-07-05 16:55:00 -070049 threads = []
Jon Hallca319892017-06-15 15:25:22 -070050 for ctrl in main.Cluster.active():
Devin Lim142b5342017-07-20 15:22:39 -070051 func = getattr( ctrl.CLI, function )
52 t = main.Thread( target=utilities.retry if needRetry else func,
Jeremy Ronquillo23fb2162017-09-15 14:59:57 -070053 name=function + "-" + str( ctrl ),
Devin Lim142b5342017-07-20 15:22:39 -070054 args=[ func, [ None ] ] if needRetry else [],
Devin Lim58046fa2017-07-05 16:55:00 -070055 kwargs=kwargs )
56 threads.append( t )
57 t.start()
58
59 for t in threads:
60 t.join()
61 if inJson:
62 try:
Devin Lim142b5342017-07-20 15:22:39 -070063 returnList.append( json.loads( t.result ) )
Devin Lim58046fa2017-07-05 16:55:00 -070064 except ( ValueError, TypeError ):
65 main.log.exception( "Error parsing hosts results" )
66 main.log.error( repr( t.result ) )
Devin Lim142b5342017-07-20 15:22:39 -070067 returnList.append( None )
Devin Lim58046fa2017-07-05 16:55:00 -070068 else:
Devin Lim142b5342017-07-20 15:22:39 -070069 returnList.append( t.result )
70 return returnList
Devin Lim58046fa2017-07-05 16:55:00 -070071
72 def compareDevicePort( self, Mininet, controller, mnSwitches, devices, ports ):
Devin Lim142b5342017-07-20 15:22:39 -070073 """
74 Description:
75 compares the devices and port of the onos to the mininet.
76 Required:
77 * Mininet - mininet driver to use
78 * controller - controller position of the devices
79 * mnSwitches - switches of mininet
80 * devices - devices of the onos
81 * ports - ports of the onos
82 Returns:
83 Returns main.TRUE if the results are matching else
84 Returns main.FALSE
85 """
Devin Lim58046fa2017-07-05 16:55:00 -070086 if devices[ controller ] and ports[ controller ] and \
87 "Error" not in devices[ controller ] and \
88 "Error" not in ports[ controller ]:
89 try:
90 currentDevicesResult = Mininet.compareSwitches(
91 mnSwitches,
92 json.loads( devices[ controller ] ),
93 json.loads( ports[ controller ] ) )
Jon Hallca319892017-06-15 15:25:22 -070094 except ( TypeError, ValueError ):
Devin Lim58046fa2017-07-05 16:55:00 -070095 main.log.error(
Jon Hallca319892017-06-15 15:25:22 -070096 "Could not load json: {0} or {1}".format( str( devices[ controller ] ),
97 str( ports[ controller ] ) ) )
Devin Lim58046fa2017-07-05 16:55:00 -070098 currentDevicesResult = main.FALSE
99 else:
100 currentDevicesResult = main.FALSE
101 return currentDevicesResult
102
103 def compareBase( self, compareElem, controller, compareF, compareArg ):
Devin Lim142b5342017-07-20 15:22:39 -0700104 """
105 Description:
106 compares the links/hosts of the onos to the mininet.
107 Required:
108 * compareElem - list of links/hosts of the onos
109 * controller - controller position of the devices
110 * compareF - function of the mininet that will compare the
111 results
112 * compareArg - arg of the compareF.
113 Returns:
114 Returns main.TRUE if the results are matching else
115 Returns main.FALSE
116 """
Devin Lim58046fa2017-07-05 16:55:00 -0700117 if compareElem[ controller ] and "Error" not in compareElem[ controller ]:
118 try:
119 if isinstance( compareArg, list ):
120 compareArg.append( json.loads( compareElem[ controller ] ) )
121 else:
Jeremy Ronquillo23fb2162017-09-15 14:59:57 -0700122 compareArg = [ compareArg, json.loads( compareElem[ controller ] ) ]
Devin Lim58046fa2017-07-05 16:55:00 -0700123
124 currentCompareResult = compareF( *compareArg )
Jeremy Ronquillo23fb2162017-09-15 14:59:57 -0700125 except( TypeError, ValueError ):
Devin Lim58046fa2017-07-05 16:55:00 -0700126 main.log.error(
127 "Could not load json: {0} or {1}".format( str( compareElem[ controller ] ) ) )
128 currentCompareResult = main.FALSE
129 else:
130 currentCompareResult = main.FALSE
131
132 return currentCompareResult
133
Devin Lim0c972b72018-02-08 14:53:59 -0800134 def compareTopos( self, Mininet, attempts=1, includeCaseDesc=True ):
Devin Lim142b5342017-07-20 15:22:39 -0700135 """
136 Description:
137 compares the links and hosts and switches of the onos to the mininet.
138 Required:
139 * Mininet - Mininet driver to use.
140 * attempts - number of attempts to compare in case
141 the result is different after a certain time.
142 Returns:
143 Returns main.TRUE if the results are matching else
144 Returns main.FALSE
145 """
Devin Lim0c972b72018-02-08 14:53:59 -0800146 if includeCaseDesc:
147 main.case( "Compare ONOS Topology view to Mininet topology" )
148 main.caseExplanation = "Compare topology elements between Mininet" +\
149 " and ONOS"
Devin Lim58046fa2017-07-05 16:55:00 -0700150 main.log.info( "Gathering topology information from Mininet" )
151 devicesResults = main.FALSE # Overall Boolean for device correctness
152 linksResults = main.FALSE # Overall Boolean for link correctness
153 hostsResults = main.FALSE # Overall Boolean for host correctness
154 deviceFails = [] # Nodes where devices are incorrect
155 linkFails = [] # Nodes where links are incorrect
156 hostFails = [] # Nodes where hosts are incorrect
157
158 mnSwitches = Mininet.getSwitches()
159 mnLinks = Mininet.getLinks()
160 mnHosts = Mininet.getHosts()
161
162 main.step( "Comparing Mininet topology to ONOS topology" )
163
164 while ( attempts >= 0 ) and\
165 ( not devicesResults or not linksResults or not hostsResults ):
166 main.log.info( "Sleeping {} seconds".format( 2 ) )
167 time.sleep( 2 )
168 if not devicesResults:
Devin Lim142b5342017-07-20 15:22:39 -0700169 devices = self.getAll( "devices", False )
170 ports = self.getAll( "ports", False )
Devin Lim58046fa2017-07-05 16:55:00 -0700171 devicesResults = main.TRUE
172 deviceFails = [] # Reset for each failed attempt
173 if not linksResults:
Devin Lim142b5342017-07-20 15:22:39 -0700174 links = self.getAll( "links", False )
Devin Lim58046fa2017-07-05 16:55:00 -0700175 linksResults = main.TRUE
176 linkFails = [] # Reset for each failed attempt
177 if not hostsResults:
Devin Lim142b5342017-07-20 15:22:39 -0700178 hosts = self.getAll( "hosts", False )
Devin Lim58046fa2017-07-05 16:55:00 -0700179 hostsResults = main.TRUE
180 hostFails = [] # Reset for each failed attempt
181
182 # Check for matching topology on each node
Devin Lim142b5342017-07-20 15:22:39 -0700183 for controller in main.Cluster.getRunningPos():
Devin Lim58046fa2017-07-05 16:55:00 -0700184 controllerStr = str( controller + 1 ) # ONOS node number
185 # Compare Devices
186 currentDevicesResult = self.compareDevicePort( Mininet, controller,
Jon Hallca319892017-06-15 15:25:22 -0700187 mnSwitches,
188 devices, ports )
Devin Lim58046fa2017-07-05 16:55:00 -0700189 if not currentDevicesResult:
190 deviceFails.append( controllerStr )
191 devicesResults = devicesResults and currentDevicesResult
192 # Compare Links
193 currentLinksResult = self.compareBase( links, controller,
Jon Hallca319892017-06-15 15:25:22 -0700194 Mininet.compareLinks,
195 [ mnSwitches, mnLinks ] )
Devin Lim58046fa2017-07-05 16:55:00 -0700196 if not currentLinksResult:
197 linkFails.append( controllerStr )
198 linksResults = linksResults and currentLinksResult
199 # Compare Hosts
200 currentHostsResult = self.compareBase( hosts, controller,
201 Mininet.compareHosts,
202 mnHosts )
203 if not currentHostsResult:
204 hostFails.append( controllerStr )
205 hostsResults = hostsResults and currentHostsResult
206 # Decrement Attempts Remaining
207 attempts -= 1
208
209 utilities.assert_equals( expect=[],
210 actual=deviceFails,
211 onpass="ONOS correctly discovered all devices",
212 onfail="ONOS incorrectly discovered devices on nodes: " +
213 str( deviceFails ) )
214 utilities.assert_equals( expect=[],
215 actual=linkFails,
216 onpass="ONOS correctly discovered all links",
217 onfail="ONOS incorrectly discovered links on nodes: " +
218 str( linkFails ) )
219 utilities.assert_equals( expect=[],
220 actual=hostFails,
221 onpass="ONOS correctly discovered all hosts",
222 onfail="ONOS incorrectly discovered hosts on nodes: " +
223 str( hostFails ) )
224 topoResults = hostsResults and linksResults and devicesResults
225 utilities.assert_equals( expect=main.TRUE,
226 actual=topoResults,
227 onpass="ONOS correctly discovered the topology",
228 onfail="ONOS incorrectly discovered the topology" )
Devin Lim142b5342017-07-20 15:22:39 -0700229 return topoResults
You Wang5da39c82018-04-26 22:55:08 -0700230
You Wang0fa76e72018-05-18 11:33:25 -0700231 def ping( self, srcList, dstList, ipv6=False, expect=True, wait=1, acceptableFailed=0, collectT3=True, t3Simple=False ):
You Wang5da39c82018-04-26 22:55:08 -0700232 """
233 Description:
234 Ping from every host in srcList to every host in dstList and
235 verify if ping results are as expected.
236 Pings are executed in parallel from host components
237 Options:
238 src: a list of source host names, e.g. [ "h1", "h2" ]
239 dst: a list of destination host names, e.g. [ "h3", "h4" ]
240 expect: expect ping result to pass if True, otherwise fail
241 acceptableFailed: maximum number of failed pings acceptable for
242 each src-dst host pair
243 collectT3: save t3-troubleshoot output for src and dst host that failed to ping
You Wang0fa76e72018-05-18 11:33:25 -0700244 t3Simple: use t3-troubleshoot-simple command when collecting t3 output
You Wang5da39c82018-04-26 22:55:08 -0700245 Returns:
246 main.TRUE if all ping results are expected, otherwise main.FALSE
247 """
248 main.log.info( "Pinging from {} to {}, expected result is {}".format( srcList, dstList,
249 "pass" if expect else "fail" ) )
250 # Verify host component has been created
251 srcIpList = {}
252 for src in srcList:
253 if not hasattr( main, src ):
254 main.log.info( "Creating component for host {}".format( src ) )
255 main.Network.createHostComponent( src )
256 hostHandle = getattr( main, src )
257 main.log.info( "Starting CLI on host {}".format( src ) )
258 hostHandle.startHostCli()
259 srcIpList[ src ] = main.Network.getIPAddress( src, proto='IPV6' if ipv6 else 'IPV4' )
You Wang5da39c82018-04-26 22:55:08 -0700260 unexpectedPings = []
261 for dst in dstList:
262 dstIp = main.Network.getIPAddress( dst, proto='IPV6' if ipv6 else 'IPV4' )
263 # Start pings from src hosts in parallel
264 pool = []
265 for src in srcList:
266 srcIp = srcIpList[ src ]
You Wangbe98fb12018-05-24 16:15:17 -0700267 if not srcIp or not dstIp:
268 if expect:
269 unexpectedPings.append( [ src, dst, "no IP" ] )
You Wang5da39c82018-04-26 22:55:08 -0700270 continue
You Wangbe98fb12018-05-24 16:15:17 -0700271 if srcIp == dstIp:
You Wang5da39c82018-04-26 22:55:08 -0700272 continue
273 hostHandle = getattr( main, src )
274 thread = main.Thread( target=utilities.retry,
275 name="{}-{}".format( srcIp, dstIp ),
276 args=[ hostHandle.pingHostSetAlternative, [ main.FALSE ] ],
You Wangc564c6f2018-05-01 15:24:57 -0700277 kwargs={ "args": ( [ dstIp ], wait, ipv6 ),
You Wang5da39c82018-04-26 22:55:08 -0700278 "attempts": acceptableFailed + 1,
279 "sleep": 1 } )
280 pool.append( thread )
281 thread.start()
282 # Wait for threads to finish and check ping result
283 for thread in pool:
284 thread.join( 10 )
285 srcIp, dstIp = thread.name.split( "-" )
286 if expect and not thread.result or not expect and thread.result:
287 unexpectedPings.append( [ srcIp, dstIp, "fail" if expect else "pass" ] )
You Wang85747762018-05-11 15:51:50 -0700288 main.log.info( "Unexpected pings: {}".format( unexpectedPings ) )
You Wang5da39c82018-04-26 22:55:08 -0700289 if collectT3:
290 for unexpectedPing in unexpectedPings:
291 if unexpectedPing[ 2 ] == "no IP":
292 continue
293 srcIp = unexpectedPing[ 0 ]
294 dstIp = unexpectedPing[ 1 ]
295 main.log.debug( "Collecting t3 with source {} and destination {}".format( srcIp, dstIp ) )
You Wang54b1d672018-06-11 16:44:13 -0700296 cmdList = main.Cluster.active( 0 ).CLI.composeT3Command( srcIp, dstIp, ipv6, True, t3Simple )
297 if not cmdList:
298 main.log.warn( "Failed to compose T3 command with source {} and destination {}".format( srcIp, dstIp ) )
299 continue
300 for i in range( 0, len( cmdList ) ):
301 cmd = cmdList[ i ]
302 main.log.debug( "t3 command: {}".format( cmd ) )
You Wang5da39c82018-04-26 22:55:08 -0700303 main.ONOSbench.dumpONOSCmd( main.Cluster.active( 0 ).ipAddress, cmd, main.logdir,
You Wang54b1d672018-06-11 16:44:13 -0700304 "t3-CASE{}-{}-{}-route{}-".format( main.CurrentTestCaseNumber, srcIp, dstIp, i ),
305 timeout=10 )
You Wang5da39c82018-04-26 22:55:08 -0700306 return main.FALSE if unexpectedPings else main.TRUE
You Wangc564c6f2018-05-01 15:24:57 -0700307
308 def sendScapyPackets( self, sender, receiver, pktFilter, pkt, sIface=None, dIface=None, expect=True, acceptableFailed=0, collectT3=True, t3Command="" ):
309 """
310 Description:
You Wang2cb70172018-07-25 16:44:13 -0700311 Send Scapy packets from sender to receiver and verify if result is as expected and retry if neccessary
You Wangc564c6f2018-05-01 15:24:57 -0700312 If collectT3 is True and t3Command is specified, collect t3-troubleshoot output on unexpected scapy results
You Wangc564c6f2018-05-01 15:24:57 -0700313 Options:
314 sender: the component of the host that is sending packets
315 receiver: the component of the host that is receiving packets
316 pktFilter: packet filter used by receiver
317 pkt: keyword that is expected to be conrained in the received packets
318 expect: expect receiver to receive the packet if True, otherwise not receiving the packet
319 acceptableFailed: maximum number of unexpected scapy results acceptable
320 collectT3: save t3-troubleshoot output for unexpected scapy results
321 Returns:
322 main.TRUE if scapy result is expected, otherwise main.FALSE
You Wang2cb70172018-07-25 16:44:13 -0700323 Note: It is assumed that Scapy is already started on the destination host
You Wangc564c6f2018-05-01 15:24:57 -0700324 """
325 main.log.info( "Sending scapy packets from {} to {}, expected result is {}".format( sender.name, receiver.name,
326 "pass" if expect else "fail" ) )
You Wang2cb70172018-07-25 16:44:13 -0700327 scapyResult = utilities.retry( self.sendScapyPacketsHelper,
You Wangc564c6f2018-05-01 15:24:57 -0700328 main.FALSE,
329 args=( sender, receiver, pktFilter, pkt,
330 sIface, dIface, expect ),
331 attempts=acceptableFailed + 1,
332 sleep=1 )
333 if not scapyResult and collectT3 and t3Command:
334 main.log.debug( "Collecting t3 with source {} and destination {}".format( sender.name, receiver.name ) )
335 main.log.debug( "t3 command: {}".format( t3Command ) )
336 main.ONOSbench.dumpONOSCmd( main.Cluster.active( 0 ).ipAddress, t3Command, main.logdir,
337 "t3-CASE{}-{}-{}-".format( main.CurrentTestCaseNumber, sender.name, receiver.name ) )
338 return scapyResult
339
You Wang2cb70172018-07-25 16:44:13 -0700340 def sendScapyPacketsHelper( self, sender, receiver, pktFilter, pkt, sIface=None, dIface=None, expect=True ):
You Wangc564c6f2018-05-01 15:24:57 -0700341 """
342 Description:
343 Send Scapy packets from sender to receiver and verify if result is as expected
344 Options:
345 sender: the component of the host that is sending packets
346 receiver: the component of the host that is receiving packets
347 pktFilter: packet filter used by receiver
348 pkt: keyword that is expected to be conrained in the received packets
349 expect: expect receiver to receive the packet if True, otherwise not receiving the packet
350 Returns:
351 main.TRUE if scapy result is expected, otherwise main.FALSE
352 """
You Wang3a5f74c2018-08-03 14:58:15 -0700353 started = receiver.startFilter( ifaceName=dIface, pktFilter=pktFilter )
354 if not started:
355 main.log.error("Failed to start Scapy packet filter")
356 return main.FALSE
You Wangc564c6f2018-05-01 15:24:57 -0700357 sender.sendPacket( iface=sIface )
358 finished = receiver.checkFilter()
359 packet = ""
360 if finished:
361 packets = receiver.readPackets()
362 for packet in packets.splitlines():
363 main.log.debug( packet )
364 else:
365 kill = receiver.killFilter()
366 main.log.debug( kill )
367 sender.handle.sendline( "" )
368 sender.handle.expect( sender.scapyPrompt )
369 main.log.debug( sender.handle.before )
370 packetCaptured = True if pkt in packet else False
371 return main.TRUE if packetCaptured == expect else main.FALSE
You Wang2cb70172018-07-25 16:44:13 -0700372
373 def pingAndCapture( self, srcHost, dstIp, dstHost, dstIntf, ipv6=False, expect=True, acceptableFailed=0, collectT3=True, t3Simple=False ):
374 """
375 Description:
376 Ping from src host to dst IP and capture packets at dst Host using Scapy and retry if neccessary
377 If collectT3 is True, collect t3-troubleshoot output on unexpected scapy results
378 Options:
379 srcHost: name of the source host
380 dstIp: destination IP of the ping packets
381 dstHost: host that runs Scapy to capture the packets
382 dstIntf: name of the interface on the destination host
383 ipv6: ping with IPv6 if True; Otherwise IPv4
384 expect: use True if the ping is expected to be captured at destination;
385 Otherwise False
386 acceptableFailed: maximum number of failed pings acceptable
387 collectT3: save t3-troubleshoot output for src and dst host that failed to ping
388 t3Simple: use t3-troubleshoot-simple command when collecting t3 output
389 Returns:
390 main.TRUE if packet capturing result is expected, otherwise main.FALSE
391 Note: It is assumed that Scapy is already started on the destination host
392 """
393 main.log.info( "Pinging from {} to {}, expected {} capture the packet at {}".format( srcHost, dstIp,
394 "to" if expect else "not to", dstHost ) )
395 # Verify host component has been created
396 if not hasattr( main, srcHost ):
397 main.log.info( "Creating component for host {}".format( srcHost ) )
398 main.Network.createHostComponent( srcHost )
399 srcHandle = getattr( main, srcHost )
400 main.log.info( "Starting CLI on host {}".format( srcHost ) )
401 srcHandle.startHostCli()
402 trafficResult = utilities.retry( self.pingAndCaptureHelper,
403 main.FALSE,
404 args=( srcHost, dstIp, dstHost, dstIntf, ipv6, expect ),
405 attempts=acceptableFailed + 1,
406 sleep=1 )
407 if not trafficResult and collectT3:
408 srcIp = main.Network.getIPAddress( srcHost, proto='IPV6' if ipv6 else 'IPV4' )
409 main.log.debug( "Collecting t3 with source {} and destination {}".format( srcIp, dstIp ) )
410 cmdList = main.Cluster.active( 0 ).CLI.composeT3Command( srcIp, dstIp, ipv6, True, t3Simple )
411 if not cmdList:
412 main.log.warn( "Failed to compose T3 command with source {} and destination {}".format( srcIp, dstIp ) )
413 for i in range( 0, len( cmdList ) ):
414 cmd = cmdList[ i ]
415 main.log.debug( "t3 command: {}".format( cmd ) )
416 main.ONOSbench.dumpONOSCmd( main.Cluster.active( 0 ).ipAddress, cmd, main.logdir,
417 "t3-CASE{}-{}-{}-route{}-".format( main.CurrentTestCaseNumber, srcIp, dstIp, i ),
418 timeout=10 )
419 return trafficResult
420
421 def pingAndCaptureHelper( self, srcHost, dstIp, dstHost, dstIntf, ipv6=False, expect=True ):
422 """
423 Description:
424 Ping from src host to dst IP and capture packets at dst Host using Scapy
425 Options:
426 srcHost: name of the source host
427 dstIp: destination IP of the ping packets
428 dstHost: host that runs Scapy to capture the packets
429 dstIntf: name of the interface on the destination host
430 ipv6: ping with IPv6 if True; Otherwise IPv4
431 expect: use True if the ping is expected to be captured at destination;
432 Otherwise False
433 Returns:
434 main.TRUE if packet capturing result is expected, otherwise main.FALSE
435 """
436 packetCaptured = True
437 srcHandle = getattr( main, srcHost )
438 dstHandle = getattr( main, dstHost )
You Wangaec6a092018-08-06 15:36:31 -0700439 pktFilter = "ip6 host {}".format( dstIp ) if ipv6 else "ip host {}".format( dstIp )
440 started = dstHandle.startFilter( ifaceName=dstIntf, pktFilter=pktFilter )
You Wang3a5f74c2018-08-03 14:58:15 -0700441 if not started:
442 main.log.error("Failed to start Scapy packet filter")
443 return main.FALSE
You Wang2cb70172018-07-25 16:44:13 -0700444 srcHandle.pingHostSetAlternative( [ dstIp ], IPv6=ipv6 )
445 finished = dstHandle.checkFilter()
446 packet = ""
447 if finished:
448 packets = dstHandle.readPackets()
449 for packet in packets.splitlines():
450 main.log.debug( packet )
451 else:
452 kill = dstHandle.killFilter()
453 main.log.debug( kill )
454 packetCaptured = True if "dst={}".format( dstIp ) in packet else False
455 return main.TRUE if packetCaptured == expect else main.FALSE