blob: 720bf9291a031f521e7efc2f0196f9a8b5c3fd53 [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 )
You Wang0fc21702018-11-02 17:49:18 -0700257 if hasattr( main, 'Mininet1' ):
258 main.log.info( "Starting CLI on host {}".format( src ) )
259 hostHandle.startHostCli()
260 else:
261 hostHandle.connectInband()
You Wang5da39c82018-04-26 22:55:08 -0700262 srcIpList[ src ] = main.Network.getIPAddress( src, proto='IPV6' if ipv6 else 'IPV4' )
You Wang5da39c82018-04-26 22:55:08 -0700263 unexpectedPings = []
264 for dst in dstList:
265 dstIp = main.Network.getIPAddress( dst, proto='IPV6' if ipv6 else 'IPV4' )
266 # Start pings from src hosts in parallel
267 pool = []
268 for src in srcList:
269 srcIp = srcIpList[ src ]
You Wangbe98fb12018-05-24 16:15:17 -0700270 if not srcIp or not dstIp:
271 if expect:
272 unexpectedPings.append( [ src, dst, "no IP" ] )
You Wang5da39c82018-04-26 22:55:08 -0700273 continue
You Wangbe98fb12018-05-24 16:15:17 -0700274 if srcIp == dstIp:
You Wang5da39c82018-04-26 22:55:08 -0700275 continue
276 hostHandle = getattr( main, src )
277 thread = main.Thread( target=utilities.retry,
278 name="{}-{}".format( srcIp, dstIp ),
279 args=[ hostHandle.pingHostSetAlternative, [ main.FALSE ] ],
You Wangc564c6f2018-05-01 15:24:57 -0700280 kwargs={ "args": ( [ dstIp ], wait, ipv6 ),
You Wang5da39c82018-04-26 22:55:08 -0700281 "attempts": acceptableFailed + 1,
282 "sleep": 1 } )
283 pool.append( thread )
284 thread.start()
285 # Wait for threads to finish and check ping result
286 for thread in pool:
287 thread.join( 10 )
288 srcIp, dstIp = thread.name.split( "-" )
289 if expect and not thread.result or not expect and thread.result:
290 unexpectedPings.append( [ srcIp, dstIp, "fail" if expect else "pass" ] )
You Wang85747762018-05-11 15:51:50 -0700291 main.log.info( "Unexpected pings: {}".format( unexpectedPings ) )
You Wang5da39c82018-04-26 22:55:08 -0700292 if collectT3:
293 for unexpectedPing in unexpectedPings:
294 if unexpectedPing[ 2 ] == "no IP":
295 continue
296 srcIp = unexpectedPing[ 0 ]
297 dstIp = unexpectedPing[ 1 ]
298 main.log.debug( "Collecting t3 with source {} and destination {}".format( srcIp, dstIp ) )
You Wang54b1d672018-06-11 16:44:13 -0700299 cmdList = main.Cluster.active( 0 ).CLI.composeT3Command( srcIp, dstIp, ipv6, True, t3Simple )
300 if not cmdList:
301 main.log.warn( "Failed to compose T3 command with source {} and destination {}".format( srcIp, dstIp ) )
302 continue
303 for i in range( 0, len( cmdList ) ):
304 cmd = cmdList[ i ]
305 main.log.debug( "t3 command: {}".format( cmd ) )
You Wang5da39c82018-04-26 22:55:08 -0700306 main.ONOSbench.dumpONOSCmd( main.Cluster.active( 0 ).ipAddress, cmd, main.logdir,
You Wang54b1d672018-06-11 16:44:13 -0700307 "t3-CASE{}-{}-{}-route{}-".format( main.CurrentTestCaseNumber, srcIp, dstIp, i ),
308 timeout=10 )
You Wang5da39c82018-04-26 22:55:08 -0700309 return main.FALSE if unexpectedPings else main.TRUE
You Wangc564c6f2018-05-01 15:24:57 -0700310
311 def sendScapyPackets( self, sender, receiver, pktFilter, pkt, sIface=None, dIface=None, expect=True, acceptableFailed=0, collectT3=True, t3Command="" ):
312 """
313 Description:
You Wang2cb70172018-07-25 16:44:13 -0700314 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 -0700315 If collectT3 is True and t3Command is specified, collect t3-troubleshoot output on unexpected scapy results
You Wangc564c6f2018-05-01 15:24:57 -0700316 Options:
317 sender: the component of the host that is sending packets
318 receiver: the component of the host that is receiving packets
319 pktFilter: packet filter used by receiver
320 pkt: keyword that is expected to be conrained in the received packets
321 expect: expect receiver to receive the packet if True, otherwise not receiving the packet
322 acceptableFailed: maximum number of unexpected scapy results acceptable
323 collectT3: save t3-troubleshoot output for unexpected scapy results
324 Returns:
325 main.TRUE if scapy result is expected, otherwise main.FALSE
You Wang2cb70172018-07-25 16:44:13 -0700326 Note: It is assumed that Scapy is already started on the destination host
You Wangc564c6f2018-05-01 15:24:57 -0700327 """
328 main.log.info( "Sending scapy packets from {} to {}, expected result is {}".format( sender.name, receiver.name,
329 "pass" if expect else "fail" ) )
You Wang2cb70172018-07-25 16:44:13 -0700330 scapyResult = utilities.retry( self.sendScapyPacketsHelper,
You Wangc564c6f2018-05-01 15:24:57 -0700331 main.FALSE,
332 args=( sender, receiver, pktFilter, pkt,
333 sIface, dIface, expect ),
334 attempts=acceptableFailed + 1,
335 sleep=1 )
336 if not scapyResult and collectT3 and t3Command:
337 main.log.debug( "Collecting t3 with source {} and destination {}".format( sender.name, receiver.name ) )
338 main.log.debug( "t3 command: {}".format( t3Command ) )
339 main.ONOSbench.dumpONOSCmd( main.Cluster.active( 0 ).ipAddress, t3Command, main.logdir,
340 "t3-CASE{}-{}-{}-".format( main.CurrentTestCaseNumber, sender.name, receiver.name ) )
341 return scapyResult
342
You Wang2cb70172018-07-25 16:44:13 -0700343 def sendScapyPacketsHelper( self, sender, receiver, pktFilter, pkt, sIface=None, dIface=None, expect=True ):
You Wangc564c6f2018-05-01 15:24:57 -0700344 """
345 Description:
346 Send Scapy packets from sender to receiver and verify if result is as expected
347 Options:
348 sender: the component of the host that is sending packets
349 receiver: the component of the host that is receiving packets
350 pktFilter: packet filter used by receiver
351 pkt: keyword that is expected to be conrained in the received packets
352 expect: expect receiver to receive the packet if True, otherwise not receiving the packet
353 Returns:
354 main.TRUE if scapy result is expected, otherwise main.FALSE
355 """
You Wang3a5f74c2018-08-03 14:58:15 -0700356 started = receiver.startFilter( ifaceName=dIface, pktFilter=pktFilter )
357 if not started:
358 main.log.error("Failed to start Scapy packet filter")
359 return main.FALSE
You Wangc564c6f2018-05-01 15:24:57 -0700360 sender.sendPacket( iface=sIface )
361 finished = receiver.checkFilter()
362 packet = ""
363 if finished:
364 packets = receiver.readPackets()
365 for packet in packets.splitlines():
366 main.log.debug( packet )
367 else:
368 kill = receiver.killFilter()
369 main.log.debug( kill )
370 sender.handle.sendline( "" )
371 sender.handle.expect( sender.scapyPrompt )
372 main.log.debug( sender.handle.before )
373 packetCaptured = True if pkt in packet else False
374 return main.TRUE if packetCaptured == expect else main.FALSE
You Wang2cb70172018-07-25 16:44:13 -0700375
376 def pingAndCapture( self, srcHost, dstIp, dstHost, dstIntf, ipv6=False, expect=True, acceptableFailed=0, collectT3=True, t3Simple=False ):
377 """
378 Description:
379 Ping from src host to dst IP and capture packets at dst Host using Scapy and retry if neccessary
380 If collectT3 is True, collect t3-troubleshoot output on unexpected scapy results
381 Options:
382 srcHost: name of the source host
383 dstIp: destination IP of the ping packets
384 dstHost: host that runs Scapy to capture the packets
385 dstIntf: name of the interface on the destination host
386 ipv6: ping with IPv6 if True; Otherwise IPv4
387 expect: use True if the ping is expected to be captured at destination;
388 Otherwise False
389 acceptableFailed: maximum number of failed pings acceptable
390 collectT3: save t3-troubleshoot output for src and dst host that failed to ping
391 t3Simple: use t3-troubleshoot-simple command when collecting t3 output
392 Returns:
393 main.TRUE if packet capturing result is expected, otherwise main.FALSE
394 Note: It is assumed that Scapy is already started on the destination host
395 """
396 main.log.info( "Pinging from {} to {}, expected {} capture the packet at {}".format( srcHost, dstIp,
397 "to" if expect else "not to", dstHost ) )
398 # Verify host component has been created
399 if not hasattr( main, srcHost ):
400 main.log.info( "Creating component for host {}".format( srcHost ) )
401 main.Network.createHostComponent( srcHost )
402 srcHandle = getattr( main, srcHost )
403 main.log.info( "Starting CLI on host {}".format( srcHost ) )
404 srcHandle.startHostCli()
405 trafficResult = utilities.retry( self.pingAndCaptureHelper,
406 main.FALSE,
407 args=( srcHost, dstIp, dstHost, dstIntf, ipv6, expect ),
408 attempts=acceptableFailed + 1,
409 sleep=1 )
410 if not trafficResult and collectT3:
411 srcIp = main.Network.getIPAddress( srcHost, proto='IPV6' if ipv6 else 'IPV4' )
412 main.log.debug( "Collecting t3 with source {} and destination {}".format( srcIp, dstIp ) )
413 cmdList = main.Cluster.active( 0 ).CLI.composeT3Command( srcIp, dstIp, ipv6, True, t3Simple )
414 if not cmdList:
415 main.log.warn( "Failed to compose T3 command with source {} and destination {}".format( srcIp, dstIp ) )
416 for i in range( 0, len( cmdList ) ):
417 cmd = cmdList[ i ]
418 main.log.debug( "t3 command: {}".format( cmd ) )
419 main.ONOSbench.dumpONOSCmd( main.Cluster.active( 0 ).ipAddress, cmd, main.logdir,
420 "t3-CASE{}-{}-{}-route{}-".format( main.CurrentTestCaseNumber, srcIp, dstIp, i ),
421 timeout=10 )
422 return trafficResult
423
424 def pingAndCaptureHelper( self, srcHost, dstIp, dstHost, dstIntf, ipv6=False, expect=True ):
425 """
426 Description:
427 Ping from src host to dst IP and capture packets at dst Host using Scapy
428 Options:
429 srcHost: name of the source host
430 dstIp: destination IP of the ping packets
431 dstHost: host that runs Scapy to capture the packets
432 dstIntf: name of the interface on the destination host
433 ipv6: ping with IPv6 if True; Otherwise IPv4
434 expect: use True if the ping is expected to be captured at destination;
435 Otherwise False
436 Returns:
437 main.TRUE if packet capturing result is expected, otherwise main.FALSE
438 """
439 packetCaptured = True
440 srcHandle = getattr( main, srcHost )
441 dstHandle = getattr( main, dstHost )
You Wangaec6a092018-08-06 15:36:31 -0700442 pktFilter = "ip6 host {}".format( dstIp ) if ipv6 else "ip host {}".format( dstIp )
443 started = dstHandle.startFilter( ifaceName=dstIntf, pktFilter=pktFilter )
You Wang3a5f74c2018-08-03 14:58:15 -0700444 if not started:
445 main.log.error("Failed to start Scapy packet filter")
446 return main.FALSE
You Wang2cb70172018-07-25 16:44:13 -0700447 srcHandle.pingHostSetAlternative( [ dstIp ], IPv6=ipv6 )
448 finished = dstHandle.checkFilter()
449 packet = ""
450 if finished:
451 packets = dstHandle.readPackets()
452 for packet in packets.splitlines():
453 main.log.debug( packet )
454 else:
455 kill = dstHandle.killFilter()
456 main.log.debug( kill )
457 packetCaptured = True if "dst={}".format( dstIp ) in packet else False
458 return main.TRUE if packetCaptured == expect else main.FALSE