blob: dcd045bfcdbbca99625f43b4ad6c4868c4a9f95b [file] [log] [blame]
andrewonlab95ce8322014-10-13 14:12:04 -04001#!/usr/bin/env python
2
kelvin8ec71442015-01-15 16:57:00 -08003"""
andrewonlab95ce8322014-10-13 14:12:04 -04004This driver enters the onos> prompt to issue commands.
5
kelvin8ec71442015-01-15 16:57:00 -08006Please follow the coding style demonstrated by existing
andrewonlab95ce8322014-10-13 14:12:04 -04007functions and document properly.
8
9If you are a contributor to the driver, please
10list your email here for future contact:
11
12jhall@onlab.us
13andrew@onlab.us
Jon Halle8217482014-10-17 13:49:14 -040014shreya@onlab.us
andrewonlab95ce8322014-10-13 14:12:04 -040015
16OCT 13 2014
Jeremy Songsterae01bba2016-07-11 15:39:17 -070017Modified 2016 by ON.Lab
18
19Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
20the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
21or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>
andrewonlab95ce8322014-10-13 14:12:04 -040022
kelvin8ec71442015-01-15 16:57:00 -080023"""
andrewonlab95ce8322014-10-13 14:12:04 -040024import pexpect
25import re
Jon Hall30b82fa2015-03-04 17:15:43 -080026import json
27import types
Jon Hallbd16b922015-03-26 17:53:15 -070028import time
kelvin-onlaba4074292015-07-09 15:19:49 -070029import os
andrewonlab95ce8322014-10-13 14:12:04 -040030from drivers.common.clidriver import CLI
You Wangdb8cd0a2016-05-26 15:19:45 -070031from core.graph import Graph
andrewonlab95ce8322014-10-13 14:12:04 -040032
andrewonlab95ce8322014-10-13 14:12:04 -040033
kelvin8ec71442015-01-15 16:57:00 -080034class OnosCliDriver( CLI ):
andrewonlab95ce8322014-10-13 14:12:04 -040035
kelvin8ec71442015-01-15 16:57:00 -080036 def __init__( self ):
37 """
38 Initialize client
39 """
Jon Hallefbd9792015-03-05 16:11:36 -080040 self.name = None
41 self.home = None
42 self.handle = None
You Wangdb8cd0a2016-05-26 15:19:45 -070043 self.graph = Graph()
kelvin8ec71442015-01-15 16:57:00 -080044 super( CLI, self ).__init__()
45
46 def connect( self, **connectargs ):
47 """
andrewonlab95ce8322014-10-13 14:12:04 -040048 Creates ssh handle for ONOS cli.
kelvin8ec71442015-01-15 16:57:00 -080049 """
andrewonlab95ce8322014-10-13 14:12:04 -040050 try:
51 for key in connectargs:
kelvin8ec71442015-01-15 16:57:00 -080052 vars( self )[ key ] = connectargs[ key ]
andrew@onlab.us658ec012015-03-11 15:13:09 -070053 self.home = "~/onos"
andrewonlab95ce8322014-10-13 14:12:04 -040054 for key in self.options:
55 if key == "home":
kelvin8ec71442015-01-15 16:57:00 -080056 self.home = self.options[ 'home' ]
andrewonlab95ce8322014-10-13 14:12:04 -040057 break
kelvin-onlabfb521662015-02-27 09:52:40 -080058 if self.home is None or self.home == "":
Jon Halle94919c2015-03-23 11:42:57 -070059 self.home = "~/onos"
andrewonlab95ce8322014-10-13 14:12:04 -040060
kelvin-onlaba4074292015-07-09 15:19:49 -070061 for key in self.options:
62 if key == 'onosIp':
63 self.onosIp = self.options[ 'onosIp' ]
64 break
65
kelvin8ec71442015-01-15 16:57:00 -080066 self.name = self.options[ 'name' ]
kelvin-onlaba4074292015-07-09 15:19:49 -070067
68 try:
Jon Hallc6793552016-01-19 14:18:37 -080069 if os.getenv( str( self.ip_address ) ) is not None:
kelvin-onlaba4074292015-07-09 15:19:49 -070070 self.ip_address = os.getenv( str( self.ip_address ) )
71 else:
72 main.log.info( self.name +
73 ": Trying to connect to " +
74 self.ip_address )
75
76 except KeyError:
77 main.log.info( "Invalid host name," +
78 " connecting to local host instead" )
79 self.ip_address = 'localhost'
80 except Exception as inst:
81 main.log.error( "Uncaught exception: " + str( inst ) )
82
kelvin8ec71442015-01-15 16:57:00 -080083 self.handle = super( OnosCliDriver, self ).connect(
kelvin-onlab08679eb2015-01-21 16:11:48 -080084 user_name=self.user_name,
85 ip_address=self.ip_address,
kelvin-onlab898a6c62015-01-16 14:13:53 -080086 port=self.port,
87 pwd=self.pwd,
88 home=self.home )
andrewonlab95ce8322014-10-13 14:12:04 -040089
kelvin8ec71442015-01-15 16:57:00 -080090 self.handle.sendline( "cd " + self.home )
91 self.handle.expect( "\$" )
andrewonlab95ce8322014-10-13 14:12:04 -040092 if self.handle:
93 return self.handle
kelvin8ec71442015-01-15 16:57:00 -080094 else:
95 main.log.info( "NO ONOS HANDLE" )
andrewonlab95ce8322014-10-13 14:12:04 -040096 return main.FALSE
Jon Halld4d4b372015-01-28 16:02:41 -080097 except TypeError:
98 main.log.exception( self.name + ": Object not as expected" )
99 return None
andrewonlab95ce8322014-10-13 14:12:04 -0400100 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800101 main.log.error( self.name + ": EOF exception found" )
102 main.log.error( self.name + ": " + self.handle.before )
andrewonlab95ce8322014-10-13 14:12:04 -0400103 main.cleanup()
104 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800105 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800106 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ce8322014-10-13 14:12:04 -0400107 main.cleanup()
108 main.exit()
109
kelvin8ec71442015-01-15 16:57:00 -0800110 def disconnect( self ):
111 """
andrewonlab95ce8322014-10-13 14:12:04 -0400112 Called when Test is complete to disconnect the ONOS handle.
kelvin8ec71442015-01-15 16:57:00 -0800113 """
Jon Halld61331b2015-02-17 16:35:47 -0800114 response = main.TRUE
andrewonlab95ce8322014-10-13 14:12:04 -0400115 try:
Jon Hall61282e32015-03-19 11:34:11 -0700116 if self.handle:
117 i = self.logout()
118 if i == main.TRUE:
119 self.handle.sendline( "" )
120 self.handle.expect( "\$" )
121 self.handle.sendline( "exit" )
122 self.handle.expect( "closed" )
Jon Halld4d4b372015-01-28 16:02:41 -0800123 except TypeError:
124 main.log.exception( self.name + ": Object not as expected" )
Jon Halld61331b2015-02-17 16:35:47 -0800125 response = main.FALSE
andrewonlab95ce8322014-10-13 14:12:04 -0400126 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800127 main.log.error( self.name + ": EOF exception found" )
128 main.log.error( self.name + ": " + self.handle.before )
Jon Hall61282e32015-03-19 11:34:11 -0700129 except ValueError:
Jon Hall1a77a1e2015-04-06 10:41:13 -0700130 main.log.exception( "Exception in disconnect of " + self.name )
Jon Hall61282e32015-03-19 11:34:11 -0700131 response = main.TRUE
Jon Hallfebb1c72015-03-05 13:30:09 -0800132 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800133 main.log.exception( self.name + ": Connection failed to the host" )
andrewonlab95ce8322014-10-13 14:12:04 -0400134 response = main.FALSE
135 return response
136
kelvin8ec71442015-01-15 16:57:00 -0800137 def logout( self ):
138 """
andrewonlab38d2b4a2014-11-13 16:28:47 -0500139 Sends 'logout' command to ONOS cli
Jon Hall61282e32015-03-19 11:34:11 -0700140 Returns main.TRUE if exited CLI and
141 main.FALSE on timeout (not guranteed you are disconnected)
142 None on TypeError
143 Exits test on unknown error or pexpect exits unexpectedly
kelvin8ec71442015-01-15 16:57:00 -0800144 """
andrewonlab38d2b4a2014-11-13 16:28:47 -0500145 try:
Jon Hall61282e32015-03-19 11:34:11 -0700146 if self.handle:
147 self.handle.sendline( "" )
148 i = self.handle.expect( [ "onos>", "\$", pexpect.TIMEOUT ],
149 timeout=10 )
150 if i == 0: # In ONOS CLI
151 self.handle.sendline( "logout" )
Jon Hallbfe00002016-04-05 10:23:54 -0700152 j = self.handle.expect( [ "\$",
153 "Command not found:",
154 pexpect.TIMEOUT ] )
155 if j == 0: # Successfully logged out
156 return main.TRUE
157 elif j == 1 or j == 2:
158 # ONOS didn't fully load, and logout command isn't working
159 # or the command timed out
160 self.handle.send( "\x04" ) # send ctrl-d
Jon Hall64ab3bd2016-05-13 11:29:44 -0700161 try:
162 self.handle.expect( "\$" )
163 except pexpect.TIMEOUT:
164 main.log.error( "ONOS did not respond to 'logout' or CTRL-d" )
Jon Hallbfe00002016-04-05 10:23:54 -0700165 return main.TRUE
166 else: # some other output
167 main.log.warn( "Unknown repsonse to logout command: '{}'",
168 repr( self.handle.before ) )
169 return main.FALSE
Jon Hall61282e32015-03-19 11:34:11 -0700170 elif i == 1: # not in CLI
171 return main.TRUE
172 elif i == 3: # Timeout
173 return main.FALSE
174 else:
andrewonlab9627f432014-11-14 12:45:10 -0500175 return main.TRUE
Jon Halld4d4b372015-01-28 16:02:41 -0800176 except TypeError:
177 main.log.exception( self.name + ": Object not as expected" )
178 return None
andrewonlab38d2b4a2014-11-13 16:28:47 -0500179 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800180 main.log.error( self.name + ": eof exception found" )
Jon Hall61282e32015-03-19 11:34:11 -0700181 main.log.error( self.name + ": " + self.handle.before )
andrewonlab38d2b4a2014-11-13 16:28:47 -0500182 main.cleanup()
183 main.exit()
Jon Hall61282e32015-03-19 11:34:11 -0700184 except ValueError:
Jon Hall5aa168b2015-03-23 14:23:09 -0700185 main.log.error( self.name +
186 "ValueError exception in logout method" )
Jon Hallfebb1c72015-03-05 13:30:09 -0800187 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800188 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab38d2b4a2014-11-13 16:28:47 -0500189 main.cleanup()
190 main.exit()
191
kelvin-onlabd3b64892015-01-20 13:26:24 -0800192 def setCell( self, cellname ):
kelvin8ec71442015-01-15 16:57:00 -0800193 """
andrewonlab95ce8322014-10-13 14:12:04 -0400194 Calls 'cell <name>' to set the environment variables on ONOSbench
kelvin8ec71442015-01-15 16:57:00 -0800195
andrewonlab95ce8322014-10-13 14:12:04 -0400196 Before issuing any cli commands, set the environment variable first.
kelvin8ec71442015-01-15 16:57:00 -0800197 """
andrewonlab95ce8322014-10-13 14:12:04 -0400198 try:
199 if not cellname:
kelvin8ec71442015-01-15 16:57:00 -0800200 main.log.error( "Must define cellname" )
andrewonlab95ce8322014-10-13 14:12:04 -0400201 main.cleanup()
202 main.exit()
203 else:
kelvin8ec71442015-01-15 16:57:00 -0800204 self.handle.sendline( "cell " + str( cellname ) )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800205 # Expect the cellname in the ONOSCELL variable.
kelvin8ec71442015-01-15 16:57:00 -0800206 # Note that this variable name is subject to change
andrewonlab95ce8322014-10-13 14:12:04 -0400207 # and that this driver will have to change accordingly
Cameron Franke9c94fb02015-01-21 10:20:20 -0800208 self.handle.expect(str(cellname))
andrew@onlab.usc400b112015-01-21 15:33:19 -0800209 handleBefore = self.handle.before
210 handleAfter = self.handle.after
kelvin8ec71442015-01-15 16:57:00 -0800211 # Get the rest of the handle
Cameron Franke9c94fb02015-01-21 10:20:20 -0800212 self.handle.sendline("")
213 self.handle.expect("\$")
andrew@onlab.usc400b112015-01-21 15:33:19 -0800214 handleMore = self.handle.before
andrewonlab95ce8322014-10-13 14:12:04 -0400215
kelvin-onlabd3b64892015-01-20 13:26:24 -0800216 main.log.info( "Cell call returned: " + handleBefore +
217 handleAfter + handleMore )
andrewonlab95ce8322014-10-13 14:12:04 -0400218
219 return main.TRUE
220
Jon Halld4d4b372015-01-28 16:02:41 -0800221 except TypeError:
222 main.log.exception( self.name + ": Object not as expected" )
223 return None
andrewonlab95ce8322014-10-13 14:12:04 -0400224 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800225 main.log.error( self.name + ": eof exception found" )
226 main.log.error( self.name + ": " + self.handle.before )
andrewonlab95ce8322014-10-13 14:12:04 -0400227 main.cleanup()
228 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800229 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800230 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ce8322014-10-13 14:12:04 -0400231 main.cleanup()
232 main.exit()
kelvin8ec71442015-01-15 16:57:00 -0800233
pingping-lin57a56ce2015-05-20 16:43:48 -0700234 def startOnosCli( self, ONOSIp, karafTimeout="",
Jon Hallc6793552016-01-19 14:18:37 -0800235 commandlineTimeout=10, onosStartTimeout=60 ):
kelvin8ec71442015-01-15 16:57:00 -0800236 """
Jon Hallefbd9792015-03-05 16:11:36 -0800237 karafTimeout is an optional argument. karafTimeout value passed
kelvin-onlabd3b64892015-01-20 13:26:24 -0800238 by user would be used to set the current karaf shell idle timeout.
239 Note that when ever this property is modified the shell will exit and
Hari Krishnad7b9c202015-01-05 10:38:14 -0800240 the subsequent login would reflect new idle timeout.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800241 Below is an example to start a session with 60 seconds idle timeout
242 ( input value is in milliseconds ):
kelvin8ec71442015-01-15 16:57:00 -0800243
Hari Krishna25d42f72015-01-05 15:08:28 -0800244 tValue = "60000"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800245 main.ONOScli1.startOnosCli( ONOSIp, karafTimeout=tValue )
kelvin8ec71442015-01-15 16:57:00 -0800246
kelvin-onlabd3b64892015-01-20 13:26:24 -0800247 Note: karafTimeout is left as str so that this could be read
248 and passed to startOnosCli from PARAMS file as str.
kelvin8ec71442015-01-15 16:57:00 -0800249 """
You Wangf69ab392016-01-26 16:34:38 -0800250 self.onosIp = ONOSIp
andrewonlab95ce8322014-10-13 14:12:04 -0400251 try:
kelvin8ec71442015-01-15 16:57:00 -0800252 self.handle.sendline( "" )
253 x = self.handle.expect( [
pingping-lin57a56ce2015-05-20 16:43:48 -0700254 "\$", "onos>" ], commandlineTimeout)
andrewonlab48829f62014-11-17 13:49:01 -0500255
256 if x == 1:
kelvin8ec71442015-01-15 16:57:00 -0800257 main.log.info( "ONOS cli is already running" )
andrewonlab48829f62014-11-17 13:49:01 -0500258 return main.TRUE
andrewonlab95ce8322014-10-13 14:12:04 -0400259
kelvin8ec71442015-01-15 16:57:00 -0800260 # Wait for onos start ( -w ) and enter onos cli
kelvin-onlabd3b64892015-01-20 13:26:24 -0800261 self.handle.sendline( "onos -w " + str( ONOSIp ) )
kelvin8ec71442015-01-15 16:57:00 -0800262 i = self.handle.expect( [
263 "onos>",
pingping-lin57a56ce2015-05-20 16:43:48 -0700264 pexpect.TIMEOUT ], onosStartTimeout )
andrewonlab2a7ea9b2014-10-24 12:21:05 -0400265
266 if i == 0:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800267 main.log.info( str( ONOSIp ) + " CLI Started successfully" )
Hari Krishnae36ef212015-01-04 14:09:13 -0800268 if karafTimeout:
kelvin8ec71442015-01-15 16:57:00 -0800269 self.handle.sendline(
Hari Krishnaac4e1782015-01-26 12:09:12 -0800270 "config:property-set -p org.apache.karaf.shell\
271 sshIdleTimeout " +
kelvin8ec71442015-01-15 16:57:00 -0800272 karafTimeout )
273 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800274 self.handle.sendline( "onos -w " + str( ONOSIp ) )
kelvin8ec71442015-01-15 16:57:00 -0800275 self.handle.expect( "onos>" )
andrewonlab2a7ea9b2014-10-24 12:21:05 -0400276 return main.TRUE
277 else:
kelvin8ec71442015-01-15 16:57:00 -0800278 # If failed, send ctrl+c to process and try again
279 main.log.info( "Starting CLI failed. Retrying..." )
280 self.handle.send( "\x03" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800281 self.handle.sendline( "onos -w " + str( ONOSIp ) )
kelvin8ec71442015-01-15 16:57:00 -0800282 i = self.handle.expect( [ "onos>", pexpect.TIMEOUT ],
283 timeout=30 )
andrewonlab3a7c3c72014-10-24 17:21:03 -0400284 if i == 0:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800285 main.log.info( str( ONOSIp ) + " CLI Started " +
kelvin8ec71442015-01-15 16:57:00 -0800286 "successfully after retry attempt" )
Hari Krishnae36ef212015-01-04 14:09:13 -0800287 if karafTimeout:
kelvin8ec71442015-01-15 16:57:00 -0800288 self.handle.sendline(
kelvin-onlabd3b64892015-01-20 13:26:24 -0800289 "config:property-set -p org.apache.karaf.shell\
290 sshIdleTimeout " +
kelvin8ec71442015-01-15 16:57:00 -0800291 karafTimeout )
292 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800293 self.handle.sendline( "onos -w " + str( ONOSIp ) )
kelvin8ec71442015-01-15 16:57:00 -0800294 self.handle.expect( "onos>" )
andrewonlab3a7c3c72014-10-24 17:21:03 -0400295 return main.TRUE
296 else:
kelvin8ec71442015-01-15 16:57:00 -0800297 main.log.error( "Connection to CLI " +
kelvin-onlabd3b64892015-01-20 13:26:24 -0800298 str( ONOSIp ) + " timeout" )
andrewonlab3a7c3c72014-10-24 17:21:03 -0400299 return main.FALSE
andrewonlab95ce8322014-10-13 14:12:04 -0400300
Jon Halld4d4b372015-01-28 16:02:41 -0800301 except TypeError:
302 main.log.exception( self.name + ": Object not as expected" )
303 return None
andrewonlab95ce8322014-10-13 14:12:04 -0400304 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800305 main.log.error( self.name + ": EOF exception found" )
306 main.log.error( self.name + ": " + self.handle.before )
andrewonlab95ce8322014-10-13 14:12:04 -0400307 main.cleanup()
308 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800309 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800310 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ce8322014-10-13 14:12:04 -0400311 main.cleanup()
312 main.exit()
313
suibin zhang116647a2016-05-06 16:30:09 -0700314 def startCellCli( self, karafTimeout="",
315 commandlineTimeout=10, onosStartTimeout=60 ):
316 """
317 Start CLI on onos ecll handle.
318
319 karafTimeout is an optional argument. karafTimeout value passed
320 by user would be used to set the current karaf shell idle timeout.
321 Note that when ever this property is modified the shell will exit and
322 the subsequent login would reflect new idle timeout.
323 Below is an example to start a session with 60 seconds idle timeout
324 ( input value is in milliseconds ):
325
326 tValue = "60000"
327
328 Note: karafTimeout is left as str so that this could be read
329 and passed to startOnosCli from PARAMS file as str.
330 """
331
332 try:
333 self.handle.sendline( "" )
334 x = self.handle.expect( [
335 "\$", "onos>" ], commandlineTimeout)
336
337 if x == 1:
338 main.log.info( "ONOS cli is already running" )
339 return main.TRUE
340
341 # Wait for onos start ( -w ) and enter onos cli
342 self.handle.sendline( "/opt/onos/bin/onos" )
343 i = self.handle.expect( [
344 "onos>",
345 pexpect.TIMEOUT ], onosStartTimeout )
346
347 if i == 0:
348 main.log.info( self.name + " CLI Started successfully" )
349 if karafTimeout:
350 self.handle.sendline(
351 "config:property-set -p org.apache.karaf.shell\
352 sshIdleTimeout " +
353 karafTimeout )
354 self.handle.expect( "\$" )
355 self.handle.sendline( "/opt/onos/bin/onos" )
356 self.handle.expect( "onos>" )
357 return main.TRUE
358 else:
359 # If failed, send ctrl+c to process and try again
360 main.log.info( "Starting CLI failed. Retrying..." )
361 self.handle.send( "\x03" )
362 self.handle.sendline( "/opt/onos/bin/onos" )
363 i = self.handle.expect( [ "onos>", pexpect.TIMEOUT ],
364 timeout=30 )
365 if i == 0:
366 main.log.info( self.name + " CLI Started " +
367 "successfully after retry attempt" )
368 if karafTimeout:
369 self.handle.sendline(
370 "config:property-set -p org.apache.karaf.shell\
371 sshIdleTimeout " +
372 karafTimeout )
373 self.handle.expect( "\$" )
374 self.handle.sendline( "/opt/onos/bin/onos" )
375 self.handle.expect( "onos>" )
376 return main.TRUE
377 else:
378 main.log.error( "Connection to CLI " +
379 self.name + " timeout" )
380 return main.FALSE
381
382 except TypeError:
383 main.log.exception( self.name + ": Object not as expected" )
384 return None
385 except pexpect.EOF:
386 main.log.error( self.name + ": EOF exception found" )
387 main.log.error( self.name + ": " + self.handle.before )
388 main.cleanup()
389 main.exit()
390 except Exception:
391 main.log.exception( self.name + ": Uncaught exception!" )
392 main.cleanup()
393 main.exit()
394
YPZhangebf9eb52016-05-12 15:20:24 -0700395 def log( self, cmdStr, level="",noExit=False):
kelvin-onlab9f541032015-02-04 16:19:53 -0800396 """
397 log the commands in the onos CLI.
kelvin-onlab338f5512015-02-06 10:53:16 -0800398 returns main.TRUE on success
Jon Hallefbd9792015-03-05 16:11:36 -0800399 returns main.FALSE if Error occurred
YPZhangebf9eb52016-05-12 15:20:24 -0700400 if noExit is True, TestON will not exit, but clean up
kelvin-onlab338f5512015-02-06 10:53:16 -0800401 Available level: DEBUG, TRACE, INFO, WARN, ERROR
402 Level defaults to INFO
kelvin-onlab9f541032015-02-04 16:19:53 -0800403 """
404 try:
kelvin-onlab338f5512015-02-06 10:53:16 -0800405 lvlStr = ""
406 if level:
407 lvlStr = "--level=" + level
408
kelvin-onlab338f5512015-02-06 10:53:16 -0800409 self.handle.sendline( "log:log " + lvlStr + " " + cmdStr )
Jon Hall390696c2015-05-05 17:13:41 -0700410 self.handle.expect( "log:log" )
kelvin-onlab9f541032015-02-04 16:19:53 -0800411 self.handle.expect( "onos>" )
kelvin-onlabfb521662015-02-27 09:52:40 -0800412
kelvin-onlab9f541032015-02-04 16:19:53 -0800413 response = self.handle.before
414 if re.search( "Error", response ):
415 return main.FALSE
416 return main.TRUE
Jon Hall80daded2015-05-27 16:07:00 -0700417 except pexpect.TIMEOUT:
418 main.log.exception( self.name + ": TIMEOUT exception found" )
YPZhangebf9eb52016-05-12 15:20:24 -0700419 if noExit:
420 main.cleanup()
421 return None
422 else:
423 main.cleanup()
424 main.exit()
kelvin-onlab9f541032015-02-04 16:19:53 -0800425 except pexpect.EOF:
426 main.log.error( self.name + ": EOF exception found" )
427 main.log.error( self.name + ": " + self.handle.before )
YPZhangebf9eb52016-05-12 15:20:24 -0700428 if noExit:
429 main.cleanup()
430 return None
431 else:
432 main.cleanup()
433 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800434 except Exception:
kelvin-onlabfb521662015-02-27 09:52:40 -0800435 main.log.exception( self.name + ": Uncaught exception!" )
YPZhangebf9eb52016-05-12 15:20:24 -0700436 if noExit:
437 main.cleanup()
438 return None
439 else:
440 main.cleanup()
441 main.exit()
andrewonlab95ce8322014-10-13 14:12:04 -0400442
YPZhangebf9eb52016-05-12 15:20:24 -0700443 def sendline( self, cmdStr, showResponse=False, debug=False, timeout=10, noExit=False ):
kelvin8ec71442015-01-15 16:57:00 -0800444 """
Jon Halle3f39ff2015-01-13 11:50:53 -0800445 Send a completely user specified string to
446 the onos> prompt. Use this function if you have
andrewonlaba18f6bf2014-10-13 19:31:54 -0400447 a very specific command to send.
Jon Halle3f39ff2015-01-13 11:50:53 -0800448
YPZhang14a4aa92016-07-15 13:37:15 -0700449 if noExit is True, TestON will not exit, and return None
YPZhangebf9eb52016-05-12 15:20:24 -0700450
andrewonlaba18f6bf2014-10-13 19:31:54 -0400451 Warning: There are no sanity checking to commands
452 sent using this method.
GlennRCed771242016-01-13 17:02:47 -0800453
kelvin8ec71442015-01-15 16:57:00 -0800454 """
andrewonlaba18f6bf2014-10-13 19:31:54 -0400455 try:
Jon Halla495f562016-05-16 18:03:26 -0700456 # Try to reconnect if disconnected from cli
457 self.handle.sendline( "" )
458 i = self.handle.expect( [ "onos>", "\$", pexpect.TIMEOUT ] )
459 if i == 1:
460 main.log.error( self.name + ": onos cli session closed. ")
461 if self.onosIp:
462 main.log.warn( "Trying to reconnect " + self.onosIp )
463 reconnectResult = self.startOnosCli( self.onosIp )
464 if reconnectResult:
465 main.log.info( self.name + ": onos cli session reconnected." )
466 else:
467 main.log.error( self.name + ": reconnection failed." )
YPZhang14a4aa92016-07-15 13:37:15 -0700468 if noExit:
469 return None
470 else:
471 main.cleanup()
472 main.exit()
Jon Halla495f562016-05-16 18:03:26 -0700473 else:
474 main.cleanup()
475 main.exit()
476 if i == 2:
477 self.handle.sendline( "" )
478 self.handle.expect( "onos>" )
479
Jon Hall14a03b52016-05-11 12:07:30 -0700480 if debug:
481 # NOTE: This adds and average of .4 seconds per call
482 logStr = "\"Sending CLI command: '" + cmdStr + "'\""
YPZhangebf9eb52016-05-12 15:20:24 -0700483 self.log( logStr,noExit=noExit )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800484 self.handle.sendline( cmdStr )
GlennRCed771242016-01-13 17:02:47 -0800485 i = self.handle.expect( ["onos>", "\$"], timeout )
Jon Hall63604932015-02-26 17:09:50 -0800486 response = self.handle.before
Jon Hall63604932015-02-26 17:09:50 -0800487 # TODO: do something with i
Jon Hallc6793552016-01-19 14:18:37 -0800488 main.log.info( "Command '" + str( cmdStr ) + "' sent to "
489 + self.name + "." )
Jon Hallc6358dd2015-04-10 12:44:28 -0700490 if debug:
Jon Hall390696c2015-05-05 17:13:41 -0700491 main.log.debug( self.name + ": Raw output" )
492 main.log.debug( self.name + ": " + repr( response ) )
Jon Hallc6358dd2015-04-10 12:44:28 -0700493
494 # Remove ANSI color control strings from output
kelvin-onlabd3b64892015-01-20 13:26:24 -0800495 ansiEscape = re.compile( r'\x1b[^m]*m' )
Jon Hall63604932015-02-26 17:09:50 -0800496 response = ansiEscape.sub( '', response )
Jon Hallc6358dd2015-04-10 12:44:28 -0700497 if debug:
Jon Hall390696c2015-05-05 17:13:41 -0700498 main.log.debug( self.name + ": ansiEscape output" )
499 main.log.debug( self.name + ": " + repr( response ) )
Jon Hallc6358dd2015-04-10 12:44:28 -0700500
kelvin-onlabfb521662015-02-27 09:52:40 -0800501 # Remove extra return chars that get added
Jon Hall63604932015-02-26 17:09:50 -0800502 response = re.sub( r"\s\r", "", response )
Jon Hallc6358dd2015-04-10 12:44:28 -0700503 if debug:
Jon Hall390696c2015-05-05 17:13:41 -0700504 main.log.debug( self.name + ": Removed extra returns " +
505 "from output" )
506 main.log.debug( self.name + ": " + repr( response ) )
Jon Hallc6358dd2015-04-10 12:44:28 -0700507
508 # Strip excess whitespace
Jon Hall63604932015-02-26 17:09:50 -0800509 response = response.strip()
Jon Hallc6358dd2015-04-10 12:44:28 -0700510 if debug:
Jon Hall390696c2015-05-05 17:13:41 -0700511 main.log.debug( self.name + ": parsed and stripped output" )
512 main.log.debug( self.name + ": " + repr( response ) )
Jon Hallc6358dd2015-04-10 12:44:28 -0700513
Jon Hall63604932015-02-26 17:09:50 -0800514 # parse for just the output, remove the cmd from response
Jon Hallc6358dd2015-04-10 12:44:28 -0700515 output = response.split( cmdStr.strip(), 1 )
516 if debug:
Jon Hall390696c2015-05-05 17:13:41 -0700517 main.log.debug( self.name + ": split output" )
Jon Hallc6358dd2015-04-10 12:44:28 -0700518 for r in output:
Jon Hall390696c2015-05-05 17:13:41 -0700519 main.log.debug( self.name + ": " + repr( r ) )
GlennRC85870432015-11-23 11:45:51 -0800520 output = output[1].strip()
521 if showResponse:
GlennRCed771242016-01-13 17:02:47 -0800522 main.log.info( "Response from ONOS: {}".format( output ) )
GlennRC85870432015-11-23 11:45:51 -0800523 return output
GlennRCed771242016-01-13 17:02:47 -0800524 except pexpect.TIMEOUT:
525 main.log.error( self.name + ":ONOS timeout" )
526 if debug:
527 main.log.debug( self.handle.before )
528 return None
Jon Hallc6358dd2015-04-10 12:44:28 -0700529 except IndexError:
530 main.log.exception( self.name + ": Object not as expected" )
Jon Halla495f562016-05-16 18:03:26 -0700531 main.log.debug( "response: {}".format( repr( response ) ) )
Jon Hallc6358dd2015-04-10 12:44:28 -0700532 return None
Jon Halld4d4b372015-01-28 16:02:41 -0800533 except TypeError:
534 main.log.exception( self.name + ": Object not as expected" )
535 return None
andrewonlaba18f6bf2014-10-13 19:31:54 -0400536 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800537 main.log.error( self.name + ": EOF exception found" )
538 main.log.error( self.name + ": " + self.handle.before )
YPZhangebf9eb52016-05-12 15:20:24 -0700539 if noExit:
YPZhangebf9eb52016-05-12 15:20:24 -0700540 return None
541 else:
542 main.cleanup()
543 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800544 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800545 main.log.exception( self.name + ": Uncaught exception!" )
YPZhangebf9eb52016-05-12 15:20:24 -0700546 if noExit:
YPZhangebf9eb52016-05-12 15:20:24 -0700547 return None
548 else:
549 main.cleanup()
550 main.exit()
andrewonlaba18f6bf2014-10-13 19:31:54 -0400551
kelvin8ec71442015-01-15 16:57:00 -0800552 # IMPORTANT NOTE:
553 # For all cli commands, naming convention should match
kelvin-onlabd3b64892015-01-20 13:26:24 -0800554 # the cli command changing 'a:b' with 'aB'.
555 # Ex ) onos:topology > onosTopology
556 # onos:links > onosLinks
557 # feature:list > featureList
Jon Halle3f39ff2015-01-13 11:50:53 -0800558
kelvin-onlabd3b64892015-01-20 13:26:24 -0800559 def addNode( self, nodeId, ONOSIp, tcpPort="" ):
kelvin8ec71442015-01-15 16:57:00 -0800560 """
andrewonlabc2d05aa2014-10-13 16:51:10 -0400561 Adds a new cluster node by ID and address information.
562 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800563 * nodeId
564 * ONOSIp
andrewonlabc2d05aa2014-10-13 16:51:10 -0400565 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800566 * tcpPort
kelvin8ec71442015-01-15 16:57:00 -0800567 """
andrewonlabc2d05aa2014-10-13 16:51:10 -0400568 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800569 cmdStr = "add-node " + str( nodeId ) + " " +\
570 str( ONOSIp ) + " " + str( tcpPort )
571 handle = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -0700572 assert handle is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -0800573 assert "Command not found:" not in handle, handle
kelvin-onlab898a6c62015-01-16 14:13:53 -0800574 if re.search( "Error", handle ):
kelvin8ec71442015-01-15 16:57:00 -0800575 main.log.error( "Error in adding node" )
576 main.log.error( handle )
Jon Halle3f39ff2015-01-13 11:50:53 -0800577 return main.FALSE
andrewonlabc2d05aa2014-10-13 16:51:10 -0400578 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800579 main.log.info( "Node " + str( ONOSIp ) + " added" )
andrewonlabc2d05aa2014-10-13 16:51:10 -0400580 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -0800581 except AssertionError:
582 main.log.exception( "" )
583 return None
Jon Halld4d4b372015-01-28 16:02:41 -0800584 except TypeError:
585 main.log.exception( self.name + ": Object not as expected" )
586 return None
andrewonlabc2d05aa2014-10-13 16:51:10 -0400587 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800588 main.log.error( self.name + ": EOF exception found" )
589 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc2d05aa2014-10-13 16:51:10 -0400590 main.cleanup()
591 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800592 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800593 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc2d05aa2014-10-13 16:51:10 -0400594 main.cleanup()
595 main.exit()
596
kelvin-onlabd3b64892015-01-20 13:26:24 -0800597 def removeNode( self, nodeId ):
kelvin8ec71442015-01-15 16:57:00 -0800598 """
andrewonlab86dc3082014-10-13 18:18:38 -0400599 Removes a cluster by ID
600 Issues command: 'remove-node [<node-id>]'
601 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800602 * nodeId
kelvin8ec71442015-01-15 16:57:00 -0800603 """
andrewonlab86dc3082014-10-13 18:18:38 -0400604 try:
andrewonlab86dc3082014-10-13 18:18:38 -0400605
kelvin-onlabd3b64892015-01-20 13:26:24 -0800606 cmdStr = "remove-node " + str( nodeId )
Jon Hall08f61bc2015-04-13 16:00:30 -0700607 handle = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -0700608 assert handle is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -0800609 assert "Command not found:" not in handle, handle
Jon Hallc6358dd2015-04-10 12:44:28 -0700610 if re.search( "Error", handle ):
611 main.log.error( "Error in removing node" )
612 main.log.error( handle )
613 return main.FALSE
614 else:
615 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -0800616 except AssertionError:
617 main.log.exception( "" )
618 return None
Jon Halld4d4b372015-01-28 16:02:41 -0800619 except TypeError:
620 main.log.exception( self.name + ": Object not as expected" )
621 return None
andrewonlab86dc3082014-10-13 18:18:38 -0400622 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800623 main.log.error( self.name + ": EOF exception found" )
624 main.log.error( self.name + ": " + self.handle.before )
andrewonlab86dc3082014-10-13 18:18:38 -0400625 main.cleanup()
626 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800627 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800628 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab86dc3082014-10-13 18:18:38 -0400629 main.cleanup()
630 main.exit()
andrewonlabc2d05aa2014-10-13 16:51:10 -0400631
Jon Hall61282e32015-03-19 11:34:11 -0700632 def nodes( self, jsonFormat=True):
kelvin8ec71442015-01-15 16:57:00 -0800633 """
andrewonlab7c211572014-10-15 16:45:20 -0400634 List the nodes currently visible
635 Issues command: 'nodes'
Jon Hall61282e32015-03-19 11:34:11 -0700636 Optional argument:
637 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -0800638 """
andrewonlab7c211572014-10-15 16:45:20 -0400639 try:
Jon Hallc6358dd2015-04-10 12:44:28 -0700640 cmdStr = "nodes"
Jon Hall61282e32015-03-19 11:34:11 -0700641 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -0700642 cmdStr += " -j"
643 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -0700644 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -0800645 assert "Command not found:" not in output, output
Jon Hallc6358dd2015-04-10 12:44:28 -0700646 return output
Jon Hallc6793552016-01-19 14:18:37 -0800647 except AssertionError:
648 main.log.exception( "" )
649 return None
Jon Halld4d4b372015-01-28 16:02:41 -0800650 except TypeError:
651 main.log.exception( self.name + ": Object not as expected" )
652 return None
andrewonlab7c211572014-10-15 16:45:20 -0400653 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800654 main.log.error( self.name + ": EOF exception found" )
655 main.log.error( self.name + ": " + self.handle.before )
andrewonlab7c211572014-10-15 16:45:20 -0400656 main.cleanup()
657 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800658 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800659 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab7c211572014-10-15 16:45:20 -0400660 main.cleanup()
661 main.exit()
662
kelvin8ec71442015-01-15 16:57:00 -0800663 def topology( self ):
664 """
Hari Krishnaef1bd4e2015-03-12 16:55:30 -0700665 Definition:
Jon Hall390696c2015-05-05 17:13:41 -0700666 Returns the output of topology command.
Hari Krishnaef1bd4e2015-03-12 16:55:30 -0700667 Return:
668 topology = current ONOS topology
kelvin8ec71442015-01-15 16:57:00 -0800669 """
andrewonlab95ce8322014-10-13 14:12:04 -0400670 try:
Hari Krishnaef1bd4e2015-03-12 16:55:30 -0700671 cmdStr = "topology -j"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800672 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -0800673 assert "Command not found:" not in handle, handle
Jon Hallc6358dd2015-04-10 12:44:28 -0700674 main.log.info( cmdStr + " returned: " + str( handle ) )
andrewonlab95ce8322014-10-13 14:12:04 -0400675 return handle
Jon Hallc6793552016-01-19 14:18:37 -0800676 except AssertionError:
677 main.log.exception( "" )
Jon Halld4d4b372015-01-28 16:02:41 -0800678 return None
Jon Halld4d4b372015-01-28 16:02:41 -0800679 except TypeError:
680 main.log.exception( self.name + ": Object not as expected" )
681 return None
andrewonlabc2d05aa2014-10-13 16:51:10 -0400682 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800683 main.log.error( self.name + ": EOF exception found" )
684 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc2d05aa2014-10-13 16:51:10 -0400685 main.cleanup()
686 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800687 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800688 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc2d05aa2014-10-13 16:51:10 -0400689 main.cleanup()
690 main.exit()
Jon Hallffb386d2014-11-21 13:43:38 -0800691
jenkins7ead5a82015-03-13 10:28:21 -0700692 def deviceRemove( self, deviceId ):
693 """
694 Removes particular device from storage
695
696 TODO: refactor this function
697 """
698 try:
Jon Hallc6358dd2015-04-10 12:44:28 -0700699 cmdStr = "device-remove " + str( deviceId )
700 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -0800701 assert "Command not found:" not in handle, handle
Jon Hallc6358dd2015-04-10 12:44:28 -0700702 if re.search( "Error", handle ):
703 main.log.error( "Error in removing device" )
704 main.log.error( handle )
705 return main.FALSE
706 else:
707 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -0800708 except AssertionError:
709 main.log.exception( "" )
710 return None
jenkins7ead5a82015-03-13 10:28:21 -0700711 except TypeError:
712 main.log.exception( self.name + ": Object not as expected" )
713 return None
714 except pexpect.EOF:
715 main.log.error( self.name + ": EOF exception found" )
716 main.log.error( self.name + ": " + self.handle.before )
717 main.cleanup()
718 main.exit()
719 except Exception:
720 main.log.exception( self.name + ": Uncaught exception!" )
721 main.cleanup()
722 main.exit()
jenkins7ead5a82015-03-13 10:28:21 -0700723
kelvin-onlabd3b64892015-01-20 13:26:24 -0800724 def devices( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -0800725 """
Jon Hall7b02d952014-10-17 20:14:54 -0400726 Lists all infrastructure devices or switches
andrewonlab86dc3082014-10-13 18:18:38 -0400727 Optional argument:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800728 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -0800729 """
andrewonlab86dc3082014-10-13 18:18:38 -0400730 try:
Jon Hallc6358dd2015-04-10 12:44:28 -0700731 cmdStr = "devices"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800732 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -0700733 cmdStr += " -j"
734 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -0800735 assert "Command not found:" not in handle, handle
Jon Hallc6358dd2015-04-10 12:44:28 -0700736 return handle
Jon Hallc6793552016-01-19 14:18:37 -0800737 except AssertionError:
738 main.log.exception( "" )
739 return None
Jon Halld4d4b372015-01-28 16:02:41 -0800740 except TypeError:
741 main.log.exception( self.name + ": Object not as expected" )
742 return None
andrewonlab7c211572014-10-15 16:45:20 -0400743 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800744 main.log.error( self.name + ": EOF exception found" )
745 main.log.error( self.name + ": " + self.handle.before )
andrewonlab7c211572014-10-15 16:45:20 -0400746 main.cleanup()
747 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800748 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800749 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab7c211572014-10-15 16:45:20 -0400750 main.cleanup()
751 main.exit()
752
kelvin-onlabd3b64892015-01-20 13:26:24 -0800753 def balanceMasters( self ):
kelvin8ec71442015-01-15 16:57:00 -0800754 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800755 This balances the devices across all controllers
756 by issuing command: 'onos> onos:balance-masters'
757 If required this could be extended to return devices balanced output.
kelvin8ec71442015-01-15 16:57:00 -0800758 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800759 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800760 cmdStr = "onos:balance-masters"
Jon Hallc6358dd2015-04-10 12:44:28 -0700761 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -0800762 assert "Command not found:" not in handle, handle
Jon Hallc6358dd2015-04-10 12:44:28 -0700763 if re.search( "Error", handle ):
764 main.log.error( "Error in balancing masters" )
765 main.log.error( handle )
766 return main.FALSE
767 else:
768 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -0800769 except AssertionError:
770 main.log.exception( "" )
771 return None
Jon Halld4d4b372015-01-28 16:02:41 -0800772 except TypeError:
773 main.log.exception( self.name + ": Object not as expected" )
774 return None
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800775 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800776 main.log.error( self.name + ": EOF exception found" )
777 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800778 main.cleanup()
779 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800780 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800781 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800782 main.cleanup()
783 main.exit()
784
Jon Hallc6793552016-01-19 14:18:37 -0800785 def checkMasters( self, jsonFormat=True ):
acsmars24950022015-07-30 18:00:43 -0700786 """
787 Returns the output of the masters command.
788 Optional argument:
789 * jsonFormat - boolean indicating if you want output in json
790 """
791 try:
792 cmdStr = "onos:masters"
793 if jsonFormat:
794 cmdStr += " -j"
795 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -0700796 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -0800797 assert "Command not found:" not in output, output
acsmars24950022015-07-30 18:00:43 -0700798 return output
Jon Hallc6793552016-01-19 14:18:37 -0800799 except AssertionError:
800 main.log.exception( "" )
801 return None
acsmars24950022015-07-30 18:00:43 -0700802 except TypeError:
803 main.log.exception( self.name + ": Object not as expected" )
804 return None
805 except pexpect.EOF:
806 main.log.error( self.name + ": EOF exception found" )
807 main.log.error( self.name + ": " + self.handle.before )
808 main.cleanup()
809 main.exit()
810 except Exception:
811 main.log.exception( self.name + ": Uncaught exception!" )
812 main.cleanup()
813 main.exit()
814
Jon Hallc6793552016-01-19 14:18:37 -0800815 def checkBalanceMasters( self, jsonFormat=True ):
acsmars24950022015-07-30 18:00:43 -0700816 """
817 Uses the master command to check that the devices' leadership
818 is evenly divided
819
820 Dependencies: checkMasters() and summary()
821
Jon Hall6509dbf2016-06-21 17:01:17 -0700822 Returns main.TRUE if the devices are balanced
823 Returns main.FALSE if the devices are unbalanced
acsmars24950022015-07-30 18:00:43 -0700824 Exits on Exception
825 Returns None on TypeError
826 """
827 try:
Jon Hallc6793552016-01-19 14:18:37 -0800828 summaryOutput = self.summary()
829 totalDevices = json.loads( summaryOutput )[ "devices" ]
830 except ( TypeError, ValueError ):
831 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, summaryOutput ) )
832 return None
833 try:
acsmars24950022015-07-30 18:00:43 -0700834 totalOwnedDevices = 0
Jon Hallc6793552016-01-19 14:18:37 -0800835 mastersOutput = self.checkMasters()
836 masters = json.loads( mastersOutput )
acsmars24950022015-07-30 18:00:43 -0700837 first = masters[ 0 ][ "size" ]
838 for master in masters:
839 totalOwnedDevices += master[ "size" ]
840 if master[ "size" ] > first + 1 or master[ "size" ] < first - 1:
841 main.log.error( "Mastership not balanced" )
842 main.log.info( "\n" + self.checkMasters( False ) )
843 return main.FALSE
844 main.log.info( "Mastership balanced between " \
845 + str( len(masters) ) + " masters" )
846 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -0800847 except ( TypeError, ValueError ):
848 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, mastersOutput ) )
acsmars24950022015-07-30 18:00:43 -0700849 return None
850 except pexpect.EOF:
851 main.log.error( self.name + ": EOF exception found" )
852 main.log.error( self.name + ": " + self.handle.before )
853 main.cleanup()
854 main.exit()
855 except Exception:
856 main.log.exception( self.name + ": Uncaught exception!" )
857 main.cleanup()
858 main.exit()
859
YPZhangfebf7302016-05-24 16:45:56 -0700860 def links( self, jsonFormat=True, timeout=30 ):
kelvin8ec71442015-01-15 16:57:00 -0800861 """
Jon Halle8217482014-10-17 13:49:14 -0400862 Lists all core links
863 Optional argument:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800864 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -0800865 """
Jon Halle8217482014-10-17 13:49:14 -0400866 try:
Jon Hallc6358dd2015-04-10 12:44:28 -0700867 cmdStr = "links"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800868 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -0700869 cmdStr += " -j"
YPZhangfebf7302016-05-24 16:45:56 -0700870 handle = self.sendline( cmdStr, timeout=timeout )
Jon Hallc6793552016-01-19 14:18:37 -0800871 assert "Command not found:" not in handle, handle
Jon Hallc6358dd2015-04-10 12:44:28 -0700872 return handle
Jon Hallc6793552016-01-19 14:18:37 -0800873 except AssertionError:
874 main.log.exception( "" )
875 return None
Jon Halld4d4b372015-01-28 16:02:41 -0800876 except TypeError:
877 main.log.exception( self.name + ": Object not as expected" )
878 return None
Jon Halle8217482014-10-17 13:49:14 -0400879 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800880 main.log.error( self.name + ": EOF exception found" )
881 main.log.error( self.name + ": " + self.handle.before )
Jon Halle8217482014-10-17 13:49:14 -0400882 main.cleanup()
883 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800884 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800885 main.log.exception( self.name + ": Uncaught exception!" )
Jon Halle8217482014-10-17 13:49:14 -0400886 main.cleanup()
887 main.exit()
888
kelvin-onlabd3b64892015-01-20 13:26:24 -0800889 def ports( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -0800890 """
Jon Halle8217482014-10-17 13:49:14 -0400891 Lists all ports
892 Optional argument:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800893 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -0800894 """
Jon Halle8217482014-10-17 13:49:14 -0400895 try:
Jon Hallc6358dd2015-04-10 12:44:28 -0700896 cmdStr = "ports"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800897 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -0700898 cmdStr += " -j"
899 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -0800900 assert "Command not found:" not in handle, handle
Jon Hallc6358dd2015-04-10 12:44:28 -0700901 return handle
Jon Hallc6793552016-01-19 14:18:37 -0800902 except AssertionError:
903 main.log.exception( "" )
904 return None
Jon Halld4d4b372015-01-28 16:02:41 -0800905 except TypeError:
906 main.log.exception( self.name + ": Object not as expected" )
907 return None
Jon Halle8217482014-10-17 13:49:14 -0400908 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800909 main.log.error( self.name + ": EOF exception found" )
910 main.log.error( self.name + ": " + self.handle.before )
Jon Halle8217482014-10-17 13:49:14 -0400911 main.cleanup()
912 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800913 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800914 main.log.exception( self.name + ": Uncaught exception!" )
Jon Halle8217482014-10-17 13:49:14 -0400915 main.cleanup()
916 main.exit()
917
kelvin-onlabd3b64892015-01-20 13:26:24 -0800918 def roles( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -0800919 """
Jon Hall983a1702014-10-28 18:44:22 -0400920 Lists all devices and the controllers with roles assigned to them
921 Optional argument:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800922 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -0800923 """
andrewonlab7c211572014-10-15 16:45:20 -0400924 try:
Jon Hallc6358dd2015-04-10 12:44:28 -0700925 cmdStr = "roles"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800926 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -0700927 cmdStr += " -j"
928 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -0800929 assert "Command not found:" not in handle, handle
Jon Hallc6358dd2015-04-10 12:44:28 -0700930 return handle
Jon Hallc6793552016-01-19 14:18:37 -0800931 except AssertionError:
932 main.log.exception( "" )
933 return None
Jon Halld4d4b372015-01-28 16:02:41 -0800934 except TypeError:
935 main.log.exception( self.name + ": Object not as expected" )
936 return None
Jon Hall983a1702014-10-28 18:44:22 -0400937 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800938 main.log.error( self.name + ": EOF exception found" )
939 main.log.error( self.name + ": " + self.handle.before )
Jon Hall983a1702014-10-28 18:44:22 -0400940 main.cleanup()
941 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800942 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800943 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall983a1702014-10-28 18:44:22 -0400944 main.cleanup()
945 main.exit()
946
kelvin-onlabd3b64892015-01-20 13:26:24 -0800947 def getRole( self, deviceId ):
kelvin-onlab898a6c62015-01-16 14:13:53 -0800948 """
Jon Halle3f39ff2015-01-13 11:50:53 -0800949 Given the a string containing the json representation of the "roles"
950 cli command and a partial or whole device id, returns a json object
951 containing the roles output for the first device whose id contains
952 "device_id"
Jon Hall983a1702014-10-28 18:44:22 -0400953
954 Returns:
Jon Halle3f39ff2015-01-13 11:50:53 -0800955 A dict of the role assignments for the given device or
956 None if no match
kelvin8ec71442015-01-15 16:57:00 -0800957 """
Jon Hall983a1702014-10-28 18:44:22 -0400958 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800959 if deviceId is None:
Jon Hall983a1702014-10-28 18:44:22 -0400960 return None
961 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800962 rawRoles = self.roles()
963 rolesJson = json.loads( rawRoles )
kelvin8ec71442015-01-15 16:57:00 -0800964 # search json for the device with id then return the device
kelvin-onlabd3b64892015-01-20 13:26:24 -0800965 for device in rolesJson:
kelvin8ec71442015-01-15 16:57:00 -0800966 # print device
kelvin-onlabd3b64892015-01-20 13:26:24 -0800967 if str( deviceId ) in device[ 'id' ]:
Jon Hall983a1702014-10-28 18:44:22 -0400968 return device
969 return None
Jon Hallc6793552016-01-19 14:18:37 -0800970 except ( TypeError, ValueError ):
971 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, rawRoles ) )
Jon Halld4d4b372015-01-28 16:02:41 -0800972 return None
andrewonlab86dc3082014-10-13 18:18:38 -0400973 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800974 main.log.error( self.name + ": EOF exception found" )
975 main.log.error( self.name + ": " + self.handle.before )
andrewonlab86dc3082014-10-13 18:18:38 -0400976 main.cleanup()
977 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800978 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800979 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab86dc3082014-10-13 18:18:38 -0400980 main.cleanup()
981 main.exit()
Jon Hall94fd0472014-12-08 11:52:42 -0800982
kelvin-onlabd3b64892015-01-20 13:26:24 -0800983 def rolesNotNull( self ):
kelvin8ec71442015-01-15 16:57:00 -0800984 """
Jon Hall94fd0472014-12-08 11:52:42 -0800985 Iterates through each device and checks if there is a master assigned
986 Returns: main.TRUE if each device has a master
987 main.FALSE any device has no master
kelvin8ec71442015-01-15 16:57:00 -0800988 """
Jon Hall94fd0472014-12-08 11:52:42 -0800989 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800990 rawRoles = self.roles()
991 rolesJson = json.loads( rawRoles )
kelvin8ec71442015-01-15 16:57:00 -0800992 # search json for the device with id then return the device
kelvin-onlabd3b64892015-01-20 13:26:24 -0800993 for device in rolesJson:
kelvin8ec71442015-01-15 16:57:00 -0800994 # print device
995 if device[ 'master' ] == "none":
996 main.log.warn( "Device has no master: " + str( device ) )
Jon Hall94fd0472014-12-08 11:52:42 -0800997 return main.FALSE
998 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -0800999 except ( TypeError, ValueError ):
1000 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, rawRoles ) )
Jon Halld4d4b372015-01-28 16:02:41 -08001001 return None
Jon Hall94fd0472014-12-08 11:52:42 -08001002 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001003 main.log.error( self.name + ": EOF exception found" )
1004 main.log.error( self.name + ": " + self.handle.before )
Jon Hall94fd0472014-12-08 11:52:42 -08001005 main.cleanup()
1006 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001007 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001008 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall94fd0472014-12-08 11:52:42 -08001009 main.cleanup()
1010 main.exit()
1011
kelvin-onlabd3b64892015-01-20 13:26:24 -08001012 def paths( self, srcId, dstId ):
kelvin8ec71442015-01-15 16:57:00 -08001013 """
andrewonlab3e15ead2014-10-15 14:21:34 -04001014 Returns string of paths, and the cost.
1015 Issues command: onos:paths <src> <dst>
kelvin8ec71442015-01-15 16:57:00 -08001016 """
andrewonlab3e15ead2014-10-15 14:21:34 -04001017 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001018 cmdStr = "onos:paths " + str( srcId ) + " " + str( dstId )
1019 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08001020 assert "Command not found:" not in handle, handle
Jon Halle3f39ff2015-01-13 11:50:53 -08001021 if re.search( "Error", handle ):
kelvin8ec71442015-01-15 16:57:00 -08001022 main.log.error( "Error in getting paths" )
1023 return ( handle, "Error" )
andrewonlab3e15ead2014-10-15 14:21:34 -04001024 else:
kelvin8ec71442015-01-15 16:57:00 -08001025 path = handle.split( ";" )[ 0 ]
1026 cost = handle.split( ";" )[ 1 ]
1027 return ( path, cost )
Jon Hallc6793552016-01-19 14:18:37 -08001028 except AssertionError:
1029 main.log.exception( "" )
1030 return ( handle, "Error" )
Jon Halld4d4b372015-01-28 16:02:41 -08001031 except TypeError:
1032 main.log.exception( self.name + ": Object not as expected" )
1033 return ( handle, "Error" )
andrewonlab3e15ead2014-10-15 14:21:34 -04001034 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001035 main.log.error( self.name + ": EOF exception found" )
1036 main.log.error( self.name + ": " + self.handle.before )
andrewonlab3e15ead2014-10-15 14:21:34 -04001037 main.cleanup()
1038 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001039 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001040 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab3e15ead2014-10-15 14:21:34 -04001041 main.cleanup()
1042 main.exit()
Jon Hallffb386d2014-11-21 13:43:38 -08001043
kelvin-onlabd3b64892015-01-20 13:26:24 -08001044 def hosts( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -08001045 """
Jon Hallffb386d2014-11-21 13:43:38 -08001046 Lists all discovered hosts
Jon Hall42db6dc2014-10-24 19:03:48 -04001047 Optional argument:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001048 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -08001049 """
Jon Hall42db6dc2014-10-24 19:03:48 -04001050 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07001051 cmdStr = "hosts"
kelvin-onlabd3b64892015-01-20 13:26:24 -08001052 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07001053 cmdStr += " -j"
1054 handle = self.sendline( cmdStr )
Jeremyd9e4eb12016-04-13 12:09:06 -07001055 if handle:
1056 assert "Command not found:" not in handle, handle
Jon Hallbaf53162015-12-17 17:04:34 -08001057 # TODO: Maybe make this less hardcoded
1058 # ConsistentMap Exceptions
1059 assert "org.onosproject.store.service" not in handle
1060 # Node not leader
1061 assert "java.lang.IllegalStateException" not in handle
Jon Hallc6358dd2015-04-10 12:44:28 -07001062 return handle
Jon Hallc6793552016-01-19 14:18:37 -08001063 except AssertionError:
Jeremyd9e4eb12016-04-13 12:09:06 -07001064 main.log.exception( "Error in processing '" + cmdStr + "' " +
Jeremy Songster6949cea2016-04-19 18:13:18 -07001065 "command: " + str( handle ) )
Jon Hallc6793552016-01-19 14:18:37 -08001066 return None
Jon Halld4d4b372015-01-28 16:02:41 -08001067 except TypeError:
1068 main.log.exception( self.name + ": Object not as expected" )
1069 return None
Jon Hall42db6dc2014-10-24 19:03:48 -04001070 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001071 main.log.error( self.name + ": EOF exception found" )
1072 main.log.error( self.name + ": " + self.handle.before )
Jon Hall42db6dc2014-10-24 19:03:48 -04001073 main.cleanup()
1074 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001075 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001076 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall42db6dc2014-10-24 19:03:48 -04001077 main.cleanup()
1078 main.exit()
1079
kelvin-onlabd3b64892015-01-20 13:26:24 -08001080 def getHost( self, mac ):
kelvin8ec71442015-01-15 16:57:00 -08001081 """
Jon Hall42db6dc2014-10-24 19:03:48 -04001082 Return the first host from the hosts api whose 'id' contains 'mac'
Jon Halle3f39ff2015-01-13 11:50:53 -08001083
Jon Hallefbd9792015-03-05 16:11:36 -08001084 Note: mac must be a colon separated mac address, but could be a
Jon Halle3f39ff2015-01-13 11:50:53 -08001085 partial mac address
1086
Jon Hall42db6dc2014-10-24 19:03:48 -04001087 Return None if there is no match
kelvin8ec71442015-01-15 16:57:00 -08001088 """
Jon Hall42db6dc2014-10-24 19:03:48 -04001089 try:
kelvin8ec71442015-01-15 16:57:00 -08001090 if mac is None:
Jon Hall42db6dc2014-10-24 19:03:48 -04001091 return None
1092 else:
1093 mac = mac
kelvin-onlabd3b64892015-01-20 13:26:24 -08001094 rawHosts = self.hosts()
1095 hostsJson = json.loads( rawHosts )
kelvin8ec71442015-01-15 16:57:00 -08001096 # search json for the host with mac then return the device
kelvin-onlabd3b64892015-01-20 13:26:24 -08001097 for host in hostsJson:
kelvin8ec71442015-01-15 16:57:00 -08001098 # print "%s in %s?" % ( mac, host[ 'id' ] )
Jon Halld4d4b372015-01-28 16:02:41 -08001099 if not host:
1100 pass
1101 elif mac in host[ 'id' ]:
Jon Hall42db6dc2014-10-24 19:03:48 -04001102 return host
1103 return None
Jon Hallc6793552016-01-19 14:18:37 -08001104 except ( TypeError, ValueError ):
1105 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, rawHosts ) )
Jon Halld4d4b372015-01-28 16:02:41 -08001106 return None
Jon Hall42db6dc2014-10-24 19:03:48 -04001107 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001108 main.log.error( self.name + ": EOF exception found" )
1109 main.log.error( self.name + ": " + self.handle.before )
Jon Hall42db6dc2014-10-24 19:03:48 -04001110 main.cleanup()
1111 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001112 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001113 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall42db6dc2014-10-24 19:03:48 -04001114 main.cleanup()
1115 main.exit()
1116
kelvin-onlabd3b64892015-01-20 13:26:24 -08001117 def getHostsId( self, hostList ):
kelvin8ec71442015-01-15 16:57:00 -08001118 """
1119 Obtain list of hosts
andrewonlab3f0a4af2014-10-17 12:25:14 -04001120 Issues command: 'onos> hosts'
kelvin8ec71442015-01-15 16:57:00 -08001121
andrewonlab3f0a4af2014-10-17 12:25:14 -04001122 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001123 * hostList: List of hosts obtained by Mininet
andrewonlab3f0a4af2014-10-17 12:25:14 -04001124 IMPORTANT:
1125 This function assumes that you started your
kelvin8ec71442015-01-15 16:57:00 -08001126 topology with the option '--mac'.
andrewonlab3f0a4af2014-10-17 12:25:14 -04001127 Furthermore, it assumes that value of VLAN is '-1'
1128 Description:
kelvin8ec71442015-01-15 16:57:00 -08001129 Converts mininet hosts ( h1, h2, h3... ) into
1130 ONOS format ( 00:00:00:00:00:01/-1 , ... )
1131 """
andrewonlab3f0a4af2014-10-17 12:25:14 -04001132 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001133 onosHostList = []
andrewonlab3f0a4af2014-10-17 12:25:14 -04001134
kelvin-onlabd3b64892015-01-20 13:26:24 -08001135 for host in hostList:
kelvin8ec71442015-01-15 16:57:00 -08001136 host = host.replace( "h", "" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001137 hostHex = hex( int( host ) ).zfill( 12 )
1138 hostHex = str( hostHex ).replace( 'x', '0' )
1139 i = iter( str( hostHex ) )
1140 hostHex = ":".join( a + b for a, b in zip( i, i ) )
1141 hostHex = hostHex + "/-1"
1142 onosHostList.append( hostHex )
andrewonlab3f0a4af2014-10-17 12:25:14 -04001143
kelvin-onlabd3b64892015-01-20 13:26:24 -08001144 return onosHostList
andrewonlab3f0a4af2014-10-17 12:25:14 -04001145
Jon Halld4d4b372015-01-28 16:02:41 -08001146 except TypeError:
1147 main.log.exception( self.name + ": Object not as expected" )
1148 return None
andrewonlab3f0a4af2014-10-17 12:25:14 -04001149 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001150 main.log.error( self.name + ": EOF exception found" )
1151 main.log.error( self.name + ": " + self.handle.before )
andrewonlab3f0a4af2014-10-17 12:25:14 -04001152 main.cleanup()
1153 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001154 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001155 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab3f0a4af2014-10-17 12:25:14 -04001156 main.cleanup()
1157 main.exit()
andrewonlab3e15ead2014-10-15 14:21:34 -04001158
Jeremy Songsterc032f162016-08-04 17:14:49 -07001159 def addHostIntent( self, hostIdOne, hostIdTwo, vlanId="", setVlan="", encap="" ):
kelvin8ec71442015-01-15 16:57:00 -08001160 """
andrewonlabe6745342014-10-17 14:29:13 -04001161 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001162 * hostIdOne: ONOS host id for host1
1163 * hostIdTwo: ONOS host id for host2
Jeremy Songster832f9e92016-05-05 14:30:49 -07001164 Optional:
1165 * vlanId: specify a VLAN id for the intent
Jeremy Songsterff553672016-05-12 17:06:23 -07001166 * setVlan: specify a VLAN id treatment
Jeremy Songsterc032f162016-08-04 17:14:49 -07001167 * encap: specify an encapsulation type
andrewonlabe6745342014-10-17 14:29:13 -04001168 Description:
Jon Hallefbd9792015-03-05 16:11:36 -08001169 Adds a host-to-host intent ( bidirectional ) by
Jon Hallb1290e82014-11-18 16:17:48 -05001170 specifying the two hosts.
kelvin-onlabfb521662015-02-27 09:52:40 -08001171 Returns:
1172 A string of the intent id or None on Error
kelvin8ec71442015-01-15 16:57:00 -08001173 """
andrewonlabe6745342014-10-17 14:29:13 -04001174 try:
Jeremy Songster832f9e92016-05-05 14:30:49 -07001175 cmdStr = "add-host-intent "
1176 if vlanId:
1177 cmdStr += "-v " + str( vlanId ) + " "
Jeremy Songsterff553672016-05-12 17:06:23 -07001178 if setVlan:
1179 cmdStr += "--setVlan " + str( vlanId ) + " "
Jeremy Songsterc032f162016-08-04 17:14:49 -07001180 if encap:
1181 cmdStr += "--encapsulation " + str( encap ) + " "
Jeremy Songster832f9e92016-05-05 14:30:49 -07001182 cmdStr += str( hostIdOne ) + " " + str( hostIdTwo )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001183 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08001184 assert "Command not found:" not in handle, handle
Hari Krishnaac4e1782015-01-26 12:09:12 -08001185 if re.search( "Error", handle ):
1186 main.log.error( "Error in adding Host intent" )
Jon Hall61282e32015-03-19 11:34:11 -07001187 main.log.debug( "Response from ONOS was: " + repr( handle ) )
kelvin-onlabfb521662015-02-27 09:52:40 -08001188 return None
Hari Krishnaac4e1782015-01-26 12:09:12 -08001189 else:
1190 main.log.info( "Host intent installed between " +
kelvin-onlabfb521662015-02-27 09:52:40 -08001191 str( hostIdOne ) + " and " + str( hostIdTwo ) )
1192 match = re.search('id=0x([\da-f]+),', handle)
1193 if match:
1194 return match.group()[3:-1]
1195 else:
1196 main.log.error( "Error, intent ID not found" )
Jon Hall61282e32015-03-19 11:34:11 -07001197 main.log.debug( "Response from ONOS was: " +
1198 repr( handle ) )
kelvin-onlabfb521662015-02-27 09:52:40 -08001199 return None
Jon Hallc6793552016-01-19 14:18:37 -08001200 except AssertionError:
1201 main.log.exception( "" )
1202 return None
Jon Halld4d4b372015-01-28 16:02:41 -08001203 except TypeError:
1204 main.log.exception( self.name + ": Object not as expected" )
1205 return None
andrewonlabe6745342014-10-17 14:29:13 -04001206 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001207 main.log.error( self.name + ": EOF exception found" )
1208 main.log.error( self.name + ": " + self.handle.before )
andrewonlabe6745342014-10-17 14:29:13 -04001209 main.cleanup()
1210 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001211 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001212 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabe6745342014-10-17 14:29:13 -04001213 main.cleanup()
1214 main.exit()
1215
kelvin-onlabd3b64892015-01-20 13:26:24 -08001216 def addOpticalIntent( self, ingressDevice, egressDevice ):
kelvin8ec71442015-01-15 16:57:00 -08001217 """
andrewonlab7b31d232014-10-24 13:31:47 -04001218 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001219 * ingressDevice: device id of ingress device
1220 * egressDevice: device id of egress device
andrewonlab7b31d232014-10-24 13:31:47 -04001221 Optional:
1222 TODO: Still needs to be implemented via dev side
kelvin-onlabfb521662015-02-27 09:52:40 -08001223 Description:
1224 Adds an optical intent by specifying an ingress and egress device
1225 Returns:
1226 A string of the intent id or None on error
kelvin-onlab898a6c62015-01-16 14:13:53 -08001227 """
andrewonlab7b31d232014-10-24 13:31:47 -04001228 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001229 cmdStr = "add-optical-intent " + str( ingressDevice ) +\
1230 " " + str( egressDevice )
1231 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08001232 assert "Command not found:" not in handle, handle
kelvin-onlab898a6c62015-01-16 14:13:53 -08001233 # If error, return error message
Jon Halle3f39ff2015-01-13 11:50:53 -08001234 if re.search( "Error", handle ):
kelvin-onlabfb521662015-02-27 09:52:40 -08001235 main.log.error( "Error in adding Optical intent" )
1236 return None
andrewonlab7b31d232014-10-24 13:31:47 -04001237 else:
kelvin-onlabfb521662015-02-27 09:52:40 -08001238 main.log.info( "Optical intent installed between " +
1239 str( ingressDevice ) + " and " +
1240 str( egressDevice ) )
1241 match = re.search('id=0x([\da-f]+),', handle)
1242 if match:
1243 return match.group()[3:-1]
1244 else:
1245 main.log.error( "Error, intent ID not found" )
1246 return None
Jon Hallc6793552016-01-19 14:18:37 -08001247 except AssertionError:
1248 main.log.exception( "" )
1249 return None
Jon Halld4d4b372015-01-28 16:02:41 -08001250 except TypeError:
1251 main.log.exception( self.name + ": Object not as expected" )
1252 return None
andrewonlab7b31d232014-10-24 13:31:47 -04001253 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001254 main.log.error( self.name + ": EOF exception found" )
1255 main.log.error( self.name + ": " + self.handle.before )
andrewonlab7b31d232014-10-24 13:31:47 -04001256 main.cleanup()
1257 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001258 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001259 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab7b31d232014-10-24 13:31:47 -04001260 main.cleanup()
1261 main.exit()
1262
kelvin-onlabd3b64892015-01-20 13:26:24 -08001263 def addPointIntent(
kelvin-onlab898a6c62015-01-16 14:13:53 -08001264 self,
kelvin-onlabd3b64892015-01-20 13:26:24 -08001265 ingressDevice,
1266 egressDevice,
1267 portIngress="",
1268 portEgress="",
kelvin-onlab898a6c62015-01-16 14:13:53 -08001269 ethType="",
1270 ethSrc="",
1271 ethDst="",
1272 bandwidth="",
kelvin-onlabd3b64892015-01-20 13:26:24 -08001273 lambdaAlloc=False,
kelvin-onlab898a6c62015-01-16 14:13:53 -08001274 ipProto="",
1275 ipSrc="",
1276 ipDst="",
1277 tcpSrc="",
Jeremy Songster832f9e92016-05-05 14:30:49 -07001278 tcpDst="",
Jeremy Songsterff553672016-05-12 17:06:23 -07001279 vlanId="",
Jeremy Songsterc032f162016-08-04 17:14:49 -07001280 setVlan="",
1281 encap="" ):
kelvin8ec71442015-01-15 16:57:00 -08001282 """
andrewonlab4dbb4d82014-10-17 18:22:31 -04001283 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001284 * ingressDevice: device id of ingress device
1285 * egressDevice: device id of egress device
andrewonlab289e4b72014-10-21 21:24:18 -04001286 Optional:
1287 * ethType: specify ethType
kelvin8ec71442015-01-15 16:57:00 -08001288 * ethSrc: specify ethSrc ( i.e. src mac addr )
1289 * ethDst: specify ethDst ( i.e. dst mac addr )
andrewonlab0dbb6ec2014-11-06 13:46:55 -05001290 * bandwidth: specify bandwidth capacity of link
kelvin-onlabd3b64892015-01-20 13:26:24 -08001291 * lambdaAlloc: if True, intent will allocate lambda
andrewonlab40ccd8b2014-11-06 16:23:34 -05001292 for the specified intent
Jon Halle3f39ff2015-01-13 11:50:53 -08001293 * ipProto: specify ip protocol
andrewonlabf77e0cb2014-11-11 17:17:59 -05001294 * ipSrc: specify ip source address
1295 * ipDst: specify ip destination address
1296 * tcpSrc: specify tcp source port
1297 * tcpDst: specify tcp destination port
Jeremy Songster832f9e92016-05-05 14:30:49 -07001298 * vlanId: specify vlan ID
Jeremy Songsterff553672016-05-12 17:06:23 -07001299 * setVlan: specify a VLAN id treatment
Jeremy Songsterc032f162016-08-04 17:14:49 -07001300 * encap: specify an Encapsulation type to use
andrewonlab4dbb4d82014-10-17 18:22:31 -04001301 Description:
kelvin8ec71442015-01-15 16:57:00 -08001302 Adds a point-to-point intent ( uni-directional ) by
andrewonlab289e4b72014-10-21 21:24:18 -04001303 specifying device id's and optional fields
kelvin-onlabfb521662015-02-27 09:52:40 -08001304 Returns:
1305 A string of the intent id or None on error
andrewonlab289e4b72014-10-21 21:24:18 -04001306
Jon Halle3f39ff2015-01-13 11:50:53 -08001307 NOTE: This function may change depending on the
andrewonlab4dbb4d82014-10-17 18:22:31 -04001308 options developers provide for point-to-point
1309 intent via cli
kelvin8ec71442015-01-15 16:57:00 -08001310 """
andrewonlab4dbb4d82014-10-17 18:22:31 -04001311 try:
Jeremy Songsterff553672016-05-12 17:06:23 -07001312 cmd = "add-point-intent"
andrewonlab36af3822014-11-18 17:48:18 -05001313
Jeremy Songsterff553672016-05-12 17:06:23 -07001314 if ethType:
1315 cmd += " --ethType " + str( ethType )
1316 if ethSrc:
1317 cmd += " --ethSrc " + str( ethSrc )
1318 if ethDst:
1319 cmd += " --ethDst " + str( ethDst )
1320 if bandwidth:
1321 cmd += " --bandwidth " + str( bandwidth )
1322 if lambdaAlloc:
1323 cmd += " --lambda "
1324 if ipProto:
1325 cmd += " --ipProto " + str( ipProto )
1326 if ipSrc:
1327 cmd += " --ipSrc " + str( ipSrc )
1328 if ipDst:
1329 cmd += " --ipDst " + str( ipDst )
1330 if tcpSrc:
1331 cmd += " --tcpSrc " + str( tcpSrc )
1332 if tcpDst:
1333 cmd += " --tcpDst " + str( tcpDst )
1334 if vlanId:
1335 cmd += " -v " + str( vlanId )
1336 if setVlan:
1337 cmd += " --setVlan " + str( setVlan )
Jeremy Songsterc032f162016-08-04 17:14:49 -07001338 if encap:
1339 cmd += " --encapsulation " + str( encap )
andrewonlab289e4b72014-10-21 21:24:18 -04001340
kelvin8ec71442015-01-15 16:57:00 -08001341 # Check whether the user appended the port
1342 # or provided it as an input
kelvin-onlabd3b64892015-01-20 13:26:24 -08001343 if "/" in ingressDevice:
1344 cmd += " " + str( ingressDevice )
andrewonlab36af3822014-11-18 17:48:18 -05001345 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001346 if not portIngress:
kelvin-onlabfb521662015-02-27 09:52:40 -08001347 main.log.error( "You must specify the ingress port" )
kelvin8ec71442015-01-15 16:57:00 -08001348 # TODO: perhaps more meaningful return
kelvin-onlabfb521662015-02-27 09:52:40 -08001349 # Would it make sense to throw an exception and exit
1350 # the test?
1351 return None
andrewonlab36af3822014-11-18 17:48:18 -05001352
kelvin8ec71442015-01-15 16:57:00 -08001353 cmd += " " + \
kelvin-onlabd3b64892015-01-20 13:26:24 -08001354 str( ingressDevice ) + "/" +\
1355 str( portIngress ) + " "
andrewonlab36af3822014-11-18 17:48:18 -05001356
kelvin-onlabd3b64892015-01-20 13:26:24 -08001357 if "/" in egressDevice:
1358 cmd += " " + str( egressDevice )
andrewonlab36af3822014-11-18 17:48:18 -05001359 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001360 if not portEgress:
kelvin-onlabfb521662015-02-27 09:52:40 -08001361 main.log.error( "You must specify the egress port" )
1362 return None
Jon Halle3f39ff2015-01-13 11:50:53 -08001363
kelvin8ec71442015-01-15 16:57:00 -08001364 cmd += " " +\
kelvin-onlabd3b64892015-01-20 13:26:24 -08001365 str( egressDevice ) + "/" +\
1366 str( portEgress )
kelvin8ec71442015-01-15 16:57:00 -08001367
kelvin-onlab898a6c62015-01-16 14:13:53 -08001368 handle = self.sendline( cmd )
Jon Hallc6793552016-01-19 14:18:37 -08001369 assert "Command not found:" not in handle, handle
kelvin-onlabfb521662015-02-27 09:52:40 -08001370 # If error, return error message
kelvin-onlab898a6c62015-01-16 14:13:53 -08001371 if re.search( "Error", handle ):
kelvin8ec71442015-01-15 16:57:00 -08001372 main.log.error( "Error in adding point-to-point intent" )
kelvin-onlabfb521662015-02-27 09:52:40 -08001373 return None
andrewonlab4dbb4d82014-10-17 18:22:31 -04001374 else:
kelvin-onlabfb521662015-02-27 09:52:40 -08001375 # TODO: print out all the options in this message?
1376 main.log.info( "Point-to-point intent installed between " +
1377 str( ingressDevice ) + " and " +
1378 str( egressDevice ) )
1379 match = re.search('id=0x([\da-f]+),', handle)
1380 if match:
1381 return match.group()[3:-1]
1382 else:
1383 main.log.error( "Error, intent ID not found" )
1384 return None
Jon Hallc6793552016-01-19 14:18:37 -08001385 except AssertionError:
1386 main.log.exception( "" )
1387 return None
Jon Halld4d4b372015-01-28 16:02:41 -08001388 except TypeError:
1389 main.log.exception( self.name + ": Object not as expected" )
1390 return None
andrewonlab4dbb4d82014-10-17 18:22:31 -04001391 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001392 main.log.error( self.name + ": EOF exception found" )
1393 main.log.error( self.name + ": " + self.handle.before )
andrewonlab4dbb4d82014-10-17 18:22:31 -04001394 main.cleanup()
1395 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001396 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001397 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab4dbb4d82014-10-17 18:22:31 -04001398 main.cleanup()
1399 main.exit()
1400
kelvin-onlabd3b64892015-01-20 13:26:24 -08001401 def addMultipointToSinglepointIntent(
kelvin-onlab898a6c62015-01-16 14:13:53 -08001402 self,
shahshreyac2f97072015-03-19 17:04:29 -07001403 ingressDeviceList,
kelvin-onlabd3b64892015-01-20 13:26:24 -08001404 egressDevice,
shahshreyac2f97072015-03-19 17:04:29 -07001405 portIngressList=None,
kelvin-onlabd3b64892015-01-20 13:26:24 -08001406 portEgress="",
kelvin-onlab898a6c62015-01-16 14:13:53 -08001407 ethType="",
1408 ethSrc="",
1409 ethDst="",
1410 bandwidth="",
kelvin-onlabd3b64892015-01-20 13:26:24 -08001411 lambdaAlloc=False,
kelvin-onlab898a6c62015-01-16 14:13:53 -08001412 ipProto="",
1413 ipSrc="",
1414 ipDst="",
1415 tcpSrc="",
1416 tcpDst="",
1417 setEthSrc="",
Jeremy Songster832f9e92016-05-05 14:30:49 -07001418 setEthDst="",
Jeremy Songsterff553672016-05-12 17:06:23 -07001419 vlanId="",
Jeremy Songster9385d412016-06-02 17:57:36 -07001420 setVlan="",
Jeremy Songsterc032f162016-08-04 17:14:49 -07001421 partial=False,
1422 encap="" ):
kelvin8ec71442015-01-15 16:57:00 -08001423 """
shahshreyad0c80432014-12-04 16:56:05 -08001424 Note:
shahshreya70622b12015-03-19 17:19:00 -07001425 This function assumes the format of all ingress devices
Jon Hallbe379602015-03-24 13:39:32 -07001426 is same. That is, all ingress devices include port numbers
1427 with a "/" or all ingress devices could specify device
1428 ids and port numbers seperately.
shahshreyad0c80432014-12-04 16:56:05 -08001429 Required:
Jon Hallbe379602015-03-24 13:39:32 -07001430 * ingressDeviceList: List of device ids of ingress device
shahshreyac2f97072015-03-19 17:04:29 -07001431 ( Atleast 2 ingress devices required in the list )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001432 * egressDevice: device id of egress device
shahshreyad0c80432014-12-04 16:56:05 -08001433 Optional:
1434 * ethType: specify ethType
kelvin8ec71442015-01-15 16:57:00 -08001435 * ethSrc: specify ethSrc ( i.e. src mac addr )
1436 * ethDst: specify ethDst ( i.e. dst mac addr )
shahshreyad0c80432014-12-04 16:56:05 -08001437 * bandwidth: specify bandwidth capacity of link
kelvin-onlabd3b64892015-01-20 13:26:24 -08001438 * lambdaAlloc: if True, intent will allocate lambda
shahshreyad0c80432014-12-04 16:56:05 -08001439 for the specified intent
Jon Halle3f39ff2015-01-13 11:50:53 -08001440 * ipProto: specify ip protocol
shahshreyad0c80432014-12-04 16:56:05 -08001441 * ipSrc: specify ip source address
1442 * ipDst: specify ip destination address
1443 * tcpSrc: specify tcp source port
1444 * tcpDst: specify tcp destination port
1445 * setEthSrc: action to Rewrite Source MAC Address
1446 * setEthDst: action to Rewrite Destination MAC Address
Jeremy Songster832f9e92016-05-05 14:30:49 -07001447 * vlanId: specify vlan Id
Jeremy Songsterff553672016-05-12 17:06:23 -07001448 * setVlan: specify VLAN Id treatment
Jeremy Songsterc032f162016-08-04 17:14:49 -07001449 * encap: specify a type of encapsulation
shahshreyad0c80432014-12-04 16:56:05 -08001450 Description:
kelvin8ec71442015-01-15 16:57:00 -08001451 Adds a multipoint-to-singlepoint intent ( uni-directional ) by
shahshreyad0c80432014-12-04 16:56:05 -08001452 specifying device id's and optional fields
kelvin-onlabfb521662015-02-27 09:52:40 -08001453 Returns:
1454 A string of the intent id or None on error
shahshreyad0c80432014-12-04 16:56:05 -08001455
Jon Halle3f39ff2015-01-13 11:50:53 -08001456 NOTE: This function may change depending on the
Jon Hallefbd9792015-03-05 16:11:36 -08001457 options developers provide for multipoint-to-singlepoint
shahshreyad0c80432014-12-04 16:56:05 -08001458 intent via cli
kelvin8ec71442015-01-15 16:57:00 -08001459 """
shahshreyad0c80432014-12-04 16:56:05 -08001460 try:
Jeremy Songsterff553672016-05-12 17:06:23 -07001461 cmd = "add-multi-to-single-intent"
shahshreyad0c80432014-12-04 16:56:05 -08001462
Jeremy Songsterff553672016-05-12 17:06:23 -07001463 if ethType:
1464 cmd += " --ethType " + str( ethType )
1465 if ethSrc:
1466 cmd += " --ethSrc " + str( ethSrc )
1467 if ethDst:
1468 cmd += " --ethDst " + str( ethDst )
1469 if bandwidth:
1470 cmd += " --bandwidth " + str( bandwidth )
1471 if lambdaAlloc:
1472 cmd += " --lambda "
1473 if ipProto:
1474 cmd += " --ipProto " + str( ipProto )
1475 if ipSrc:
1476 cmd += " --ipSrc " + str( ipSrc )
1477 if ipDst:
1478 cmd += " --ipDst " + str( ipDst )
1479 if tcpSrc:
1480 cmd += " --tcpSrc " + str( tcpSrc )
1481 if tcpDst:
1482 cmd += " --tcpDst " + str( tcpDst )
1483 if setEthSrc:
1484 cmd += " --setEthSrc " + str( setEthSrc )
1485 if setEthDst:
1486 cmd += " --setEthDst " + str( setEthDst )
1487 if vlanId:
1488 cmd += " -v " + str( vlanId )
1489 if setVlan:
1490 cmd += " --setVlan " + str( setVlan )
Jeremy Songster9385d412016-06-02 17:57:36 -07001491 if partial:
1492 cmd += " --partial"
Jeremy Songsterc032f162016-08-04 17:14:49 -07001493 if encap:
1494 cmd += " --encapsulation " + str( encap )
shahshreyad0c80432014-12-04 16:56:05 -08001495
kelvin8ec71442015-01-15 16:57:00 -08001496 # Check whether the user appended the port
1497 # or provided it as an input
shahshreyac2f97072015-03-19 17:04:29 -07001498
1499 if portIngressList is None:
1500 for ingressDevice in ingressDeviceList:
1501 if "/" in ingressDevice:
1502 cmd += " " + str( ingressDevice )
1503 else:
1504 main.log.error( "You must specify " +
Jon Hallbe379602015-03-24 13:39:32 -07001505 "the ingress port" )
shahshreyac2f97072015-03-19 17:04:29 -07001506 # TODO: perhaps more meaningful return
1507 return main.FALSE
shahshreyad0c80432014-12-04 16:56:05 -08001508 else:
Jon Hall71ce4e72015-03-23 14:05:58 -07001509 if len( ingressDeviceList ) == len( portIngressList ):
Jon Hall08f61bc2015-04-13 16:00:30 -07001510 for ingressDevice, portIngress in zip( ingressDeviceList,
1511 portIngressList ):
shahshreya70622b12015-03-19 17:19:00 -07001512 cmd += " " + \
1513 str( ingressDevice ) + "/" +\
1514 str( portIngress ) + " "
kelvin-onlab38143812015-04-01 15:03:01 -07001515 else:
Jon Hall08f61bc2015-04-13 16:00:30 -07001516 main.log.error( "Device list and port list does not " +
1517 "have the same length" )
kelvin-onlab38143812015-04-01 15:03:01 -07001518 return main.FALSE
kelvin-onlabd3b64892015-01-20 13:26:24 -08001519 if "/" in egressDevice:
1520 cmd += " " + str( egressDevice )
shahshreyad0c80432014-12-04 16:56:05 -08001521 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001522 if not portEgress:
kelvin8ec71442015-01-15 16:57:00 -08001523 main.log.error( "You must specify " +
1524 "the egress port" )
shahshreyad0c80432014-12-04 16:56:05 -08001525 return main.FALSE
Jon Halle3f39ff2015-01-13 11:50:53 -08001526
kelvin8ec71442015-01-15 16:57:00 -08001527 cmd += " " +\
kelvin-onlabd3b64892015-01-20 13:26:24 -08001528 str( egressDevice ) + "/" +\
1529 str( portEgress )
kelvin-onlab898a6c62015-01-16 14:13:53 -08001530 handle = self.sendline( cmd )
Jon Hallc6793552016-01-19 14:18:37 -08001531 assert "Command not found:" not in handle, handle
kelvin-onlabfb521662015-02-27 09:52:40 -08001532 # If error, return error message
kelvin-onlab898a6c62015-01-16 14:13:53 -08001533 if re.search( "Error", handle ):
kelvin-onlabfb521662015-02-27 09:52:40 -08001534 main.log.error( "Error in adding multipoint-to-singlepoint " +
1535 "intent" )
1536 return None
shahshreyad0c80432014-12-04 16:56:05 -08001537 else:
kelvin-onlabb9408212015-04-01 13:34:04 -07001538 match = re.search('id=0x([\da-f]+),', handle)
1539 if match:
1540 return match.group()[3:-1]
1541 else:
1542 main.log.error( "Error, intent ID not found" )
1543 return None
Jon Hallc6793552016-01-19 14:18:37 -08001544 except AssertionError:
1545 main.log.exception( "" )
1546 return None
kelvin-onlabb9408212015-04-01 13:34:04 -07001547 except TypeError:
1548 main.log.exception( self.name + ": Object not as expected" )
1549 return None
1550 except pexpect.EOF:
1551 main.log.error( self.name + ": EOF exception found" )
1552 main.log.error( self.name + ": " + self.handle.before )
1553 main.cleanup()
1554 main.exit()
1555 except Exception:
1556 main.log.exception( self.name + ": Uncaught exception!" )
1557 main.cleanup()
1558 main.exit()
1559
1560 def addSinglepointToMultipointIntent(
1561 self,
1562 ingressDevice,
1563 egressDeviceList,
1564 portIngress="",
1565 portEgressList=None,
1566 ethType="",
1567 ethSrc="",
1568 ethDst="",
1569 bandwidth="",
1570 lambdaAlloc=False,
1571 ipProto="",
1572 ipSrc="",
1573 ipDst="",
1574 tcpSrc="",
1575 tcpDst="",
1576 setEthSrc="",
Jeremy Songster832f9e92016-05-05 14:30:49 -07001577 setEthDst="",
Jeremy Songsterff553672016-05-12 17:06:23 -07001578 vlanId="",
Jeremy Songster9385d412016-06-02 17:57:36 -07001579 setVlan="",
Jeremy Songsterc032f162016-08-04 17:14:49 -07001580 partial=False,
1581 encap="" ):
kelvin-onlabb9408212015-04-01 13:34:04 -07001582 """
1583 Note:
1584 This function assumes the format of all egress devices
1585 is same. That is, all egress devices include port numbers
1586 with a "/" or all egress devices could specify device
1587 ids and port numbers seperately.
1588 Required:
1589 * EgressDeviceList: List of device ids of egress device
1590 ( Atleast 2 eress devices required in the list )
1591 * ingressDevice: device id of ingress device
1592 Optional:
1593 * ethType: specify ethType
1594 * ethSrc: specify ethSrc ( i.e. src mac addr )
1595 * ethDst: specify ethDst ( i.e. dst mac addr )
1596 * bandwidth: specify bandwidth capacity of link
1597 * lambdaAlloc: if True, intent will allocate lambda
1598 for the specified intent
1599 * ipProto: specify ip protocol
1600 * ipSrc: specify ip source address
1601 * ipDst: specify ip destination address
1602 * tcpSrc: specify tcp source port
1603 * tcpDst: specify tcp destination port
1604 * setEthSrc: action to Rewrite Source MAC Address
1605 * setEthDst: action to Rewrite Destination MAC Address
Jeremy Songster832f9e92016-05-05 14:30:49 -07001606 * vlanId: specify vlan Id
Jeremy Songsterff553672016-05-12 17:06:23 -07001607 * setVlan: specify VLAN ID treatment
Jeremy Songsterc032f162016-08-04 17:14:49 -07001608 * encap: specify an encapsulation type
kelvin-onlabb9408212015-04-01 13:34:04 -07001609 Description:
1610 Adds a singlepoint-to-multipoint intent ( uni-directional ) by
1611 specifying device id's and optional fields
1612 Returns:
1613 A string of the intent id or None on error
1614
1615 NOTE: This function may change depending on the
1616 options developers provide for singlepoint-to-multipoint
1617 intent via cli
1618 """
1619 try:
Jeremy Songsterff553672016-05-12 17:06:23 -07001620 cmd = "add-single-to-multi-intent"
kelvin-onlabb9408212015-04-01 13:34:04 -07001621
Jeremy Songsterff553672016-05-12 17:06:23 -07001622 if ethType:
1623 cmd += " --ethType " + str( ethType )
1624 if ethSrc:
1625 cmd += " --ethSrc " + str( ethSrc )
1626 if ethDst:
1627 cmd += " --ethDst " + str( ethDst )
1628 if bandwidth:
1629 cmd += " --bandwidth " + str( bandwidth )
1630 if lambdaAlloc:
1631 cmd += " --lambda "
1632 if ipProto:
1633 cmd += " --ipProto " + str( ipProto )
1634 if ipSrc:
1635 cmd += " --ipSrc " + str( ipSrc )
1636 if ipDst:
1637 cmd += " --ipDst " + str( ipDst )
1638 if tcpSrc:
1639 cmd += " --tcpSrc " + str( tcpSrc )
1640 if tcpDst:
1641 cmd += " --tcpDst " + str( tcpDst )
1642 if setEthSrc:
1643 cmd += " --setEthSrc " + str( setEthSrc )
1644 if setEthDst:
1645 cmd += " --setEthDst " + str( setEthDst )
1646 if vlanId:
1647 cmd += " -v " + str( vlanId )
1648 if setVlan:
1649 cmd += " --setVlan " + str( setVlan )
Jeremy Songster9385d412016-06-02 17:57:36 -07001650 if partial:
1651 cmd += " --partial"
Jeremy Songsterc032f162016-08-04 17:14:49 -07001652 if encap:
1653 cmd += " --encapsulation " + str( encap )
kelvin-onlabb9408212015-04-01 13:34:04 -07001654
1655 # Check whether the user appended the port
1656 # or provided it as an input
Jon Hall08f61bc2015-04-13 16:00:30 -07001657
kelvin-onlabb9408212015-04-01 13:34:04 -07001658 if "/" in ingressDevice:
1659 cmd += " " + str( ingressDevice )
1660 else:
1661 if not portIngress:
1662 main.log.error( "You must specify " +
1663 "the Ingress port" )
1664 return main.FALSE
1665
1666 cmd += " " +\
1667 str( ingressDevice ) + "/" +\
1668 str( portIngress )
1669
1670 if portEgressList is None:
1671 for egressDevice in egressDeviceList:
1672 if "/" in egressDevice:
1673 cmd += " " + str( egressDevice )
1674 else:
1675 main.log.error( "You must specify " +
1676 "the egress port" )
1677 # TODO: perhaps more meaningful return
1678 return main.FALSE
1679 else:
1680 if len( egressDeviceList ) == len( portEgressList ):
Jon Hall08f61bc2015-04-13 16:00:30 -07001681 for egressDevice, portEgress in zip( egressDeviceList,
1682 portEgressList ):
kelvin-onlabb9408212015-04-01 13:34:04 -07001683 cmd += " " + \
1684 str( egressDevice ) + "/" +\
1685 str( portEgress )
kelvin-onlab38143812015-04-01 15:03:01 -07001686 else:
Jon Hall08f61bc2015-04-13 16:00:30 -07001687 main.log.error( "Device list and port list does not " +
1688 "have the same length" )
kelvin-onlab38143812015-04-01 15:03:01 -07001689 return main.FALSE
kelvin-onlabb9408212015-04-01 13:34:04 -07001690 handle = self.sendline( cmd )
Jon Hallc6793552016-01-19 14:18:37 -08001691 assert "Command not found:" not in handle, handle
kelvin-onlabb9408212015-04-01 13:34:04 -07001692 # If error, return error message
1693 if re.search( "Error", handle ):
1694 main.log.error( "Error in adding singlepoint-to-multipoint " +
1695 "intent" )
shahshreyac2f97072015-03-19 17:04:29 -07001696 return None
kelvin-onlabb9408212015-04-01 13:34:04 -07001697 else:
1698 match = re.search('id=0x([\da-f]+),', handle)
1699 if match:
1700 return match.group()[3:-1]
1701 else:
1702 main.log.error( "Error, intent ID not found" )
1703 return None
Jon Hallc6793552016-01-19 14:18:37 -08001704 except AssertionError:
1705 main.log.exception( "" )
1706 return None
Jon Halld4d4b372015-01-28 16:02:41 -08001707 except TypeError:
1708 main.log.exception( self.name + ": Object not as expected" )
1709 return None
shahshreyad0c80432014-12-04 16:56:05 -08001710 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001711 main.log.error( self.name + ": EOF exception found" )
1712 main.log.error( self.name + ": " + self.handle.before )
shahshreyad0c80432014-12-04 16:56:05 -08001713 main.cleanup()
1714 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001715 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001716 main.log.exception( self.name + ": Uncaught exception!" )
shahshreyad0c80432014-12-04 16:56:05 -08001717 main.cleanup()
1718 main.exit()
1719
Hari Krishna9e232602015-04-13 17:29:08 -07001720 def addMplsIntent(
1721 self,
1722 ingressDevice,
1723 egressDevice,
Hari Krishna87a17f12015-04-13 17:42:23 -07001724 ingressPort="",
1725 egressPort="",
Hari Krishna9e232602015-04-13 17:29:08 -07001726 ethType="",
1727 ethSrc="",
1728 ethDst="",
1729 bandwidth="",
1730 lambdaAlloc=False,
1731 ipProto="",
1732 ipSrc="",
1733 ipDst="",
1734 tcpSrc="",
1735 tcpDst="",
Hari Krishna87a17f12015-04-13 17:42:23 -07001736 ingressLabel="",
Hari Krishnadfff6672015-04-13 17:53:27 -07001737 egressLabel="",
Hari Krishna9e232602015-04-13 17:29:08 -07001738 priority=""):
1739 """
1740 Required:
1741 * ingressDevice: device id of ingress device
1742 * egressDevice: device id of egress device
1743 Optional:
1744 * ethType: specify ethType
1745 * ethSrc: specify ethSrc ( i.e. src mac addr )
1746 * ethDst: specify ethDst ( i.e. dst mac addr )
1747 * bandwidth: specify bandwidth capacity of link
1748 * lambdaAlloc: if True, intent will allocate lambda
1749 for the specified intent
1750 * ipProto: specify ip protocol
1751 * ipSrc: specify ip source address
1752 * ipDst: specify ip destination address
1753 * tcpSrc: specify tcp source port
1754 * tcpDst: specify tcp destination port
1755 * ingressLabel: Ingress MPLS label
1756 * egressLabel: Egress MPLS label
1757 Description:
1758 Adds MPLS intent by
1759 specifying device id's and optional fields
1760 Returns:
1761 A string of the intent id or None on error
1762
1763 NOTE: This function may change depending on the
1764 options developers provide for MPLS
1765 intent via cli
1766 """
1767 try:
Jeremy Songsterff553672016-05-12 17:06:23 -07001768 cmd = "add-mpls-intent"
Hari Krishna9e232602015-04-13 17:29:08 -07001769
Jeremy Songsterff553672016-05-12 17:06:23 -07001770 if ethType:
1771 cmd += " --ethType " + str( ethType )
1772 if ethSrc:
1773 cmd += " --ethSrc " + str( ethSrc )
1774 if ethDst:
1775 cmd += " --ethDst " + str( ethDst )
1776 if bandwidth:
1777 cmd += " --bandwidth " + str( bandwidth )
1778 if lambdaAlloc:
1779 cmd += " --lambda "
1780 if ipProto:
1781 cmd += " --ipProto " + str( ipProto )
1782 if ipSrc:
1783 cmd += " --ipSrc " + str( ipSrc )
1784 if ipDst:
1785 cmd += " --ipDst " + str( ipDst )
1786 if tcpSrc:
1787 cmd += " --tcpSrc " + str( tcpSrc )
1788 if tcpDst:
1789 cmd += " --tcpDst " + str( tcpDst )
1790 if ingressLabel:
1791 cmd += " --ingressLabel " + str( ingressLabel )
1792 if egressLabel:
1793 cmd += " --egressLabel " + str( egressLabel )
1794 if priority:
1795 cmd += " --priority " + str( priority )
Hari Krishna9e232602015-04-13 17:29:08 -07001796
1797 # Check whether the user appended the port
1798 # or provided it as an input
1799 if "/" in ingressDevice:
1800 cmd += " " + str( ingressDevice )
1801 else:
Hari Krishna87a17f12015-04-13 17:42:23 -07001802 if not ingressPort:
Hari Krishna9e232602015-04-13 17:29:08 -07001803 main.log.error( "You must specify the ingress port" )
1804 return None
1805
1806 cmd += " " + \
1807 str( ingressDevice ) + "/" +\
Hari Krishna87a17f12015-04-13 17:42:23 -07001808 str( ingressPort ) + " "
Hari Krishna9e232602015-04-13 17:29:08 -07001809
1810 if "/" in egressDevice:
1811 cmd += " " + str( egressDevice )
1812 else:
Hari Krishna87a17f12015-04-13 17:42:23 -07001813 if not egressPort:
Hari Krishna9e232602015-04-13 17:29:08 -07001814 main.log.error( "You must specify the egress port" )
1815 return None
1816
1817 cmd += " " +\
1818 str( egressDevice ) + "/" +\
Hari Krishna87a17f12015-04-13 17:42:23 -07001819 str( egressPort )
Hari Krishna9e232602015-04-13 17:29:08 -07001820
1821 handle = self.sendline( cmd )
Jon Hallc6793552016-01-19 14:18:37 -08001822 assert "Command not found:" not in handle, handle
Hari Krishna9e232602015-04-13 17:29:08 -07001823 # If error, return error message
1824 if re.search( "Error", handle ):
1825 main.log.error( "Error in adding mpls intent" )
1826 return None
1827 else:
1828 # TODO: print out all the options in this message?
1829 main.log.info( "MPLS intent installed between " +
1830 str( ingressDevice ) + " and " +
1831 str( egressDevice ) )
1832 match = re.search('id=0x([\da-f]+),', handle)
1833 if match:
1834 return match.group()[3:-1]
1835 else:
1836 main.log.error( "Error, intent ID not found" )
1837 return None
Jon Hallc6793552016-01-19 14:18:37 -08001838 except AssertionError:
1839 main.log.exception( "" )
1840 return None
Hari Krishna9e232602015-04-13 17:29:08 -07001841 except TypeError:
1842 main.log.exception( self.name + ": Object not as expected" )
1843 return None
1844 except pexpect.EOF:
1845 main.log.error( self.name + ": EOF exception found" )
1846 main.log.error( self.name + ": " + self.handle.before )
1847 main.cleanup()
1848 main.exit()
1849 except Exception:
1850 main.log.exception( self.name + ": Uncaught exception!" )
1851 main.cleanup()
1852 main.exit()
1853
Jon Hallefbd9792015-03-05 16:11:36 -08001854 def removeIntent( self, intentId, app='org.onosproject.cli',
1855 purge=False, sync=False ):
kelvin-onlab898a6c62015-01-16 14:13:53 -08001856 """
shahshreya1c818fc2015-02-26 13:44:08 -08001857 Remove intent for specified application id and intent id
Jon Hall61282e32015-03-19 11:34:11 -07001858 Optional args:-
shahshreya1c818fc2015-02-26 13:44:08 -08001859 -s or --sync: Waits for the removal before returning
Jon Hall61282e32015-03-19 11:34:11 -07001860 -p or --purge: Purge the intent from the store after removal
1861
Jon Halle3f39ff2015-01-13 11:50:53 -08001862 Returns:
Jon Hall6509dbf2016-06-21 17:01:17 -07001863 main.FALSE on error and
Jon Halle3f39ff2015-01-13 11:50:53 -08001864 cli output otherwise
kelvin-onlab898a6c62015-01-16 14:13:53 -08001865 """
andrewonlab9a50dfe2014-10-17 17:22:31 -04001866 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07001867 cmdStr = "remove-intent"
shahshreya1c818fc2015-02-26 13:44:08 -08001868 if purge:
1869 cmdStr += " -p"
1870 if sync:
1871 cmdStr += " -s"
1872
1873 cmdStr += " " + app + " " + str( intentId )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001874 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08001875 assert "Command not found:" not in handle, handle
Jon Halle3f39ff2015-01-13 11:50:53 -08001876 if re.search( "Error", handle ):
kelvin-onlab898a6c62015-01-16 14:13:53 -08001877 main.log.error( "Error in removing intent" )
Jon Halle3f39ff2015-01-13 11:50:53 -08001878 return main.FALSE
andrewonlab9a50dfe2014-10-17 17:22:31 -04001879 else:
Jon Halle3f39ff2015-01-13 11:50:53 -08001880 # TODO: Should this be main.TRUE
1881 return handle
Jon Hallc6793552016-01-19 14:18:37 -08001882 except AssertionError:
1883 main.log.exception( "" )
1884 return None
Jon Halld4d4b372015-01-28 16:02:41 -08001885 except TypeError:
1886 main.log.exception( self.name + ": Object not as expected" )
1887 return None
andrewonlab9a50dfe2014-10-17 17:22:31 -04001888 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001889 main.log.error( self.name + ": EOF exception found" )
1890 main.log.error( self.name + ": " + self.handle.before )
andrewonlab9a50dfe2014-10-17 17:22:31 -04001891 main.cleanup()
1892 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001893 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001894 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab9a50dfe2014-10-17 17:22:31 -04001895 main.cleanup()
1896 main.exit()
1897
YPZhangfebf7302016-05-24 16:45:56 -07001898 def removeAllIntents( self, purge=False, sync=False, app='org.onosproject.cli', timeout=30 ):
Jeremy42df2e72016-02-23 16:37:46 -08001899 """
1900 Description:
1901 Remove all the intents
1902 Optional args:-
1903 -s or --sync: Waits for the removal before returning
1904 -p or --purge: Purge the intent from the store after removal
1905 Returns:
1906 Returns main.TRUE if all intents are removed, otherwise returns
1907 main.FALSE; Returns None for exception
1908 """
1909 try:
1910 cmdStr = "remove-intent"
1911 if purge:
1912 cmdStr += " -p"
1913 if sync:
1914 cmdStr += " -s"
1915
1916 cmdStr += " " + app
YPZhangfebf7302016-05-24 16:45:56 -07001917 handle = self.sendline( cmdStr, timeout=timeout )
Jeremy42df2e72016-02-23 16:37:46 -08001918 assert "Command not found:" not in handle, handle
1919 if re.search( "Error", handle ):
1920 main.log.error( "Error in removing intent" )
1921 return main.FALSE
1922 else:
1923 return main.TRUE
1924 except AssertionError:
1925 main.log.exception( "" )
1926 return None
1927 except TypeError:
1928 main.log.exception( self.name + ": Object not as expected" )
1929 return None
1930 except pexpect.EOF:
1931 main.log.error( self.name + ": EOF exception found" )
1932 main.log.error( self.name + ": " + self.handle.before )
1933 main.cleanup()
1934 main.exit()
1935 except Exception:
1936 main.log.exception( self.name + ": Uncaught exception!" )
1937 main.cleanup()
1938 main.exit()
1939
Hari Krishnaacabd5a2015-07-01 17:10:19 -07001940 def purgeWithdrawnIntents( self ):
Hari Krishna0ce0e152015-06-23 09:55:29 -07001941 """
1942 Purges all WITHDRAWN Intents
1943 """
1944 try:
1945 cmdStr = "purge-intents"
1946 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08001947 assert "Command not found:" not in handle, handle
Hari Krishna0ce0e152015-06-23 09:55:29 -07001948 if re.search( "Error", handle ):
1949 main.log.error( "Error in purging intents" )
1950 return main.FALSE
1951 else:
1952 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -08001953 except AssertionError:
1954 main.log.exception( "" )
1955 return None
Hari Krishna0ce0e152015-06-23 09:55:29 -07001956 except TypeError:
1957 main.log.exception( self.name + ": Object not as expected" )
1958 return None
1959 except pexpect.EOF:
1960 main.log.error( self.name + ": EOF exception found" )
1961 main.log.error( self.name + ": " + self.handle.before )
1962 main.cleanup()
1963 main.exit()
1964 except Exception:
1965 main.log.exception( self.name + ": Uncaught exception!" )
1966 main.cleanup()
1967 main.exit()
1968
kelvin-onlabd3b64892015-01-20 13:26:24 -08001969 def routes( self, jsonFormat=False ):
kelvin8ec71442015-01-15 16:57:00 -08001970 """
kelvin-onlab898a6c62015-01-16 14:13:53 -08001971 NOTE: This method should be used after installing application:
1972 onos-app-sdnip
pingping-lin8b306ac2014-11-17 18:13:51 -08001973 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001974 * jsonFormat: enable output formatting in json
pingping-lin8b306ac2014-11-17 18:13:51 -08001975 Description:
1976 Obtain all routes in the system
kelvin8ec71442015-01-15 16:57:00 -08001977 """
pingping-lin8b306ac2014-11-17 18:13:51 -08001978 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07001979 cmdStr = "routes"
kelvin-onlabd3b64892015-01-20 13:26:24 -08001980 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07001981 cmdStr += " -j"
1982 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08001983 assert "Command not found:" not in handle, handle
pingping-lin8b306ac2014-11-17 18:13:51 -08001984 return handle
Jon Hallc6793552016-01-19 14:18:37 -08001985 except AssertionError:
1986 main.log.exception( "" )
1987 return None
Jon Halld4d4b372015-01-28 16:02:41 -08001988 except TypeError:
1989 main.log.exception( self.name + ": Object not as expected" )
1990 return None
pingping-lin8b306ac2014-11-17 18:13:51 -08001991 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001992 main.log.error( self.name + ": EOF exception found" )
1993 main.log.error( self.name + ": " + self.handle.before )
pingping-lin8b306ac2014-11-17 18:13:51 -08001994 main.cleanup()
1995 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001996 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001997 main.log.exception( self.name + ": Uncaught exception!" )
pingping-lin8b306ac2014-11-17 18:13:51 -08001998 main.cleanup()
1999 main.exit()
2000
pingping-lin54b03372015-08-13 14:43:10 -07002001 def ipv4RouteNumber( self ):
2002 """
2003 NOTE: This method should be used after installing application:
2004 onos-app-sdnip
2005 Description:
2006 Obtain the total IPv4 routes number in the system
2007 """
2008 try:
2009 cmdStr = "routes -s -j"
2010 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002011 assert "Command not found:" not in handle, handle
pingping-lin54b03372015-08-13 14:43:10 -07002012 jsonResult = json.loads( handle )
2013 return jsonResult['totalRoutes4']
Jon Hallc6793552016-01-19 14:18:37 -08002014 except AssertionError:
2015 main.log.exception( "" )
2016 return None
2017 except ( TypeError, ValueError ):
2018 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, handle ) )
pingping-lin54b03372015-08-13 14:43:10 -07002019 return None
2020 except pexpect.EOF:
2021 main.log.error( self.name + ": EOF exception found" )
2022 main.log.error( self.name + ": " + self.handle.before )
2023 main.cleanup()
2024 main.exit()
2025 except Exception:
2026 main.log.exception( self.name + ": Uncaught exception!" )
2027 main.cleanup()
2028 main.exit()
2029
pingping-lin8244a3b2015-09-16 13:36:56 -07002030 def intents( self, jsonFormat = True, summary = False, **intentargs):
kelvin8ec71442015-01-15 16:57:00 -08002031 """
andrewonlabe6745342014-10-17 14:29:13 -04002032 Description:
Jon Hallff566d52016-01-15 14:45:36 -08002033 Obtain intents from the ONOS cli.
2034 Optional:
2035 * jsonFormat: Enable output formatting in json, default to True
2036 * summary: Whether only output the intent summary, defaults to False
2037 * type: Only output a certain type of intent. This options is valid
2038 only when jsonFormat is True and summary is True.
kelvin-onlab898a6c62015-01-16 14:13:53 -08002039 """
andrewonlabe6745342014-10-17 14:29:13 -04002040 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002041 cmdStr = "intents"
pingping-lin8244a3b2015-09-16 13:36:56 -07002042 if summary:
2043 cmdStr += " -s"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002044 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002045 cmdStr += " -j"
2046 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002047 assert "Command not found:" not in handle, handle
pingping-lin8244a3b2015-09-16 13:36:56 -07002048 args = utilities.parse_args( [ "TYPE" ], **intentargs )
acsmars5b5fbaf2015-09-18 10:38:20 -07002049 if "TYPE" in args.keys():
Jon Hallff566d52016-01-15 14:45:36 -08002050 intentType = args[ "TYPE" ]
acsmars5b5fbaf2015-09-18 10:38:20 -07002051 else:
Jon Hallff566d52016-01-15 14:45:36 -08002052 intentType = ""
2053 # IF we want the summary of a specific intent type
2054 if jsonFormat and summary and ( intentType != "" ):
pingping-lin8244a3b2015-09-16 13:36:56 -07002055 jsonResult = json.loads( handle )
Jon Hallff566d52016-01-15 14:45:36 -08002056 if intentType in jsonResult.keys():
2057 return jsonResult[ intentType ]
pingping-lin8244a3b2015-09-16 13:36:56 -07002058 else:
Jon Hallff566d52016-01-15 14:45:36 -08002059 main.log.error( "unknown TYPE, returning all types of intents" )
pingping-lin8244a3b2015-09-16 13:36:56 -07002060 return handle
2061 else:
2062 return handle
Jon Hallc6793552016-01-19 14:18:37 -08002063 except AssertionError:
2064 main.log.exception( "" )
2065 return None
2066 except ( TypeError, ValueError ):
2067 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, handle ) )
pingping-lin54b03372015-08-13 14:43:10 -07002068 return None
2069 except pexpect.EOF:
2070 main.log.error( self.name + ": EOF exception found" )
2071 main.log.error( self.name + ": " + self.handle.before )
2072 main.cleanup()
2073 main.exit()
2074 except Exception:
2075 main.log.exception( self.name + ": Uncaught exception!" )
2076 main.cleanup()
2077 main.exit()
2078
kelvin-onlab54400a92015-02-26 18:05:51 -08002079 def getIntentState(self, intentsId, intentsJson=None):
2080 """
You Wangfdcbfc42016-05-16 12:16:53 -07002081 Description:
2082 Gets intent state. Accepts a single intent ID (string type) or a
2083 list of intent IDs.
2084 Parameters:
2085 intentsId: intent ID, both string type and list type are acceptable
kelvin-onlab54400a92015-02-26 18:05:51 -08002086 intentsJson: parsed json object from the onos:intents api
You Wangfdcbfc42016-05-16 12:16:53 -07002087 Returns:
2088 Returns the state (string type) of the ID if a single intent ID is
2089 accepted.
2090 Returns a list of dictionaries if a list of intent IDs is accepted,
2091 and each dictionary maps 'id' to the Intent ID and 'state' to
2092 corresponding intent state.
kelvin-onlab54400a92015-02-26 18:05:51 -08002093 """
kelvin-onlab54400a92015-02-26 18:05:51 -08002094 try:
2095 state = "State is Undefined"
2096 if not intentsJson:
Jon Hallc6793552016-01-19 14:18:37 -08002097 rawJson = self.intents()
kelvin-onlab54400a92015-02-26 18:05:51 -08002098 else:
Jon Hallc6793552016-01-19 14:18:37 -08002099 rawJson = intentsJson
2100 parsedIntentsJson = json.loads( rawJson )
Jon Hallefbd9792015-03-05 16:11:36 -08002101 if isinstance( intentsId, types.StringType ):
Jon Hallc6793552016-01-19 14:18:37 -08002102 for intent in parsedIntentsJson:
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07002103 if intentsId == intent[ 'id' ]:
2104 state = intent[ 'state' ]
kelvin-onlab54400a92015-02-26 18:05:51 -08002105 return state
Jon Hallefbd9792015-03-05 16:11:36 -08002106 main.log.info( "Cannot find intent ID" + str( intentsId ) +
2107 " on the list" )
kelvin-onlab54400a92015-02-26 18:05:51 -08002108 return state
Jon Hallefbd9792015-03-05 16:11:36 -08002109 elif isinstance( intentsId, types.ListType ):
kelvin-onlab07dbd012015-03-04 16:29:39 -08002110 dictList = []
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07002111 for i in xrange( len( intentsId ) ):
kelvin-onlab07dbd012015-03-04 16:29:39 -08002112 stateDict = {}
Jon Hallc6793552016-01-19 14:18:37 -08002113 for intents in parsedIntentsJson:
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07002114 if intentsId[ i ] == intents[ 'id' ]:
2115 stateDict[ 'state' ] = intents[ 'state' ]
2116 stateDict[ 'id' ] = intentsId[ i ]
Jon Hallefbd9792015-03-05 16:11:36 -08002117 dictList.append( stateDict )
kelvin-onlab54400a92015-02-26 18:05:51 -08002118 break
Jon Hallefbd9792015-03-05 16:11:36 -08002119 if len( intentsId ) != len( dictList ):
2120 main.log.info( "Cannot find some of the intent ID state" )
kelvin-onlab07dbd012015-03-04 16:29:39 -08002121 return dictList
kelvin-onlab54400a92015-02-26 18:05:51 -08002122 else:
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07002123 main.log.info( "Invalid intents ID entry" )
kelvin-onlab54400a92015-02-26 18:05:51 -08002124 return None
Jon Hallc6793552016-01-19 14:18:37 -08002125 except ( TypeError, ValueError ):
2126 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, rawJson ) )
kelvin-onlab54400a92015-02-26 18:05:51 -08002127 return None
2128 except pexpect.EOF:
2129 main.log.error( self.name + ": EOF exception found" )
2130 main.log.error( self.name + ": " + self.handle.before )
2131 main.cleanup()
2132 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002133 except Exception:
kelvin-onlab54400a92015-02-26 18:05:51 -08002134 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabe6745342014-10-17 14:29:13 -04002135 main.cleanup()
2136 main.exit()
Jon Hall390696c2015-05-05 17:13:41 -07002137
kelvin-onlabf512e942015-06-08 19:42:59 -07002138 def checkIntentState( self, intentsId, expectedState='INSTALLED' ):
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07002139 """
2140 Description:
2141 Check intents state
2142 Required:
2143 intentsId - List of intents ID to be checked
2144 Optional:
kelvin-onlabf512e942015-06-08 19:42:59 -07002145 expectedState - Check the expected state(s) of each intents
2146 state in the list.
2147 *NOTE: You can pass in a list of expected state,
2148 Eg: expectedState = [ 'INSTALLED' , 'INSTALLING' ]
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07002149 Return:
kelvin-onlabf512e942015-06-08 19:42:59 -07002150 Returns main.TRUE only if all intent are the same as expected states
2151 , otherwise, returns main.FALSE.
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07002152 """
2153 try:
2154 # Generating a dictionary: intent id as a key and state as value
kelvin-onlabf512e942015-06-08 19:42:59 -07002155 returnValue = main.TRUE
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07002156 intentsDict = self.getIntentState( intentsId )
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07002157 if len( intentsId ) != len( intentsDict ):
Jon Hallae04e622016-01-27 10:38:05 -08002158 main.log.info( self.name + ": There is something wrong " +
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07002159 "getting intents state" )
2160 return main.FALSE
kelvin-onlabf512e942015-06-08 19:42:59 -07002161
2162 if isinstance( expectedState, types.StringType ):
2163 for intents in intentsDict:
2164 if intents.get( 'state' ) != expectedState:
kelvin-onlaba297c4d2015-06-01 13:53:55 -07002165 main.log.debug( self.name + " : Intent ID - " +
2166 intents.get( 'id' ) +
kelvin-onlabf512e942015-06-08 19:42:59 -07002167 " actual state = " +
2168 intents.get( 'state' )
2169 + " does not equal expected state = "
2170 + expectedState )
kelvin-onlaba297c4d2015-06-01 13:53:55 -07002171 returnValue = main.FALSE
kelvin-onlabf512e942015-06-08 19:42:59 -07002172
2173 elif isinstance( expectedState, types.ListType ):
2174 for intents in intentsDict:
2175 if not any( state == intents.get( 'state' ) for state in
2176 expectedState ):
2177 main.log.debug( self.name + " : Intent ID - " +
2178 intents.get( 'id' ) +
2179 " actual state = " +
2180 intents.get( 'state' ) +
2181 " does not equal expected states = "
2182 + str( expectedState ) )
2183 returnValue = main.FALSE
2184
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07002185 if returnValue == main.TRUE:
2186 main.log.info( self.name + ": All " +
2187 str( len( intentsDict ) ) +
kelvin-onlabf512e942015-06-08 19:42:59 -07002188 " intents are in " + str( expectedState ) +
2189 " state" )
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07002190 return returnValue
2191 except TypeError:
2192 main.log.exception( self.name + ": Object not as expected" )
2193 return None
2194 except pexpect.EOF:
2195 main.log.error( self.name + ": EOF exception found" )
2196 main.log.error( self.name + ": " + self.handle.before )
2197 main.cleanup()
2198 main.exit()
2199 except Exception:
2200 main.log.exception( self.name + ": Uncaught exception!" )
2201 main.cleanup()
2202 main.exit()
andrewonlabe6745342014-10-17 14:29:13 -04002203
You Wang66518af2016-05-16 15:32:59 -07002204 def compareIntent( self, intentDict ):
2205 """
2206 Description:
2207 Compare the intent ids and states provided in the argument with all intents in ONOS
2208 Return:
2209 Returns main.TRUE if the two sets of intents match exactly, otherwise main.FALSE
2210 Arguments:
2211 intentDict: a dictionary which maps intent ids to intent states
2212 """
2213 try:
2214 intentsRaw = self.intents()
2215 intentsJson = json.loads( intentsRaw )
2216 intentDictONOS = {}
2217 for intent in intentsJson:
2218 intentDictONOS[ intent[ 'id' ] ] = intent[ 'state' ]
You Wang58d04452016-09-21 15:13:05 -07002219 returnValue = main.TRUE
You Wang66518af2016-05-16 15:32:59 -07002220 if len( intentDict ) != len( intentDictONOS ):
You Wang58d04452016-09-21 15:13:05 -07002221 main.log.warn( self.name + ": expected intent count does not match that in ONOS, " +
You Wang66518af2016-05-16 15:32:59 -07002222 str( len( intentDict ) ) + " expected and " +
2223 str( len( intentDictONOS ) ) + " actual" )
You Wang58d04452016-09-21 15:13:05 -07002224 returnValue = main.FALSE
You Wang66518af2016-05-16 15:32:59 -07002225 for intentID in intentDict.keys():
2226 if not intentID in intentDictONOS.keys():
2227 main.log.debug( self.name + ": intent ID - " + intentID + " is not in ONOS" )
2228 returnValue = main.FALSE
You Wang58d04452016-09-21 15:13:05 -07002229 else:
2230 if intentDict[ intentID ] != intentDictONOS[ intentID ]:
2231 main.log.debug( self.name + ": intent ID - " + intentID +
2232 " expected state is " + intentDict[ intentID ] +
2233 " but actual state is " + intentDictONOS[ intentID ] )
2234 returnValue = main.FALSE
2235 intentDictONOS.pop( intentID )
2236 if len( intentDictONOS ) > 0:
2237 returnValue = main.FALSE
2238 for intentID in intentDictONOS.keys():
2239 main.log.debug( self.name + ": find extra intent in ONOS: intent ID " + intentID )
You Wang66518af2016-05-16 15:32:59 -07002240 if returnValue == main.TRUE:
2241 main.log.info( self.name + ": all intent IDs and states match that in ONOS" )
2242 return returnValue
You Wang1be9a512016-05-26 16:54:17 -07002243 except KeyError:
2244 main.log.exception( self.name + ": KeyError exception found" )
2245 return main.ERROR
You Wang66518af2016-05-16 15:32:59 -07002246 except ( TypeError, ValueError ):
2247 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, intentsRaw ) )
You Wang85560372016-05-18 10:44:33 -07002248 return main.ERROR
You Wang66518af2016-05-16 15:32:59 -07002249 except pexpect.EOF:
2250 main.log.error( self.name + ": EOF exception found" )
2251 main.log.error( self.name + ": " + self.handle.before )
2252 main.cleanup()
2253 main.exit()
2254 except Exception:
2255 main.log.exception( self.name + ": Uncaught exception!" )
2256 main.cleanup()
2257 main.exit()
2258
YPZhang14a4aa92016-07-15 13:37:15 -07002259 def checkIntentSummary( self, timeout=60, noExit=True ):
GlennRCed771242016-01-13 17:02:47 -08002260 """
2261 Description:
2262 Check the number of installed intents.
2263 Optional:
2264 timeout - the timeout for pexcept
YPZhang14a4aa92016-07-15 13:37:15 -07002265 noExit - If noExit, TestON will not exit if any except.
GlennRCed771242016-01-13 17:02:47 -08002266 Return:
2267 Returns main.TRUE only if the number of all installed intents are the same as total intents number
2268 , otherwise, returns main.FALSE.
2269 """
2270
2271 try:
2272 cmd = "intents -s -j"
2273
2274 # Check response if something wrong
YPZhang14a4aa92016-07-15 13:37:15 -07002275 response = self.sendline( cmd, timeout=timeout, noExit=noExit )
GlennRCed771242016-01-13 17:02:47 -08002276 if response == None:
YPZhang0584d432016-06-21 15:20:13 -07002277 return main.FALSE
GlennRCed771242016-01-13 17:02:47 -08002278 response = json.loads( response )
2279
2280 # get total and installed number, see if they are match
2281 allState = response.get( 'all' )
2282 if allState.get('total') == allState.get('installed'):
YPZhangb5d3f832016-01-23 22:54:26 -08002283 main.log.info( 'Total Intents: {} Installed Intents: {}'.format( allState.get('total'), allState.get('installed') ) )
GlennRCed771242016-01-13 17:02:47 -08002284 return main.TRUE
YPZhangb5d3f832016-01-23 22:54:26 -08002285 main.log.info( 'Verified Intents failed Excepte intetnes: {} installed intents: {}'.format( allState.get('total'), allState.get('installed') ) )
GlennRCed771242016-01-13 17:02:47 -08002286 return main.FALSE
2287
Jon Hallc6793552016-01-19 14:18:37 -08002288 except ( TypeError, ValueError ):
2289 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, response ) )
GlennRCed771242016-01-13 17:02:47 -08002290 return None
2291 except pexpect.EOF:
2292 main.log.error( self.name + ": EOF exception found" )
2293 main.log.error( self.name + ": " + self.handle.before )
YPZhang14a4aa92016-07-15 13:37:15 -07002294 if noExit:
2295 return main.FALSE
2296 else:
2297 main.cleanup()
2298 main.exit()
GlennRCed771242016-01-13 17:02:47 -08002299 except Exception:
2300 main.log.exception( self.name + ": Uncaught exception!" )
YPZhang14a4aa92016-07-15 13:37:15 -07002301 if noExit:
2302 return main.FALSE
2303 else:
2304 main.cleanup()
2305 main.exit()
YPZhangebf9eb52016-05-12 15:20:24 -07002306 except pexpect.TIMEOUT:
2307 main.log.error( self.name + ": ONOS timeout" )
2308 return None
GlennRCed771242016-01-13 17:02:47 -08002309
Jeremy Songster306ed7a2016-07-19 10:59:07 -07002310 def flows( self, state="", jsonFormat=True, timeout=60, noExit=False, noCore=False ):
kelvin8ec71442015-01-15 16:57:00 -08002311 """
Shreya Shah0f01c812014-10-26 20:15:28 -04002312 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002313 * jsonFormat: enable output formatting in json
Jeremy Songster306ed7a2016-07-19 10:59:07 -07002314 * noCore: suppress core flows
Shreya Shah0f01c812014-10-26 20:15:28 -04002315 Description:
Jon Halle3f39ff2015-01-13 11:50:53 -08002316 Obtain flows currently installed
kelvin-onlab898a6c62015-01-16 14:13:53 -08002317 """
Shreya Shah0f01c812014-10-26 20:15:28 -04002318 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002319 cmdStr = "flows"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002320 if jsonFormat:
GlennRCed771242016-01-13 17:02:47 -08002321 cmdStr += " -j "
Jeremy Songster306ed7a2016-07-19 10:59:07 -07002322 if noCore:
2323 cmdStr += " -n "
GlennRCed771242016-01-13 17:02:47 -08002324 cmdStr += state
YPZhangebf9eb52016-05-12 15:20:24 -07002325 handle = self.sendline( cmdStr, timeout=timeout, noExit=noExit )
Jon Hallc6793552016-01-19 14:18:37 -08002326 assert "Command not found:" not in handle, handle
2327 if re.search( "Error:", handle ):
2328 main.log.error( self.name + ": flows() response: " +
2329 str( handle ) )
2330 return handle
2331 except AssertionError:
2332 main.log.exception( "" )
GlennRCed771242016-01-13 17:02:47 -08002333 return None
Jon Halld4d4b372015-01-28 16:02:41 -08002334 except TypeError:
2335 main.log.exception( self.name + ": Object not as expected" )
2336 return None
Jon Hallc6793552016-01-19 14:18:37 -08002337 except pexpect.TIMEOUT:
2338 main.log.error( self.name + ": ONOS timeout" )
2339 return None
Shreya Shah0f01c812014-10-26 20:15:28 -04002340 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002341 main.log.error( self.name + ": EOF exception found" )
2342 main.log.error( self.name + ": " + self.handle.before )
Shreya Shah0f01c812014-10-26 20:15:28 -04002343 main.cleanup()
2344 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002345 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002346 main.log.exception( self.name + ": Uncaught exception!" )
Shreya Shah0f01c812014-10-26 20:15:28 -04002347 main.cleanup()
2348 main.exit()
2349
Flavio Castrod2ffffa2016-04-26 15:56:56 -07002350 def checkFlowCount(self, min=0, timeout=60 ):
Flavio Castroa1286fe2016-07-25 14:48:51 -07002351 count = self.getTotalFlowsNum( timeout=timeout )
2352 count = int (count) if count else 0
Flavio Castrod2ffffa2016-04-26 15:56:56 -07002353 return count if (count > min) else False
GlennRCed771242016-01-13 17:02:47 -08002354
YPZhangebf9eb52016-05-12 15:20:24 -07002355 def checkFlowsState( self, isPENDING=True, timeout=60,noExit=False ):
kelvin-onlab4df89f22015-04-13 18:10:23 -07002356 """
2357 Description:
GlennRCed771242016-01-13 17:02:47 -08002358 Check the if all the current flows are in ADDED state
Jon Hallc6793552016-01-19 14:18:37 -08002359 We check PENDING_ADD, PENDING_REMOVE, REMOVED, and FAILED flows,
2360 if the count of those states is 0, which means all current flows
2361 are in ADDED state, and return main.TRUE otherwise return main.FALSE
pingping-linbab7f8a2015-09-21 17:33:36 -07002362 Optional:
GlennRCed771242016-01-13 17:02:47 -08002363 * isPENDING: whether the PENDING_ADD is also a correct status
kelvin-onlab4df89f22015-04-13 18:10:23 -07002364 Return:
2365 returnValue - Returns main.TRUE only if all flows are in
Jon Hallc6793552016-01-19 14:18:37 -08002366 ADDED state or PENDING_ADD if the isPENDING
pingping-linbab7f8a2015-09-21 17:33:36 -07002367 parameter is set true, return main.FALSE otherwise.
kelvin-onlab4df89f22015-04-13 18:10:23 -07002368 """
2369 try:
GlennRCed771242016-01-13 17:02:47 -08002370 states = ["PENDING_ADD", "PENDING_REMOVE", "REMOVED", "FAILED"]
2371 checkedStates = []
2372 statesCount = [0, 0, 0, 0]
2373 for s in states:
Jon Hallc6793552016-01-19 14:18:37 -08002374 rawFlows = self.flows( state=s, timeout = timeout )
YPZhang240842b2016-05-17 12:00:50 -07002375 if rawFlows:
2376 # if we didn't get flows or flows function return None, we should return
2377 # main.Flase
2378 checkedStates.append( json.loads( rawFlows ) )
2379 else:
2380 return main.FALSE
Jon Hallc6793552016-01-19 14:18:37 -08002381 for i in range( len( states ) ):
GlennRCed771242016-01-13 17:02:47 -08002382 for c in checkedStates[i]:
Jon Hallc6793552016-01-19 14:18:37 -08002383 try:
2384 statesCount[i] += int( c.get( "flowCount" ) )
2385 except TypeError:
2386 main.log.exception( "Json object not as expected" )
2387 main.log.info( states[i] + " flows: " + str( statesCount[i] ) )
kelvin-onlabf2ec6e02015-05-27 14:15:28 -07002388
GlennRCed771242016-01-13 17:02:47 -08002389 # We want to count PENDING_ADD if isPENDING is true
2390 if isPENDING:
2391 if statesCount[1] + statesCount[2] + statesCount[3] > 0:
2392 return main.FALSE
pingping-linbab7f8a2015-09-21 17:33:36 -07002393 else:
GlennRCed771242016-01-13 17:02:47 -08002394 if statesCount[0] + statesCount[1] + statesCount[2] + statesCount[3] > 0:
2395 return main.FALSE
GlennRCed771242016-01-13 17:02:47 -08002396 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -08002397 except ( TypeError, ValueError ):
2398 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, rawFlows ) )
kelvin-onlab4df89f22015-04-13 18:10:23 -07002399 return None
Jeremy Songster9385d412016-06-02 17:57:36 -07002400
YPZhang240842b2016-05-17 12:00:50 -07002401 except AssertionError:
2402 main.log.exception( "" )
2403 return None
kelvin-onlab4df89f22015-04-13 18:10:23 -07002404 except pexpect.EOF:
2405 main.log.error( self.name + ": EOF exception found" )
2406 main.log.error( self.name + ": " + self.handle.before )
2407 main.cleanup()
2408 main.exit()
2409 except Exception:
2410 main.log.exception( self.name + ": Uncaught exception!" )
2411 main.cleanup()
2412 main.exit()
YPZhangebf9eb52016-05-12 15:20:24 -07002413 except pexpect.TIMEOUT:
2414 main.log.error( self.name + ": ONOS timeout" )
2415 return None
2416
kelvin-onlab4df89f22015-04-13 18:10:23 -07002417
GlennRCed771242016-01-13 17:02:47 -08002418 def pushTestIntents( self, ingress, egress, batchSize, offset="",
YPZhangb34b7e12016-06-14 14:28:19 -07002419 options="", timeout=10, background = False, noExit=False, getResponse=False ):
kelvin8ec71442015-01-15 16:57:00 -08002420 """
andrewonlab87852b02014-11-19 18:44:19 -05002421 Description:
Jon Halle3f39ff2015-01-13 11:50:53 -08002422 Push a number of intents in a batch format to
andrewonlab87852b02014-11-19 18:44:19 -05002423 a specific point-to-point intent definition
2424 Required:
GlennRCed771242016-01-13 17:02:47 -08002425 * ingress: specify source dpid
2426 * egress: specify destination dpid
2427 * batchSize: specify number of intents to push
andrewonlab87852b02014-11-19 18:44:19 -05002428 Optional:
GlennRCed771242016-01-13 17:02:47 -08002429 * offset: the keyOffset is where the next batch of intents
2430 will be installed
YPZhangb34b7e12016-06-14 14:28:19 -07002431 * noExit: If set to True, TestON will not exit if any error when issus command
2432 * getResponse: If set to True, function will return ONOS response.
2433
GlennRCed771242016-01-13 17:02:47 -08002434 Returns: If failed to push test intents, it will returen None,
2435 if successful, return true.
2436 Timeout expection will return None,
2437 TypeError will return false
2438 other expections will exit()
kelvin8ec71442015-01-15 16:57:00 -08002439 """
andrewonlab87852b02014-11-19 18:44:19 -05002440 try:
GlennRCed771242016-01-13 17:02:47 -08002441 if background:
2442 back = "&"
andrewonlab87852b02014-11-19 18:44:19 -05002443 else:
GlennRCed771242016-01-13 17:02:47 -08002444 back = ""
2445 cmd = "push-test-intents {} {} {} {} {} {}".format( options,
Jon Hallc6793552016-01-19 14:18:37 -08002446 ingress,
2447 egress,
2448 batchSize,
2449 offset,
2450 back )
YPZhangebf9eb52016-05-12 15:20:24 -07002451 response = self.sendline( cmd, timeout=timeout, noExit=noExit )
Jon Hallc6793552016-01-19 14:18:37 -08002452 assert "Command not found:" not in response, response
GlennRCed771242016-01-13 17:02:47 -08002453 main.log.info( response )
2454 if response == None:
2455 return None
2456
YPZhangb34b7e12016-06-14 14:28:19 -07002457 if getResponse:
2458 return response
2459
GlennRCed771242016-01-13 17:02:47 -08002460 # TODO: We should handle if there is failure in installation
2461 return main.TRUE
2462
Jon Hallc6793552016-01-19 14:18:37 -08002463 except AssertionError:
2464 main.log.exception( "" )
2465 return None
GlennRCed771242016-01-13 17:02:47 -08002466 except pexpect.TIMEOUT:
2467 main.log.error( self.name + ": ONOS timeout" )
Jon Halld4d4b372015-01-28 16:02:41 -08002468 return None
andrewonlab87852b02014-11-19 18:44:19 -05002469 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002470 main.log.error( self.name + ": EOF exception found" )
2471 main.log.error( self.name + ": " + self.handle.before )
andrewonlab87852b02014-11-19 18:44:19 -05002472 main.cleanup()
2473 main.exit()
GlennRCed771242016-01-13 17:02:47 -08002474 except TypeError:
2475 main.log.exception( self.name + ": Object not as expected" )
Jon Hallc6793552016-01-19 14:18:37 -08002476 return None
Jon Hallfebb1c72015-03-05 13:30:09 -08002477 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002478 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab87852b02014-11-19 18:44:19 -05002479 main.cleanup()
2480 main.exit()
2481
YPZhangebf9eb52016-05-12 15:20:24 -07002482 def getTotalFlowsNum( self, timeout=60, noExit=False ):
YPZhangb5d3f832016-01-23 22:54:26 -08002483 """
2484 Description:
YPZhangf6f14a02016-01-28 15:17:31 -08002485 Get the number of ADDED flows.
YPZhangb5d3f832016-01-23 22:54:26 -08002486 Return:
YPZhangf6f14a02016-01-28 15:17:31 -08002487 The number of ADDED flows
YPZhang14a4aa92016-07-15 13:37:15 -07002488 Or return None if any exceptions
YPZhangb5d3f832016-01-23 22:54:26 -08002489 """
YPZhange3109a72016-02-02 11:25:37 -08002490
YPZhangb5d3f832016-01-23 22:54:26 -08002491 try:
YPZhange3109a72016-02-02 11:25:37 -08002492 # get total added flows number
YPZhang14a4aa92016-07-15 13:37:15 -07002493 cmd = "flows -c added"
2494 rawFlows = self.sendline( cmd, timeout=timeout, noExit=noExit )
2495 if rawFlows:
2496 rawFlows = rawFlows.split("\n")
YPZhange3109a72016-02-02 11:25:37 -08002497 totalFlows = 0
YPZhang14a4aa92016-07-15 13:37:15 -07002498 for l in rawFlows:
2499 totalFlows += int(l.split("Count=")[1])
2500 else:
2501 main.log.error("Response not as expected!")
2502 return None
2503 return totalFlows
YPZhange3109a72016-02-02 11:25:37 -08002504
You Wangd3cb2ce2016-05-16 14:01:24 -07002505 except ( TypeError, ValueError ):
YPZhang14a4aa92016-07-15 13:37:15 -07002506 main.log.exception( "{}: Object not as expected!".format( self.name ) )
YPZhangb5d3f832016-01-23 22:54:26 -08002507 return None
2508 except pexpect.EOF:
2509 main.log.error( self.name + ": EOF exception found" )
2510 main.log.error( self.name + ": " + self.handle.before )
YPZhang14a4aa92016-07-15 13:37:15 -07002511 if not noExit:
2512 main.cleanup()
2513 main.exit()
2514 return None
YPZhangb5d3f832016-01-23 22:54:26 -08002515 except Exception:
2516 main.log.exception( self.name + ": Uncaught exception!" )
YPZhang14a4aa92016-07-15 13:37:15 -07002517 if not noExit:
2518 main.cleanup()
2519 main.exit()
2520 return None
YPZhangebf9eb52016-05-12 15:20:24 -07002521 except pexpect.TIMEOUT:
2522 main.log.error( self.name + ": ONOS timeout" )
2523 return None
YPZhangb5d3f832016-01-23 22:54:26 -08002524
YPZhang14a4aa92016-07-15 13:37:15 -07002525 def getTotalIntentsNum( self, timeout=60, noExit = False ):
YPZhangb5d3f832016-01-23 22:54:26 -08002526 """
2527 Description:
2528 Get the total number of intents, include every states.
YPZhang14a4aa92016-07-15 13:37:15 -07002529 Optional:
2530 noExit - If noExit, TestON will not exit if any except.
YPZhangb5d3f832016-01-23 22:54:26 -08002531 Return:
2532 The number of intents
2533 """
2534 try:
2535 cmd = "summary -j"
YPZhang14a4aa92016-07-15 13:37:15 -07002536 response = self.sendline( cmd, timeout=timeout, noExit=noExit )
YPZhangb5d3f832016-01-23 22:54:26 -08002537 if response == None:
2538 return -1
2539 response = json.loads( response )
2540 return int( response.get("intents") )
You Wangd3cb2ce2016-05-16 14:01:24 -07002541 except ( TypeError, ValueError ):
2542 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, response ) )
YPZhangb5d3f832016-01-23 22:54:26 -08002543 return None
2544 except pexpect.EOF:
2545 main.log.error( self.name + ": EOF exception found" )
2546 main.log.error( self.name + ": " + self.handle.before )
YPZhang14a4aa92016-07-15 13:37:15 -07002547 if noExit:
2548 return -1
2549 else:
2550 main.cleanup()
2551 main.exit()
YPZhangb5d3f832016-01-23 22:54:26 -08002552 except Exception:
2553 main.log.exception( self.name + ": Uncaught exception!" )
YPZhang14a4aa92016-07-15 13:37:15 -07002554 if noExit:
2555 return -1
2556 else:
2557 main.cleanup()
2558 main.exit()
YPZhangb5d3f832016-01-23 22:54:26 -08002559
kelvin-onlabd3b64892015-01-20 13:26:24 -08002560 def intentsEventsMetrics( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -08002561 """
Jon Halle3f39ff2015-01-13 11:50:53 -08002562 Description:Returns topology metrics
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002563 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002564 * jsonFormat: enable json formatting of output
kelvin8ec71442015-01-15 16:57:00 -08002565 """
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002566 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002567 cmdStr = "intents-events-metrics"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002568 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002569 cmdStr += " -j"
2570 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002571 assert "Command not found:" not in handle, handle
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002572 return handle
Jon Hallc6793552016-01-19 14:18:37 -08002573 except AssertionError:
2574 main.log.exception( "" )
2575 return None
Jon Halld4d4b372015-01-28 16:02:41 -08002576 except TypeError:
2577 main.log.exception( self.name + ": Object not as expected" )
2578 return None
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002579 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002580 main.log.error( self.name + ": EOF exception found" )
2581 main.log.error( self.name + ": " + self.handle.before )
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002582 main.cleanup()
2583 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002584 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002585 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002586 main.cleanup()
2587 main.exit()
Shreya Shah0f01c812014-10-26 20:15:28 -04002588
kelvin-onlabd3b64892015-01-20 13:26:24 -08002589 def topologyEventsMetrics( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -08002590 """
2591 Description:Returns topology metrics
andrewonlab867212a2014-10-22 20:13:38 -04002592 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002593 * jsonFormat: enable json formatting of output
kelvin8ec71442015-01-15 16:57:00 -08002594 """
andrewonlab867212a2014-10-22 20:13:38 -04002595 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002596 cmdStr = "topology-events-metrics"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002597 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002598 cmdStr += " -j"
2599 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002600 assert "Command not found:" not in handle, handle
jenkins7ead5a82015-03-13 10:28:21 -07002601 if handle:
2602 return handle
Jon Hallc6358dd2015-04-10 12:44:28 -07002603 elif jsonFormat:
Jon Hallbe379602015-03-24 13:39:32 -07002604 # Return empty json
jenkins7ead5a82015-03-13 10:28:21 -07002605 return '{}'
Jon Hallc6358dd2015-04-10 12:44:28 -07002606 else:
2607 return handle
Jon Hallc6793552016-01-19 14:18:37 -08002608 except AssertionError:
2609 main.log.exception( "" )
2610 return None
Jon Halld4d4b372015-01-28 16:02:41 -08002611 except TypeError:
2612 main.log.exception( self.name + ": Object not as expected" )
2613 return None
andrewonlab867212a2014-10-22 20:13:38 -04002614 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002615 main.log.error( self.name + ": EOF exception found" )
2616 main.log.error( self.name + ": " + self.handle.before )
andrewonlab867212a2014-10-22 20:13:38 -04002617 main.cleanup()
2618 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002619 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002620 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab867212a2014-10-22 20:13:38 -04002621 main.cleanup()
2622 main.exit()
2623
kelvin8ec71442015-01-15 16:57:00 -08002624 # Wrapper functions ****************
2625 # Wrapper functions use existing driver
2626 # functions and extends their use case.
2627 # For example, we may use the output of
2628 # a normal driver function, and parse it
2629 # using a wrapper function
andrewonlabc2d05aa2014-10-13 16:51:10 -04002630
kelvin-onlabd3b64892015-01-20 13:26:24 -08002631 def getAllIntentsId( self ):
kelvin8ec71442015-01-15 16:57:00 -08002632 """
andrewonlab9a50dfe2014-10-17 17:22:31 -04002633 Description:
2634 Obtain all intent id's in a list
kelvin8ec71442015-01-15 16:57:00 -08002635 """
andrewonlab9a50dfe2014-10-17 17:22:31 -04002636 try:
kelvin8ec71442015-01-15 16:57:00 -08002637 # Obtain output of intents function
kelvin-onlabfb521662015-02-27 09:52:40 -08002638 intentsStr = self.intents(jsonFormat=False)
kelvin-onlabd3b64892015-01-20 13:26:24 -08002639 intentIdList = []
andrewonlab9a50dfe2014-10-17 17:22:31 -04002640
kelvin8ec71442015-01-15 16:57:00 -08002641 # Parse the intents output for ID's
kelvin-onlabd3b64892015-01-20 13:26:24 -08002642 intentsList = [ s.strip() for s in intentsStr.splitlines() ]
2643 for intents in intentsList:
kelvin-onlabfb521662015-02-27 09:52:40 -08002644 match = re.search('id=0x([\da-f]+),', intents)
2645 if match:
2646 tmpId = match.group()[3:-1]
2647 intentIdList.append( tmpId )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002648 return intentIdList
andrewonlab9a50dfe2014-10-17 17:22:31 -04002649
Jon Halld4d4b372015-01-28 16:02:41 -08002650 except TypeError:
2651 main.log.exception( self.name + ": Object not as expected" )
2652 return None
andrewonlab9a50dfe2014-10-17 17:22:31 -04002653 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002654 main.log.error( self.name + ": EOF exception found" )
2655 main.log.error( self.name + ": " + self.handle.before )
andrewonlab9a50dfe2014-10-17 17:22:31 -04002656 main.cleanup()
2657 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002658 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002659 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab9a50dfe2014-10-17 17:22:31 -04002660 main.cleanup()
2661 main.exit()
2662
Jon Hall30b82fa2015-03-04 17:15:43 -08002663 def FlowAddedCount( self, deviceId ):
2664 """
2665 Determine the number of flow rules for the given device id that are
2666 in the added state
2667 """
2668 try:
2669 cmdStr = "flows any " + str( deviceId ) + " | " +\
2670 "grep 'state=ADDED' | wc -l"
2671 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002672 assert "Command not found:" not in handle, handle
Jon Hall30b82fa2015-03-04 17:15:43 -08002673 return handle
Jon Hallc6793552016-01-19 14:18:37 -08002674 except AssertionError:
2675 main.log.exception( "" )
2676 return None
Jon Hall30b82fa2015-03-04 17:15:43 -08002677 except pexpect.EOF:
2678 main.log.error( self.name + ": EOF exception found" )
2679 main.log.error( self.name + ": " + self.handle.before )
2680 main.cleanup()
2681 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002682 except Exception:
Jon Hall30b82fa2015-03-04 17:15:43 -08002683 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ce8322014-10-13 14:12:04 -04002684 main.cleanup()
2685 main.exit()
2686
kelvin-onlabd3b64892015-01-20 13:26:24 -08002687 def getAllDevicesId( self ):
kelvin8ec71442015-01-15 16:57:00 -08002688 """
andrewonlab7e4d2d32014-10-15 13:23:21 -04002689 Use 'devices' function to obtain list of all devices
2690 and parse the result to obtain a list of all device
2691 id's. Returns this list. Returns empty list if no
2692 devices exist
kelvin8ec71442015-01-15 16:57:00 -08002693 List is ordered sequentially
2694
andrewonlab3e15ead2014-10-15 14:21:34 -04002695 This function may be useful if you are not sure of the
kelvin8ec71442015-01-15 16:57:00 -08002696 device id, and wish to execute other commands using
andrewonlab3e15ead2014-10-15 14:21:34 -04002697 the ids. By obtaining the list of device ids on the fly,
2698 you can iterate through the list to get mastership, etc.
kelvin8ec71442015-01-15 16:57:00 -08002699 """
andrewonlab7e4d2d32014-10-15 13:23:21 -04002700 try:
kelvin8ec71442015-01-15 16:57:00 -08002701 # Call devices and store result string
kelvin-onlabd3b64892015-01-20 13:26:24 -08002702 devicesStr = self.devices( jsonFormat=False )
2703 idList = []
kelvin8ec71442015-01-15 16:57:00 -08002704
kelvin-onlabd3b64892015-01-20 13:26:24 -08002705 if not devicesStr:
kelvin8ec71442015-01-15 16:57:00 -08002706 main.log.info( "There are no devices to get id from" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002707 return idList
kelvin8ec71442015-01-15 16:57:00 -08002708
2709 # Split the string into list by comma
kelvin-onlabd3b64892015-01-20 13:26:24 -08002710 deviceList = devicesStr.split( "," )
kelvin8ec71442015-01-15 16:57:00 -08002711 # Get temporary list of all arguments with string 'id='
kelvin-onlabd3b64892015-01-20 13:26:24 -08002712 tempList = [ dev for dev in deviceList if "id=" in dev ]
kelvin8ec71442015-01-15 16:57:00 -08002713 # Split list further into arguments before and after string
2714 # 'id='. Get the latter portion ( the actual device id ) and
kelvin-onlabd3b64892015-01-20 13:26:24 -08002715 # append to idList
2716 for arg in tempList:
2717 idList.append( arg.split( "id=" )[ 1 ] )
2718 return idList
andrewonlab7e4d2d32014-10-15 13:23:21 -04002719
Jon Halld4d4b372015-01-28 16:02:41 -08002720 except TypeError:
2721 main.log.exception( self.name + ": Object not as expected" )
2722 return None
andrewonlab7e4d2d32014-10-15 13:23:21 -04002723 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002724 main.log.error( self.name + ": EOF exception found" )
2725 main.log.error( self.name + ": " + self.handle.before )
andrewonlab7e4d2d32014-10-15 13:23:21 -04002726 main.cleanup()
2727 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002728 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002729 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab7e4d2d32014-10-15 13:23:21 -04002730 main.cleanup()
2731 main.exit()
2732
kelvin-onlabd3b64892015-01-20 13:26:24 -08002733 def getAllNodesId( self ):
kelvin8ec71442015-01-15 16:57:00 -08002734 """
andrewonlab7c211572014-10-15 16:45:20 -04002735 Uses 'nodes' function to obtain list of all nodes
2736 and parse the result of nodes to obtain just the
kelvin8ec71442015-01-15 16:57:00 -08002737 node id's.
andrewonlab7c211572014-10-15 16:45:20 -04002738 Returns:
2739 list of node id's
kelvin8ec71442015-01-15 16:57:00 -08002740 """
andrewonlab7c211572014-10-15 16:45:20 -04002741 try:
Jon Hall5aa168b2015-03-23 14:23:09 -07002742 nodesStr = self.nodes( jsonFormat=True )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002743 idList = []
Jon Hall5aa168b2015-03-23 14:23:09 -07002744 # Sample nodesStr output
Jon Hallbd182782016-03-28 16:42:22 -07002745 # id=local, address=127.0.0.1:9876, state=READY *
kelvin-onlabd3b64892015-01-20 13:26:24 -08002746 if not nodesStr:
kelvin8ec71442015-01-15 16:57:00 -08002747 main.log.info( "There are no nodes to get id from" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002748 return idList
Jon Hall5aa168b2015-03-23 14:23:09 -07002749 nodesJson = json.loads( nodesStr )
2750 idList = [ node.get('id') for node in nodesJson ]
kelvin-onlabd3b64892015-01-20 13:26:24 -08002751 return idList
Jon Hallc6793552016-01-19 14:18:37 -08002752 except ( TypeError, ValueError ):
2753 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, nodesStr ) )
Jon Halld4d4b372015-01-28 16:02:41 -08002754 return None
andrewonlab7c211572014-10-15 16:45:20 -04002755 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002756 main.log.error( self.name + ": EOF exception found" )
2757 main.log.error( self.name + ": " + self.handle.before )
andrewonlab7c211572014-10-15 16:45:20 -04002758 main.cleanup()
2759 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002760 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002761 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab7c211572014-10-15 16:45:20 -04002762 main.cleanup()
2763 main.exit()
andrewonlab7e4d2d32014-10-15 13:23:21 -04002764
kelvin-onlabd3b64892015-01-20 13:26:24 -08002765 def getDevice( self, dpid=None ):
kelvin8ec71442015-01-15 16:57:00 -08002766 """
Jon Halla91c4dc2014-10-22 12:57:04 -04002767 Return the first device from the devices api whose 'id' contains 'dpid'
2768 Return None if there is no match
kelvin8ec71442015-01-15 16:57:00 -08002769 """
Jon Halla91c4dc2014-10-22 12:57:04 -04002770 try:
kelvin8ec71442015-01-15 16:57:00 -08002771 if dpid is None:
Jon Halla91c4dc2014-10-22 12:57:04 -04002772 return None
2773 else:
kelvin8ec71442015-01-15 16:57:00 -08002774 dpid = dpid.replace( ':', '' )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002775 rawDevices = self.devices()
2776 devicesJson = json.loads( rawDevices )
kelvin8ec71442015-01-15 16:57:00 -08002777 # search json for the device with dpid then return the device
kelvin-onlabd3b64892015-01-20 13:26:24 -08002778 for device in devicesJson:
kelvin8ec71442015-01-15 16:57:00 -08002779 # print "%s in %s?" % ( dpid, device[ 'id' ] )
2780 if dpid in device[ 'id' ]:
Jon Halla91c4dc2014-10-22 12:57:04 -04002781 return device
2782 return None
Jon Hallc6793552016-01-19 14:18:37 -08002783 except ( TypeError, ValueError ):
2784 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, rawDevices ) )
Jon Halld4d4b372015-01-28 16:02:41 -08002785 return None
Jon Halla91c4dc2014-10-22 12:57:04 -04002786 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002787 main.log.error( self.name + ": EOF exception found" )
2788 main.log.error( self.name + ": " + self.handle.before )
Jon Halla91c4dc2014-10-22 12:57:04 -04002789 main.cleanup()
2790 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002791 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002792 main.log.exception( self.name + ": Uncaught exception!" )
Jon Halla91c4dc2014-10-22 12:57:04 -04002793 main.cleanup()
2794 main.exit()
2795
You Wang24139872016-05-03 11:48:47 -07002796 def getTopology( self, topologyOutput ):
2797 """
2798 Definition:
2799 Loads a json topology output
2800 Return:
2801 topology = current ONOS topology
2802 """
2803 import json
2804 try:
2805 # either onos:topology or 'topology' will work in CLI
2806 topology = json.loads(topologyOutput)
Jeremy Songsterbc2d8ac2016-05-04 11:25:42 -07002807 main.log.debug( topology )
You Wang24139872016-05-03 11:48:47 -07002808 return topology
You Wangd3cb2ce2016-05-16 14:01:24 -07002809 except ( TypeError, ValueError ):
2810 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, topologyOutput ) )
2811 return None
You Wang24139872016-05-03 11:48:47 -07002812 except pexpect.EOF:
2813 main.log.error( self.name + ": EOF exception found" )
2814 main.log.error( self.name + ": " + self.handle.before )
2815 main.cleanup()
2816 main.exit()
2817 except Exception:
2818 main.log.exception( self.name + ": Uncaught exception!" )
2819 main.cleanup()
2820 main.exit()
2821
Flavio Castro82ee2f62016-06-07 15:04:12 -07002822 def checkStatus(self, numoswitch, numolink, numoctrl = -1, logLevel="info"):
kelvin8ec71442015-01-15 16:57:00 -08002823 """
Jon Hallefbd9792015-03-05 16:11:36 -08002824 Checks the number of switches & links that ONOS sees against the
kelvin8ec71442015-01-15 16:57:00 -08002825 supplied values. By default this will report to main.log, but the
You Wang24139872016-05-03 11:48:47 -07002826 log level can be specific.
kelvin8ec71442015-01-15 16:57:00 -08002827
Flavio Castro82ee2f62016-06-07 15:04:12 -07002828 Params: numoswitch = expected number of switches
Jon Hallefbd9792015-03-05 16:11:36 -08002829 numolink = expected number of links
Flavio Castro82ee2f62016-06-07 15:04:12 -07002830 numoctrl = expected number of controllers
You Wang24139872016-05-03 11:48:47 -07002831 logLevel = level to log to.
2832 Currently accepts 'info', 'warn' and 'report'
Jon Hall42db6dc2014-10-24 19:03:48 -04002833
Jon Hallefbd9792015-03-05 16:11:36 -08002834 Returns: main.TRUE if the number of switches and links are correct,
2835 main.FALSE if the number of switches and links is incorrect,
Jon Hall42db6dc2014-10-24 19:03:48 -04002836 and main.ERROR otherwise
kelvin8ec71442015-01-15 16:57:00 -08002837 """
Flavio Castro82ee2f62016-06-07 15:04:12 -07002838 import json
Jon Hall42db6dc2014-10-24 19:03:48 -04002839 try:
You Wang13310252016-07-31 10:56:14 -07002840 summary = self.summary()
2841 summary = json.loads( summary )
Flavio Castrof5b3f872016-06-23 17:52:31 -07002842 except ( TypeError, ValueError ):
2843 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, summary ) )
2844 return main.ERROR
2845 try:
2846 topology = self.getTopology( self.topology() )
Flavio Castro82ee2f62016-06-07 15:04:12 -07002847 if topology == {} or topology == None or summary == {} or summary == None:
Jon Hall42db6dc2014-10-24 19:03:48 -04002848 return main.ERROR
2849 output = ""
kelvin8ec71442015-01-15 16:57:00 -08002850 # Is the number of switches is what we expected
2851 devices = topology.get( 'devices', False )
2852 links = topology.get( 'links', False )
Flavio Castro82ee2f62016-06-07 15:04:12 -07002853 nodes = summary.get( 'nodes', False )
2854 if devices is False or links is False or nodes is False:
Jon Hall42db6dc2014-10-24 19:03:48 -04002855 return main.ERROR
kelvin-onlabd3b64892015-01-20 13:26:24 -08002856 switchCheck = ( int( devices ) == int( numoswitch ) )
kelvin8ec71442015-01-15 16:57:00 -08002857 # Is the number of links is what we expected
kelvin-onlabd3b64892015-01-20 13:26:24 -08002858 linkCheck = ( int( links ) == int( numolink ) )
Flavio Castro82ee2f62016-06-07 15:04:12 -07002859 nodeCheck = ( int( nodes ) == int( numoctrl ) ) or int( numoctrl ) == -1
2860 if switchCheck and linkCheck and nodeCheck:
kelvin8ec71442015-01-15 16:57:00 -08002861 # We expected the correct numbers
You Wang24139872016-05-03 11:48:47 -07002862 output = output + "The number of links and switches match "\
2863 + "what was expected"
Jon Hall42db6dc2014-10-24 19:03:48 -04002864 result = main.TRUE
2865 else:
You Wang24139872016-05-03 11:48:47 -07002866 output = output + \
2867 "The number of links and switches does not match " + \
2868 "what was expected"
Jon Hall42db6dc2014-10-24 19:03:48 -04002869 result = main.FALSE
You Wang24139872016-05-03 11:48:47 -07002870 output = output + "\n ONOS sees %i devices" % int( devices )
2871 output = output + " (%i expected) " % int( numoswitch )
2872 output = output + "and %i links " % int( links )
2873 output = output + "(%i expected)" % int( numolink )
YPZhangd7e4b6e2016-06-17 16:07:55 -07002874 if int( numoctrl ) > 0:
Flavio Castro82ee2f62016-06-07 15:04:12 -07002875 output = output + "and %i controllers " % int( nodes )
2876 output = output + "(%i expected)" % int( numoctrl )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002877 if logLevel == "report":
kelvin8ec71442015-01-15 16:57:00 -08002878 main.log.report( output )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002879 elif logLevel == "warn":
kelvin8ec71442015-01-15 16:57:00 -08002880 main.log.warn( output )
Jon Hall42db6dc2014-10-24 19:03:48 -04002881 else:
You Wang24139872016-05-03 11:48:47 -07002882 main.log.info( output )
kelvin8ec71442015-01-15 16:57:00 -08002883 return result
Jon Hall42db6dc2014-10-24 19:03:48 -04002884 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002885 main.log.error( self.name + ": EOF exception found" )
2886 main.log.error( self.name + ": " + self.handle.before )
Jon Hall42db6dc2014-10-24 19:03:48 -04002887 main.cleanup()
2888 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002889 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002890 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall42db6dc2014-10-24 19:03:48 -04002891 main.cleanup()
2892 main.exit()
Jon Hall1c9e8732014-10-27 19:29:27 -04002893
kelvin-onlabd3b64892015-01-20 13:26:24 -08002894 def deviceRole( self, deviceId, onosNode, role="master" ):
kelvin8ec71442015-01-15 16:57:00 -08002895 """
Jon Hall1c9e8732014-10-27 19:29:27 -04002896 Calls the device-role cli command.
kelvin-onlabd3b64892015-01-20 13:26:24 -08002897 deviceId must be the id of a device as seen in the onos devices command
2898 onosNode is the ip of one of the onos nodes in the cluster
Jon Hall1c9e8732014-10-27 19:29:27 -04002899 role must be either master, standby, or none
2900
Jon Halle3f39ff2015-01-13 11:50:53 -08002901 Returns:
2902 main.TRUE or main.FALSE based on argument verification and
2903 main.ERROR if command returns and error
kelvin-onlab898a6c62015-01-16 14:13:53 -08002904 """
Jon Hall1c9e8732014-10-27 19:29:27 -04002905 try:
Jon Halle3f39ff2015-01-13 11:50:53 -08002906 if role.lower() == "master" or role.lower() == "standby" or\
Jon Hall1c9e8732014-10-27 19:29:27 -04002907 role.lower() == "none":
kelvin-onlabd3b64892015-01-20 13:26:24 -08002908 cmdStr = "device-role " +\
2909 str( deviceId ) + " " +\
2910 str( onosNode ) + " " +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08002911 str( role )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002912 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002913 assert "Command not found:" not in handle, handle
kelvin-onlab898a6c62015-01-16 14:13:53 -08002914 if re.search( "Error", handle ):
2915 # end color output to escape any colours
2916 # from the cli
kelvin8ec71442015-01-15 16:57:00 -08002917 main.log.error( self.name + ": " +
kelvin-onlab898a6c62015-01-16 14:13:53 -08002918 handle + '\033[0m' )
kelvin8ec71442015-01-15 16:57:00 -08002919 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -08002920 return main.TRUE
Jon Hall1c9e8732014-10-27 19:29:27 -04002921 else:
kelvin-onlab898a6c62015-01-16 14:13:53 -08002922 main.log.error( "Invalid 'role' given to device_role(). " +
2923 "Value was '" + str(role) + "'." )
Jon Hall1c9e8732014-10-27 19:29:27 -04002924 return main.FALSE
Jon Hallc6793552016-01-19 14:18:37 -08002925 except AssertionError:
2926 main.log.exception( "" )
2927 return None
Jon Halld4d4b372015-01-28 16:02:41 -08002928 except TypeError:
2929 main.log.exception( self.name + ": Object not as expected" )
2930 return None
Jon Hall1c9e8732014-10-27 19:29:27 -04002931 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002932 main.log.error( self.name + ": EOF exception found" )
2933 main.log.error( self.name + ": " + self.handle.before )
Jon Hall1c9e8732014-10-27 19:29:27 -04002934 main.cleanup()
2935 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002936 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002937 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall1c9e8732014-10-27 19:29:27 -04002938 main.cleanup()
2939 main.exit()
2940
kelvin-onlabd3b64892015-01-20 13:26:24 -08002941 def clusters( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -08002942 """
Jon Hall73cf9cc2014-11-20 22:28:38 -08002943 Lists all clusters
Jon Hallffb386d2014-11-21 13:43:38 -08002944 Optional argument:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002945 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -08002946 """
Jon Hall73cf9cc2014-11-20 22:28:38 -08002947 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002948 cmdStr = "clusters"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002949 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002950 cmdStr += " -j"
2951 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002952 assert "Command not found:" not in handle, handle
Jon Hallc6358dd2015-04-10 12:44:28 -07002953 return handle
Jon Hallc6793552016-01-19 14:18:37 -08002954 except AssertionError:
2955 main.log.exception( "" )
2956 return None
Jon Halld4d4b372015-01-28 16:02:41 -08002957 except TypeError:
2958 main.log.exception( self.name + ": Object not as expected" )
2959 return None
Jon Hall73cf9cc2014-11-20 22:28:38 -08002960 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002961 main.log.error( self.name + ": EOF exception found" )
2962 main.log.error( self.name + ": " + self.handle.before )
Jon Hall73cf9cc2014-11-20 22:28:38 -08002963 main.cleanup()
2964 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002965 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002966 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall73cf9cc2014-11-20 22:28:38 -08002967 main.cleanup()
2968 main.exit()
2969
kelvin-onlabd3b64892015-01-20 13:26:24 -08002970 def electionTestLeader( self ):
kelvin-onlab898a6c62015-01-16 14:13:53 -08002971 """
Jon Halle3f39ff2015-01-13 11:50:53 -08002972 CLI command to get the current leader for the Election test application
2973 NOTE: Requires installation of the onos-app-election feature
2974 Returns: Node IP of the leader if one exists
2975 None if none exists
2976 Main.FALSE on error
kelvin-onlab898a6c62015-01-16 14:13:53 -08002977 """
Jon Hall94fd0472014-12-08 11:52:42 -08002978 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002979 cmdStr = "election-test-leader"
2980 response = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002981 assert "Command not found:" not in response, response
Jon Halle3f39ff2015-01-13 11:50:53 -08002982 # Leader
2983 leaderPattern = "The\scurrent\sleader\sfor\sthe\sElection\s" +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08002984 "app\sis\s(?P<node>.+)\."
kelvin-onlabd3b64892015-01-20 13:26:24 -08002985 nodeSearch = re.search( leaderPattern, response )
2986 if nodeSearch:
2987 node = nodeSearch.group( 'node' )
Jon Halle3f39ff2015-01-13 11:50:53 -08002988 main.log.info( "Election-test-leader on " + str( self.name ) +
kelvin-onlab898a6c62015-01-16 14:13:53 -08002989 " found " + node + " as the leader" )
Jon Hall94fd0472014-12-08 11:52:42 -08002990 return node
Jon Halle3f39ff2015-01-13 11:50:53 -08002991 # no leader
2992 nullPattern = "There\sis\scurrently\sno\sleader\selected\sfor\s" +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08002993 "the\sElection\sapp"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002994 nullSearch = re.search( nullPattern, response )
2995 if nullSearch:
Jon Halle3f39ff2015-01-13 11:50:53 -08002996 main.log.info( "Election-test-leader found no leader on " +
kelvin-onlab898a6c62015-01-16 14:13:53 -08002997 self.name )
Jon Hall94fd0472014-12-08 11:52:42 -08002998 return None
kelvin-onlab898a6c62015-01-16 14:13:53 -08002999 # error
Jon Hall97cf84a2016-06-20 13:35:58 -07003000 main.log.error( "Error in electionTestLeader on " + self.name +
3001 ": " + "unexpected response" )
3002 main.log.error( repr( response ) )
3003 return main.FALSE
Jon Hallc6793552016-01-19 14:18:37 -08003004 except AssertionError:
3005 main.log.exception( "" )
3006 return None
Jon Halld4d4b372015-01-28 16:02:41 -08003007 except TypeError:
3008 main.log.exception( self.name + ": Object not as expected" )
3009 return main.FALSE
Jon Hall94fd0472014-12-08 11:52:42 -08003010 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08003011 main.log.error( self.name + ": EOF exception found" )
3012 main.log.error( self.name + ": " + self.handle.before )
Jon Hall94fd0472014-12-08 11:52:42 -08003013 main.cleanup()
3014 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003015 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08003016 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall94fd0472014-12-08 11:52:42 -08003017 main.cleanup()
3018 main.exit()
3019
kelvin-onlabd3b64892015-01-20 13:26:24 -08003020 def electionTestRun( self ):
kelvin-onlab898a6c62015-01-16 14:13:53 -08003021 """
Jon Halle3f39ff2015-01-13 11:50:53 -08003022 CLI command to run for leadership of the Election test application.
3023 NOTE: Requires installation of the onos-app-election feature
3024 Returns: Main.TRUE on success
3025 Main.FALSE on error
kelvin-onlab898a6c62015-01-16 14:13:53 -08003026 """
Jon Hall94fd0472014-12-08 11:52:42 -08003027 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08003028 cmdStr = "election-test-run"
3029 response = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08003030 assert "Command not found:" not in response, response
kelvin-onlab898a6c62015-01-16 14:13:53 -08003031 # success
Jon Halle3f39ff2015-01-13 11:50:53 -08003032 successPattern = "Entering\sleadership\selections\sfor\sthe\s" +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08003033 "Election\sapp."
Jon Halle3f39ff2015-01-13 11:50:53 -08003034 search = re.search( successPattern, response )
Jon Hall94fd0472014-12-08 11:52:42 -08003035 if search:
Jon Halle3f39ff2015-01-13 11:50:53 -08003036 main.log.info( self.name + " entering leadership elections " +
kelvin-onlab898a6c62015-01-16 14:13:53 -08003037 "for the Election app." )
Jon Hall94fd0472014-12-08 11:52:42 -08003038 return main.TRUE
kelvin-onlab898a6c62015-01-16 14:13:53 -08003039 # error
Jon Hall97cf84a2016-06-20 13:35:58 -07003040 main.log.error( "Error in electionTestRun on " + self.name +
3041 ": " + "unexpected response" )
3042 main.log.error( repr( response ) )
3043 return main.FALSE
Jon Hallc6793552016-01-19 14:18:37 -08003044 except AssertionError:
3045 main.log.exception( "" )
3046 return None
Jon Halld4d4b372015-01-28 16:02:41 -08003047 except TypeError:
3048 main.log.exception( self.name + ": Object not as expected" )
3049 return main.FALSE
Jon Hall94fd0472014-12-08 11:52:42 -08003050 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08003051 main.log.error( self.name + ": EOF exception found" )
3052 main.log.error( self.name + ": " + self.handle.before )
Jon Hall94fd0472014-12-08 11:52:42 -08003053 main.cleanup()
3054 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003055 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08003056 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall94fd0472014-12-08 11:52:42 -08003057 main.cleanup()
3058 main.exit()
3059
kelvin-onlabd3b64892015-01-20 13:26:24 -08003060 def electionTestWithdraw( self ):
kelvin8ec71442015-01-15 16:57:00 -08003061 """
Jon Hall94fd0472014-12-08 11:52:42 -08003062 * CLI command to withdraw the local node from leadership election for
3063 * the Election test application.
3064 #NOTE: Requires installation of the onos-app-election feature
3065 Returns: Main.TRUE on success
3066 Main.FALSE on error
kelvin8ec71442015-01-15 16:57:00 -08003067 """
Jon Hall94fd0472014-12-08 11:52:42 -08003068 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08003069 cmdStr = "election-test-withdraw"
3070 response = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08003071 assert "Command not found:" not in response, response
kelvin-onlab898a6c62015-01-16 14:13:53 -08003072 # success
Jon Halle3f39ff2015-01-13 11:50:53 -08003073 successPattern = "Withdrawing\sfrom\sleadership\selections\sfor" +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08003074 "\sthe\sElection\sapp."
Jon Halle3f39ff2015-01-13 11:50:53 -08003075 if re.search( successPattern, response ):
3076 main.log.info( self.name + " withdrawing from leadership " +
kelvin-onlab898a6c62015-01-16 14:13:53 -08003077 "elections for the Election app." )
Jon Hall94fd0472014-12-08 11:52:42 -08003078 return main.TRUE
kelvin-onlab898a6c62015-01-16 14:13:53 -08003079 # error
Jon Hall97cf84a2016-06-20 13:35:58 -07003080 main.log.error( "Error in electionTestWithdraw on " +
3081 self.name + ": " + "unexpected response" )
3082 main.log.error( repr( response ) )
3083 return main.FALSE
Jon Hallc6793552016-01-19 14:18:37 -08003084 except AssertionError:
3085 main.log.exception( "" )
3086 return None
Jon Halld4d4b372015-01-28 16:02:41 -08003087 except TypeError:
3088 main.log.exception( self.name + ": Object not as expected" )
3089 return main.FALSE
Jon Hall94fd0472014-12-08 11:52:42 -08003090 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08003091 main.log.error( self.name + ": EOF exception found" )
3092 main.log.error( self.name + ": " + self.handle.before )
Jon Hall94fd0472014-12-08 11:52:42 -08003093 main.cleanup()
3094 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003095 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08003096 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall94fd0472014-12-08 11:52:42 -08003097 main.cleanup()
3098 main.exit()
Jon Hall1c9e8732014-10-27 19:29:27 -04003099
kelvin8ec71442015-01-15 16:57:00 -08003100 def getDevicePortsEnabledCount( self, dpid ):
3101 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003102 Get the count of all enabled ports on a particular device/switch
kelvin8ec71442015-01-15 16:57:00 -08003103 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003104 try:
Jon Halle3f39ff2015-01-13 11:50:53 -08003105 dpid = str( dpid )
kelvin-onlabd3b64892015-01-20 13:26:24 -08003106 cmdStr = "onos:ports -e " + dpid + " | wc -l"
3107 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003108 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003109 assert "Command not found:" not in output, output
Jon Halle3f39ff2015-01-13 11:50:53 -08003110 if re.search( "No such device", output ):
3111 main.log.error( "Error in getting ports" )
3112 return ( output, "Error" )
Jon Halla495f562016-05-16 18:03:26 -07003113 return output
Jon Hallc6793552016-01-19 14:18:37 -08003114 except AssertionError:
3115 main.log.exception( "" )
3116 return None
Jon Halld4d4b372015-01-28 16:02:41 -08003117 except TypeError:
3118 main.log.exception( self.name + ": Object not as expected" )
3119 return ( output, "Error" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003120 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08003121 main.log.error( self.name + ": EOF exception found" )
3122 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003123 main.cleanup()
3124 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003125 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08003126 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003127 main.cleanup()
3128 main.exit()
3129
kelvin8ec71442015-01-15 16:57:00 -08003130 def getDeviceLinksActiveCount( self, dpid ):
3131 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003132 Get the count of all enabled ports on a particular device/switch
kelvin8ec71442015-01-15 16:57:00 -08003133 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003134 try:
kelvin-onlab898a6c62015-01-16 14:13:53 -08003135 dpid = str( dpid )
kelvin-onlabd3b64892015-01-20 13:26:24 -08003136 cmdStr = "onos:links " + dpid + " | grep ACTIVE | wc -l"
3137 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003138 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003139 assert "Command not found:" not in output, output
Jon Halle3f39ff2015-01-13 11:50:53 -08003140 if re.search( "No such device", output ):
kelvin-onlab898a6c62015-01-16 14:13:53 -08003141 main.log.error( "Error in getting ports " )
3142 return ( output, "Error " )
Jon Halla495f562016-05-16 18:03:26 -07003143 return output
Jon Hallc6793552016-01-19 14:18:37 -08003144 except AssertionError:
3145 main.log.exception( "" )
3146 return None
Jon Halld4d4b372015-01-28 16:02:41 -08003147 except TypeError:
3148 main.log.exception( self.name + ": Object not as expected" )
3149 return ( output, "Error " )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003150 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08003151 main.log.error( self.name + ": EOF exception found" )
3152 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003153 main.cleanup()
3154 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003155 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08003156 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003157 main.cleanup()
3158 main.exit()
3159
kelvin8ec71442015-01-15 16:57:00 -08003160 def getAllIntentIds( self ):
3161 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003162 Return a list of all Intent IDs
kelvin8ec71442015-01-15 16:57:00 -08003163 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003164 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08003165 cmdStr = "onos:intents | grep id="
3166 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003167 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003168 assert "Command not found:" not in output, output
Jon Halle3f39ff2015-01-13 11:50:53 -08003169 if re.search( "Error", output ):
3170 main.log.error( "Error in getting ports" )
3171 return ( output, "Error" )
Jon Halla495f562016-05-16 18:03:26 -07003172 return output
Jon Hallc6793552016-01-19 14:18:37 -08003173 except AssertionError:
3174 main.log.exception( "" )
3175 return None
Jon Halld4d4b372015-01-28 16:02:41 -08003176 except TypeError:
3177 main.log.exception( self.name + ": Object not as expected" )
3178 return ( output, "Error" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003179 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08003180 main.log.error( self.name + ": EOF exception found" )
3181 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003182 main.cleanup()
3183 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003184 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08003185 main.log.exception( self.name + ": Uncaught exception!" )
3186 main.cleanup()
3187 main.exit()
3188
Jon Hall73509952015-02-24 16:42:56 -08003189 def intentSummary( self ):
3190 """
Jon Hallefbd9792015-03-05 16:11:36 -08003191 Returns a dictionary containing the current intent states and the count
Jon Hall73509952015-02-24 16:42:56 -08003192 """
3193 try:
3194 intents = self.intents( )
Jon Hall08f61bc2015-04-13 16:00:30 -07003195 states = []
Jon Hall5aa168b2015-03-23 14:23:09 -07003196 for intent in json.loads( intents ):
Jon Hall08f61bc2015-04-13 16:00:30 -07003197 states.append( intent.get( 'state', None ) )
3198 out = [ ( i, states.count( i ) ) for i in set( states ) ]
Jon Hall63604932015-02-26 17:09:50 -08003199 main.log.info( dict( out ) )
Jon Hall73509952015-02-24 16:42:56 -08003200 return dict( out )
Jon Hallc6793552016-01-19 14:18:37 -08003201 except ( TypeError, ValueError ):
3202 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, intents ) )
Jon Hall73509952015-02-24 16:42:56 -08003203 return None
3204 except pexpect.EOF:
3205 main.log.error( self.name + ": EOF exception found" )
3206 main.log.error( self.name + ": " + self.handle.before )
3207 main.cleanup()
3208 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003209 except Exception:
Jon Hall73509952015-02-24 16:42:56 -08003210 main.log.exception( self.name + ": Uncaught exception!" )
3211 main.cleanup()
3212 main.exit()
Jon Hall63604932015-02-26 17:09:50 -08003213
Jon Hall61282e32015-03-19 11:34:11 -07003214 def leaders( self, jsonFormat=True ):
Jon Hall63604932015-02-26 17:09:50 -08003215 """
3216 Returns the output of the leaders command.
Jon Hall61282e32015-03-19 11:34:11 -07003217 Optional argument:
3218 * jsonFormat - boolean indicating if you want output in json
Jon Hall63604932015-02-26 17:09:50 -08003219 """
Jon Hall63604932015-02-26 17:09:50 -08003220 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07003221 cmdStr = "onos:leaders"
Jon Hall61282e32015-03-19 11:34:11 -07003222 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07003223 cmdStr += " -j"
3224 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003225 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003226 assert "Command not found:" not in output, output
Jon Hallc6358dd2015-04-10 12:44:28 -07003227 return output
Jon Hallc6793552016-01-19 14:18:37 -08003228 except AssertionError:
3229 main.log.exception( "" )
3230 return None
Jon Hall63604932015-02-26 17:09:50 -08003231 except TypeError:
3232 main.log.exception( self.name + ": Object not as expected" )
3233 return None
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003234 except pexpect.EOF:
3235 main.log.error( self.name + ": EOF exception found" )
3236 main.log.error( self.name + ": " + self.handle.before )
3237 main.cleanup()
3238 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003239 except Exception:
Jon Hall63604932015-02-26 17:09:50 -08003240 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003241 main.cleanup()
3242 main.exit()
Jon Hall63604932015-02-26 17:09:50 -08003243
acsmarsa4a4d1e2015-07-10 16:01:24 -07003244 def leaderCandidates( self, jsonFormat=True ):
3245 """
3246 Returns the output of the leaders -c command.
3247 Optional argument:
3248 * jsonFormat - boolean indicating if you want output in json
3249 """
3250 try:
3251 cmdStr = "onos:leaders -c"
3252 if jsonFormat:
3253 cmdStr += " -j"
3254 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003255 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003256 assert "Command not found:" not in output, output
acsmarsa4a4d1e2015-07-10 16:01:24 -07003257 return output
Jon Hallc6793552016-01-19 14:18:37 -08003258 except AssertionError:
3259 main.log.exception( "" )
3260 return None
acsmarsa4a4d1e2015-07-10 16:01:24 -07003261 except TypeError:
3262 main.log.exception( self.name + ": Object not as expected" )
3263 return None
3264 except pexpect.EOF:
3265 main.log.error( self.name + ": EOF exception found" )
3266 main.log.error( self.name + ": " + self.handle.before )
3267 main.cleanup()
3268 main.exit()
3269 except Exception:
3270 main.log.exception( self.name + ": Uncaught exception!" )
3271 main.cleanup()
3272 main.exit()
3273
Jon Hallc6793552016-01-19 14:18:37 -08003274 def specificLeaderCandidate( self, topic ):
acsmarsa4a4d1e2015-07-10 16:01:24 -07003275 """
3276 Returns a list in format [leader,candidate1,candidate2,...] for a given
3277 topic parameter and an empty list if the topic doesn't exist
3278 If no leader is elected leader in the returned list will be "none"
3279 Returns None if there is a type error processing the json object
3280 """
3281 try:
Jon Hall6e709752016-02-01 13:38:46 -08003282 cmdStr = "onos:leaders -j"
Jon Hallc6793552016-01-19 14:18:37 -08003283 rawOutput = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003284 assert rawOutput is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003285 assert "Command not found:" not in rawOutput, rawOutput
3286 output = json.loads( rawOutput )
acsmarsa4a4d1e2015-07-10 16:01:24 -07003287 results = []
3288 for dict in output:
3289 if dict["topic"] == topic:
3290 leader = dict["leader"]
Jon Hallc6793552016-01-19 14:18:37 -08003291 candidates = re.split( ", ", dict["candidates"][1:-1] )
3292 results.append( leader )
3293 results.extend( candidates )
acsmarsa4a4d1e2015-07-10 16:01:24 -07003294 return results
Jon Hallc6793552016-01-19 14:18:37 -08003295 except AssertionError:
3296 main.log.exception( "" )
3297 return None
3298 except ( TypeError, ValueError ):
3299 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, rawOutput ) )
acsmarsa4a4d1e2015-07-10 16:01:24 -07003300 return None
3301 except pexpect.EOF:
3302 main.log.error( self.name + ": EOF exception found" )
3303 main.log.error( self.name + ": " + self.handle.before )
3304 main.cleanup()
3305 main.exit()
3306 except Exception:
3307 main.log.exception( self.name + ": Uncaught exception!" )
3308 main.cleanup()
3309 main.exit()
3310
Jon Hall61282e32015-03-19 11:34:11 -07003311 def pendingMap( self, jsonFormat=True ):
Jon Hall63604932015-02-26 17:09:50 -08003312 """
3313 Returns the output of the intent Pending map.
3314 """
Jon Hall63604932015-02-26 17:09:50 -08003315 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07003316 cmdStr = "onos:intents -p"
Jon Hall61282e32015-03-19 11:34:11 -07003317 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07003318 cmdStr += " -j"
3319 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003320 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003321 assert "Command not found:" not in output, output
Jon Hallc6358dd2015-04-10 12:44:28 -07003322 return output
Jon Hallc6793552016-01-19 14:18:37 -08003323 except AssertionError:
3324 main.log.exception( "" )
3325 return None
Jon Hall63604932015-02-26 17:09:50 -08003326 except TypeError:
3327 main.log.exception( self.name + ": Object not as expected" )
3328 return None
3329 except pexpect.EOF:
3330 main.log.error( self.name + ": EOF exception found" )
3331 main.log.error( self.name + ": " + self.handle.before )
3332 main.cleanup()
3333 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003334 except Exception:
Jon Hall63604932015-02-26 17:09:50 -08003335 main.log.exception( self.name + ": Uncaught exception!" )
3336 main.cleanup()
3337 main.exit()
3338
Jon Hall61282e32015-03-19 11:34:11 -07003339 def partitions( self, jsonFormat=True ):
Jon Hall63604932015-02-26 17:09:50 -08003340 """
3341 Returns the output of the raft partitions command for ONOS.
3342 """
Jon Hall61282e32015-03-19 11:34:11 -07003343 # Sample JSON
3344 # {
3345 # "leader": "tcp://10.128.30.11:7238",
3346 # "members": [
3347 # "tcp://10.128.30.11:7238",
3348 # "tcp://10.128.30.17:7238",
3349 # "tcp://10.128.30.13:7238",
3350 # ],
3351 # "name": "p1",
3352 # "term": 3
3353 # },
Jon Hall63604932015-02-26 17:09:50 -08003354 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07003355 cmdStr = "onos:partitions"
Jon Hall61282e32015-03-19 11:34:11 -07003356 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07003357 cmdStr += " -j"
3358 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003359 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003360 assert "Command not found:" not in output, output
Jon Hallc6358dd2015-04-10 12:44:28 -07003361 return output
Jon Hallc6793552016-01-19 14:18:37 -08003362 except AssertionError:
3363 main.log.exception( "" )
3364 return None
Jon Hall63604932015-02-26 17:09:50 -08003365 except TypeError:
3366 main.log.exception( self.name + ": Object not as expected" )
3367 return None
3368 except pexpect.EOF:
3369 main.log.error( self.name + ": EOF exception found" )
3370 main.log.error( self.name + ": " + self.handle.before )
3371 main.cleanup()
3372 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003373 except Exception:
Jon Hall63604932015-02-26 17:09:50 -08003374 main.log.exception( self.name + ": Uncaught exception!" )
3375 main.cleanup()
3376 main.exit()
3377
Jon Hallbe379602015-03-24 13:39:32 -07003378 def apps( self, jsonFormat=True ):
3379 """
3380 Returns the output of the apps command for ONOS. This command lists
3381 information about installed ONOS applications
3382 """
3383 # Sample JSON object
3384 # [{"name":"org.onosproject.openflow","id":0,"version":"1.2.0",
3385 # "description":"ONOS OpenFlow protocol southbound providers",
3386 # "origin":"ON.Lab","permissions":"[]","featuresRepo":"",
3387 # "features":"[onos-openflow]","state":"ACTIVE"}]
3388 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07003389 cmdStr = "onos:apps"
Jon Hallbe379602015-03-24 13:39:32 -07003390 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07003391 cmdStr += " -j"
3392 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003393 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003394 assert "Command not found:" not in output, output
3395 assert "Error executing command" not in output, output
Jon Hallc6358dd2015-04-10 12:44:28 -07003396 return output
Jon Hallbe379602015-03-24 13:39:32 -07003397 # FIXME: look at specific exceptions/Errors
3398 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08003399 main.log.exception( "Error in processing onos:app command." )
Jon Hallbe379602015-03-24 13:39:32 -07003400 return None
3401 except TypeError:
3402 main.log.exception( self.name + ": Object not as expected" )
3403 return None
3404 except pexpect.EOF:
3405 main.log.error( self.name + ": EOF exception found" )
3406 main.log.error( self.name + ": " + self.handle.before )
3407 main.cleanup()
3408 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003409 except Exception:
Jon Hallbe379602015-03-24 13:39:32 -07003410 main.log.exception( self.name + ": Uncaught exception!" )
3411 main.cleanup()
3412 main.exit()
3413
Jon Hall146f1522015-03-24 15:33:24 -07003414 def appStatus( self, appName ):
3415 """
3416 Uses the onos:apps cli command to return the status of an application.
3417 Returns:
3418 "ACTIVE" - If app is installed and activated
3419 "INSTALLED" - If app is installed and deactivated
3420 "UNINSTALLED" - If app is not installed
3421 None - on error
3422 """
Jon Hall146f1522015-03-24 15:33:24 -07003423 try:
3424 if not isinstance( appName, types.StringType ):
3425 main.log.error( self.name + ".appStatus(): appName must be" +
3426 " a string" )
3427 return None
3428 output = self.apps( jsonFormat=True )
3429 appsJson = json.loads( output )
3430 state = None
3431 for app in appsJson:
3432 if appName == app.get('name'):
3433 state = app.get('state')
3434 break
3435 if state == "ACTIVE" or state == "INSTALLED":
3436 return state
3437 elif state is None:
3438 return "UNINSTALLED"
3439 elif state:
3440 main.log.error( "Unexpected state from 'onos:apps': " +
3441 str( state ) )
3442 return state
Jon Hallc6793552016-01-19 14:18:37 -08003443 except ( TypeError, ValueError ):
3444 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, output ) )
Jon Hall146f1522015-03-24 15:33:24 -07003445 return None
3446 except pexpect.EOF:
3447 main.log.error( self.name + ": EOF exception found" )
3448 main.log.error( self.name + ": " + self.handle.before )
3449 main.cleanup()
3450 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003451 except Exception:
Jon Hall146f1522015-03-24 15:33:24 -07003452 main.log.exception( self.name + ": Uncaught exception!" )
3453 main.cleanup()
3454 main.exit()
3455
Jon Hallbe379602015-03-24 13:39:32 -07003456 def app( self, appName, option ):
3457 """
3458 Interacts with the app command for ONOS. This command manages
3459 application inventory.
3460 """
Jon Hallbe379602015-03-24 13:39:32 -07003461 try:
Jon Hallbd16b922015-03-26 17:53:15 -07003462 # Validate argument types
3463 valid = True
3464 if not isinstance( appName, types.StringType ):
3465 main.log.error( self.name + ".app(): appName must be a " +
3466 "string" )
3467 valid = False
3468 if not isinstance( option, types.StringType ):
3469 main.log.error( self.name + ".app(): option must be a string" )
3470 valid = False
3471 if not valid:
3472 return main.FALSE
3473 # Validate Option
3474 option = option.lower()
3475 # NOTE: Install may become a valid option
3476 if option == "activate":
3477 pass
3478 elif option == "deactivate":
3479 pass
3480 elif option == "uninstall":
3481 pass
3482 else:
3483 # Invalid option
3484 main.log.error( "The ONOS app command argument only takes " +
3485 "the values: (activate|deactivate|uninstall)" +
3486 "; was given '" + option + "'")
3487 return main.FALSE
Jon Hall146f1522015-03-24 15:33:24 -07003488 cmdStr = "onos:app " + option + " " + appName
Jon Hallbe379602015-03-24 13:39:32 -07003489 output = self.sendline( cmdStr )
Jon Hallbe379602015-03-24 13:39:32 -07003490 if "Error executing command" in output:
3491 main.log.error( "Error in processing onos:app command: " +
3492 str( output ) )
Jon Hall146f1522015-03-24 15:33:24 -07003493 return main.FALSE
Jon Hallbe379602015-03-24 13:39:32 -07003494 elif "No such application" in output:
3495 main.log.error( "The application '" + appName +
3496 "' is not installed in ONOS" )
Jon Hall146f1522015-03-24 15:33:24 -07003497 return main.FALSE
3498 elif "Command not found:" in output:
3499 main.log.error( "Error in processing onos:app command: " +
3500 str( output ) )
3501 return main.FALSE
Jon Hallbd16b922015-03-26 17:53:15 -07003502 elif "Unsupported command:" in output:
3503 main.log.error( "Incorrect command given to 'app': " +
3504 str( output ) )
Jon Hallbe379602015-03-24 13:39:32 -07003505 # NOTE: we may need to add more checks here
Jon Hallbd16b922015-03-26 17:53:15 -07003506 # else: Command was successful
Jon Hall08f61bc2015-04-13 16:00:30 -07003507 # main.log.debug( "app response: " + repr( output ) )
Jon Hallbe379602015-03-24 13:39:32 -07003508 return main.TRUE
3509 except TypeError:
3510 main.log.exception( self.name + ": Object not as expected" )
3511 return main.ERROR
3512 except pexpect.EOF:
3513 main.log.error( self.name + ": EOF exception found" )
3514 main.log.error( self.name + ": " + self.handle.before )
3515 main.cleanup()
3516 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003517 except Exception:
Jon Hallbe379602015-03-24 13:39:32 -07003518 main.log.exception( self.name + ": Uncaught exception!" )
3519 main.cleanup()
3520 main.exit()
Jon Hall146f1522015-03-24 15:33:24 -07003521
Jon Hallbd16b922015-03-26 17:53:15 -07003522 def activateApp( self, appName, check=True ):
Jon Hall146f1522015-03-24 15:33:24 -07003523 """
3524 Activate an app that is already installed in ONOS
Jon Hallbd16b922015-03-26 17:53:15 -07003525 appName is the hierarchical app name, not the feature name
3526 If check is True, method will check the status of the app after the
3527 command is issued
Jon Hall146f1522015-03-24 15:33:24 -07003528 Returns main.TRUE if the command was successfully sent
3529 main.FALSE if the cli responded with an error or given
3530 incorrect input
3531 """
3532 try:
3533 if not isinstance( appName, types.StringType ):
3534 main.log.error( self.name + ".activateApp(): appName must be" +
3535 " a string" )
3536 return main.FALSE
3537 status = self.appStatus( appName )
3538 if status == "INSTALLED":
3539 response = self.app( appName, "activate" )
Jon Hallbd16b922015-03-26 17:53:15 -07003540 if check and response == main.TRUE:
3541 for i in range(10): # try 10 times then give up
Jon Hallbd16b922015-03-26 17:53:15 -07003542 status = self.appStatus( appName )
3543 if status == "ACTIVE":
3544 return main.TRUE
3545 else:
Jon Hall050e1bd2015-03-30 13:33:02 -07003546 main.log.debug( "The state of application " +
3547 appName + " is " + status )
Jon Hallbd16b922015-03-26 17:53:15 -07003548 time.sleep( 1 )
3549 return main.FALSE
3550 else: # not 'check' or command didn't succeed
3551 return response
Jon Hall146f1522015-03-24 15:33:24 -07003552 elif status == "ACTIVE":
3553 return main.TRUE
3554 elif status == "UNINSTALLED":
3555 main.log.error( self.name + ": Tried to activate the " +
3556 "application '" + appName + "' which is not " +
3557 "installed." )
3558 else:
3559 main.log.error( "Unexpected return value from appStatus: " +
3560 str( status ) )
3561 return main.ERROR
3562 except TypeError:
3563 main.log.exception( self.name + ": Object not as expected" )
3564 return main.ERROR
3565 except pexpect.EOF:
3566 main.log.error( self.name + ": EOF exception found" )
3567 main.log.error( self.name + ": " + self.handle.before )
3568 main.cleanup()
3569 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003570 except Exception:
Jon Hall146f1522015-03-24 15:33:24 -07003571 main.log.exception( self.name + ": Uncaught exception!" )
3572 main.cleanup()
3573 main.exit()
3574
Jon Hallbd16b922015-03-26 17:53:15 -07003575 def deactivateApp( self, appName, check=True ):
Jon Hall146f1522015-03-24 15:33:24 -07003576 """
3577 Deactivate an app that is already activated in ONOS
Jon Hallbd16b922015-03-26 17:53:15 -07003578 appName is the hierarchical app name, not the feature name
3579 If check is True, method will check the status of the app after the
3580 command is issued
Jon Hall146f1522015-03-24 15:33:24 -07003581 Returns main.TRUE if the command was successfully sent
3582 main.FALSE if the cli responded with an error or given
3583 incorrect input
3584 """
3585 try:
3586 if not isinstance( appName, types.StringType ):
3587 main.log.error( self.name + ".deactivateApp(): appName must " +
3588 "be a string" )
3589 return main.FALSE
3590 status = self.appStatus( appName )
3591 if status == "INSTALLED":
3592 return main.TRUE
3593 elif status == "ACTIVE":
3594 response = self.app( appName, "deactivate" )
Jon Hallbd16b922015-03-26 17:53:15 -07003595 if check and response == main.TRUE:
3596 for i in range(10): # try 10 times then give up
3597 status = self.appStatus( appName )
3598 if status == "INSTALLED":
3599 return main.TRUE
3600 else:
3601 time.sleep( 1 )
3602 return main.FALSE
3603 else: # not check or command didn't succeed
3604 return response
Jon Hall146f1522015-03-24 15:33:24 -07003605 elif status == "UNINSTALLED":
3606 main.log.warn( self.name + ": Tried to deactivate the " +
3607 "application '" + appName + "' which is not " +
3608 "installed." )
3609 return main.TRUE
3610 else:
3611 main.log.error( "Unexpected return value from appStatus: " +
3612 str( status ) )
3613 return main.ERROR
3614 except TypeError:
3615 main.log.exception( self.name + ": Object not as expected" )
3616 return main.ERROR
3617 except pexpect.EOF:
3618 main.log.error( self.name + ": EOF exception found" )
3619 main.log.error( self.name + ": " + self.handle.before )
3620 main.cleanup()
3621 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003622 except Exception:
Jon Hall146f1522015-03-24 15:33:24 -07003623 main.log.exception( self.name + ": Uncaught exception!" )
3624 main.cleanup()
3625 main.exit()
3626
Jon Hallbd16b922015-03-26 17:53:15 -07003627 def uninstallApp( self, appName, check=True ):
Jon Hall146f1522015-03-24 15:33:24 -07003628 """
3629 Uninstall an app that is already installed in ONOS
Jon Hallbd16b922015-03-26 17:53:15 -07003630 appName is the hierarchical app name, not the feature name
3631 If check is True, method will check the status of the app after the
3632 command is issued
Jon Hall146f1522015-03-24 15:33:24 -07003633 Returns main.TRUE if the command was successfully sent
3634 main.FALSE if the cli responded with an error or given
3635 incorrect input
3636 """
3637 # TODO: check with Thomas about the state machine for apps
3638 try:
3639 if not isinstance( appName, types.StringType ):
3640 main.log.error( self.name + ".uninstallApp(): appName must " +
3641 "be a string" )
3642 return main.FALSE
3643 status = self.appStatus( appName )
3644 if status == "INSTALLED":
3645 response = self.app( appName, "uninstall" )
Jon Hallbd16b922015-03-26 17:53:15 -07003646 if check and response == main.TRUE:
3647 for i in range(10): # try 10 times then give up
3648 status = self.appStatus( appName )
3649 if status == "UNINSTALLED":
3650 return main.TRUE
3651 else:
3652 time.sleep( 1 )
3653 return main.FALSE
3654 else: # not check or command didn't succeed
3655 return response
Jon Hall146f1522015-03-24 15:33:24 -07003656 elif status == "ACTIVE":
3657 main.log.warn( self.name + ": Tried to uninstall the " +
3658 "application '" + appName + "' which is " +
3659 "currently active." )
3660 response = self.app( appName, "uninstall" )
Jon Hallbd16b922015-03-26 17:53:15 -07003661 if check and response == main.TRUE:
3662 for i in range(10): # try 10 times then give up
3663 status = self.appStatus( appName )
3664 if status == "UNINSTALLED":
3665 return main.TRUE
3666 else:
3667 time.sleep( 1 )
3668 return main.FALSE
3669 else: # not check or command didn't succeed
3670 return response
Jon Hall146f1522015-03-24 15:33:24 -07003671 elif status == "UNINSTALLED":
3672 return main.TRUE
3673 else:
3674 main.log.error( "Unexpected return value from appStatus: " +
3675 str( status ) )
3676 return main.ERROR
3677 except TypeError:
3678 main.log.exception( self.name + ": Object not as expected" )
3679 return main.ERROR
3680 except pexpect.EOF:
3681 main.log.error( self.name + ": EOF exception found" )
3682 main.log.error( self.name + ": " + self.handle.before )
3683 main.cleanup()
3684 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003685 except Exception:
Jon Hall146f1522015-03-24 15:33:24 -07003686 main.log.exception( self.name + ": Uncaught exception!" )
3687 main.cleanup()
3688 main.exit()
Jon Hallbd16b922015-03-26 17:53:15 -07003689
3690 def appIDs( self, jsonFormat=True ):
3691 """
3692 Show the mappings between app id and app names given by the 'app-ids'
3693 cli command
3694 """
3695 try:
3696 cmdStr = "app-ids"
3697 if jsonFormat:
3698 cmdStr += " -j"
Jon Hallc6358dd2015-04-10 12:44:28 -07003699 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003700 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003701 assert "Command not found:" not in output, output
3702 assert "Error executing command" not in output, output
Jon Hallc6358dd2015-04-10 12:44:28 -07003703 return output
Jon Hallbd16b922015-03-26 17:53:15 -07003704 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08003705 main.log.exception( "Error in processing onos:app-ids command." )
Jon Hallbd16b922015-03-26 17:53:15 -07003706 return None
3707 except TypeError:
3708 main.log.exception( self.name + ": Object not as expected" )
3709 return None
3710 except pexpect.EOF:
3711 main.log.error( self.name + ": EOF exception found" )
3712 main.log.error( self.name + ": " + self.handle.before )
3713 main.cleanup()
3714 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003715 except Exception:
Jon Hallbd16b922015-03-26 17:53:15 -07003716 main.log.exception( self.name + ": Uncaught exception!" )
3717 main.cleanup()
3718 main.exit()
3719
3720 def appToIDCheck( self ):
3721 """
3722 This method will check that each application's ID listed in 'apps' is
3723 the same as the ID listed in 'app-ids'. The check will also check that
3724 there are no duplicate IDs issued. Note that an app ID should be
3725 a globaly unique numerical identifier for app/app-like features. Once
3726 an ID is registered, the ID is never freed up so that if an app is
3727 reinstalled it will have the same ID.
3728
3729 Returns: main.TRUE if the check passes and
3730 main.FALSE if the check fails or
3731 main.ERROR if there is some error in processing the test
3732 """
3733 try:
Jon Hall390696c2015-05-05 17:13:41 -07003734 bail = False
Jon Hallc6793552016-01-19 14:18:37 -08003735 rawJson = self.appIDs( jsonFormat=True )
3736 if rawJson:
3737 ids = json.loads( rawJson )
Jon Hall390696c2015-05-05 17:13:41 -07003738 else:
Jon Hallc6793552016-01-19 14:18:37 -08003739 main.log.error( "app-ids returned nothing:" + repr( rawJson ) )
Jon Hall390696c2015-05-05 17:13:41 -07003740 bail = True
Jon Hallc6793552016-01-19 14:18:37 -08003741 rawJson = self.apps( jsonFormat=True )
3742 if rawJson:
3743 apps = json.loads( rawJson )
Jon Hall390696c2015-05-05 17:13:41 -07003744 else:
Jon Hallc6793552016-01-19 14:18:37 -08003745 main.log.error( "apps returned nothing:" + repr( rawJson ) )
Jon Hall390696c2015-05-05 17:13:41 -07003746 bail = True
3747 if bail:
3748 return main.FALSE
Jon Hallbd16b922015-03-26 17:53:15 -07003749 result = main.TRUE
3750 for app in apps:
3751 appID = app.get( 'id' )
3752 if appID is None:
3753 main.log.error( "Error parsing app: " + str( app ) )
3754 result = main.FALSE
3755 appName = app.get( 'name' )
3756 if appName is None:
3757 main.log.error( "Error parsing app: " + str( app ) )
3758 result = main.FALSE
3759 # get the entry in ids that has the same appID
Jon Hall390696c2015-05-05 17:13:41 -07003760 current = filter( lambda item: item[ 'id' ] == appID, ids )
Jon Hall050e1bd2015-03-30 13:33:02 -07003761 # main.log.debug( "Comparing " + str( app ) + " to " +
3762 # str( current ) )
Jon Hallbd16b922015-03-26 17:53:15 -07003763 if not current: # if ids doesn't have this id
3764 result = main.FALSE
3765 main.log.error( "'app-ids' does not have the ID for " +
3766 str( appName ) + " that apps does." )
3767 elif len( current ) > 1:
3768 # there is more than one app with this ID
3769 result = main.FALSE
3770 # We will log this later in the method
3771 elif not current[0][ 'name' ] == appName:
3772 currentName = current[0][ 'name' ]
3773 result = main.FALSE
3774 main.log.error( "'app-ids' has " + str( currentName ) +
3775 " registered under id:" + str( appID ) +
3776 " but 'apps' has " + str( appName ) )
3777 else:
3778 pass # id and name match!
3779 # now make sure that app-ids has no duplicates
3780 idsList = []
3781 namesList = []
3782 for item in ids:
3783 idsList.append( item[ 'id' ] )
3784 namesList.append( item[ 'name' ] )
3785 if len( idsList ) != len( set( idsList ) ) or\
3786 len( namesList ) != len( set( namesList ) ):
3787 main.log.error( "'app-ids' has some duplicate entries: \n"
3788 + json.dumps( ids,
3789 sort_keys=True,
3790 indent=4,
3791 separators=( ',', ': ' ) ) )
3792 result = main.FALSE
3793 return result
Jon Hallc6793552016-01-19 14:18:37 -08003794 except ( TypeError, ValueError ):
3795 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, rawJson ) )
Jon Hallbd16b922015-03-26 17:53:15 -07003796 return main.ERROR
3797 except pexpect.EOF:
3798 main.log.error( self.name + ": EOF exception found" )
3799 main.log.error( self.name + ": " + self.handle.before )
3800 main.cleanup()
3801 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003802 except Exception:
Jon Hallbd16b922015-03-26 17:53:15 -07003803 main.log.exception( self.name + ": Uncaught exception!" )
3804 main.cleanup()
3805 main.exit()
3806
Jon Hallfb760a02015-04-13 15:35:03 -07003807 def getCfg( self, component=None, propName=None, short=False,
3808 jsonFormat=True ):
3809 """
3810 Get configuration settings from onos cli
3811 Optional arguments:
3812 component - Optionally only list configurations for a specific
3813 component. If None, all components with configurations
3814 are displayed. Case Sensitive string.
3815 propName - If component is specified, propName option will show
3816 only this specific configuration from that component.
3817 Case Sensitive string.
3818 jsonFormat - Returns output as json. Note that this will override
3819 the short option
3820 short - Short, less verbose, version of configurations.
3821 This is overridden by the json option
3822 returns:
3823 Output from cli as a string or None on error
3824 """
3825 try:
3826 baseStr = "cfg"
3827 cmdStr = " get"
3828 componentStr = ""
3829 if component:
3830 componentStr += " " + component
3831 if propName:
3832 componentStr += " " + propName
3833 if jsonFormat:
3834 baseStr += " -j"
3835 elif short:
3836 baseStr += " -s"
3837 output = self.sendline( baseStr + cmdStr + componentStr )
Jon Halla495f562016-05-16 18:03:26 -07003838 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003839 assert "Command not found:" not in output, output
3840 assert "Error executing command" not in output, output
Jon Hallfb760a02015-04-13 15:35:03 -07003841 return output
3842 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08003843 main.log.exception( "Error in processing 'cfg get' command." )
Jon Hallfb760a02015-04-13 15:35:03 -07003844 return None
3845 except TypeError:
3846 main.log.exception( self.name + ": Object not as expected" )
3847 return None
3848 except pexpect.EOF:
3849 main.log.error( self.name + ": EOF exception found" )
3850 main.log.error( self.name + ": " + self.handle.before )
3851 main.cleanup()
3852 main.exit()
3853 except Exception:
3854 main.log.exception( self.name + ": Uncaught exception!" )
3855 main.cleanup()
3856 main.exit()
3857
3858 def setCfg( self, component, propName, value=None, check=True ):
3859 """
3860 Set/Unset configuration settings from ONOS cli
Jon Hall390696c2015-05-05 17:13:41 -07003861 Required arguments:
Jon Hallfb760a02015-04-13 15:35:03 -07003862 component - The case sensitive name of the component whose
3863 property is to be set
3864 propName - The case sensitive name of the property to be set/unset
Jon Hall390696c2015-05-05 17:13:41 -07003865 Optional arguments:
Jon Hallfb760a02015-04-13 15:35:03 -07003866 value - The value to set the property to. If None, will unset the
3867 property and revert it to it's default value(if applicable)
3868 check - Boolean, Check whether the option was successfully set this
3869 only applies when a value is given.
3870 returns:
3871 main.TRUE on success or main.FALSE on failure. If check is False,
3872 will return main.TRUE unless there is an error
3873 """
3874 try:
3875 baseStr = "cfg"
3876 cmdStr = " set " + str( component ) + " " + str( propName )
3877 if value is not None:
3878 cmdStr += " " + str( value )
3879 output = self.sendline( baseStr + cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003880 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003881 assert "Command not found:" not in output, output
3882 assert "Error executing command" not in output, output
Jon Hallfb760a02015-04-13 15:35:03 -07003883 if value and check:
3884 results = self.getCfg( component=str( component ),
3885 propName=str( propName ),
3886 jsonFormat=True )
3887 # Check if current value is what we just set
3888 try:
3889 jsonOutput = json.loads( results )
3890 current = jsonOutput[ 'value' ]
Jon Hallc6793552016-01-19 14:18:37 -08003891 except ( TypeError, ValueError ):
Jon Hallfb760a02015-04-13 15:35:03 -07003892 main.log.exception( "Error parsing cfg output" )
3893 main.log.error( "output:" + repr( results ) )
3894 return main.FALSE
3895 if current == str( value ):
3896 return main.TRUE
3897 return main.FALSE
3898 return main.TRUE
3899 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08003900 main.log.exception( "Error in processing 'cfg set' command." )
Jon Hallfb760a02015-04-13 15:35:03 -07003901 return main.FALSE
Jon Hallc6793552016-01-19 14:18:37 -08003902 except ( TypeError, ValueError ):
3903 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, results ) )
Jon Hallfb760a02015-04-13 15:35:03 -07003904 return main.FALSE
3905 except pexpect.EOF:
3906 main.log.error( self.name + ": EOF exception found" )
3907 main.log.error( self.name + ": " + self.handle.before )
3908 main.cleanup()
3909 main.exit()
3910 except Exception:
3911 main.log.exception( self.name + ": Uncaught exception!" )
3912 main.cleanup()
3913 main.exit()
3914
Jon Hall390696c2015-05-05 17:13:41 -07003915 def setTestAdd( self, setName, values ):
3916 """
3917 CLI command to add elements to a distributed set.
3918 Arguments:
3919 setName - The name of the set to add to.
3920 values - The value(s) to add to the set, space seperated.
3921 Example usages:
3922 setTestAdd( "set1", "a b c" )
3923 setTestAdd( "set2", "1" )
3924 returns:
3925 main.TRUE on success OR
3926 main.FALSE if elements were already in the set OR
3927 main.ERROR on error
3928 """
3929 try:
3930 cmdStr = "set-test-add " + str( setName ) + " " + str( values )
3931 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003932 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003933 assert "Command not found:" not in output, output
Jon Hallfeff3082015-05-19 10:23:26 -07003934 try:
3935 # TODO: Maybe make this less hardcoded
3936 # ConsistentMap Exceptions
3937 assert "org.onosproject.store.service" not in output
3938 # Node not leader
3939 assert "java.lang.IllegalStateException" not in output
3940 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07003941 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07003942 "command: " + str( output ) )
3943 retryTime = 30 # Conservative time, given by Madan
3944 main.log.info( "Waiting " + str( retryTime ) +
3945 "seconds before retrying." )
3946 time.sleep( retryTime ) # Due to change in mastership
3947 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003948 assert output is not None, "Error in sendline"
Jon Hall390696c2015-05-05 17:13:41 -07003949 assert "Error executing command" not in output
3950 positiveMatch = "\[(.*)\] was added to the set " + str( setName )
3951 negativeMatch = "\[(.*)\] was already in set " + str( setName )
3952 main.log.info( self.name + ": " + output )
3953 if re.search( positiveMatch, output):
3954 return main.TRUE
3955 elif re.search( negativeMatch, output):
3956 return main.FALSE
3957 else:
3958 main.log.error( self.name + ": setTestAdd did not" +
3959 " match expected output" )
Jon Hall390696c2015-05-05 17:13:41 -07003960 main.log.debug( self.name + " actual: " + repr( output ) )
3961 return main.ERROR
3962 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08003963 main.log.exception( "Error in processing '" + cmdStr + "' command. " )
Jon Hall390696c2015-05-05 17:13:41 -07003964 return main.ERROR
3965 except TypeError:
3966 main.log.exception( self.name + ": Object not as expected" )
3967 return main.ERROR
3968 except pexpect.EOF:
3969 main.log.error( self.name + ": EOF exception found" )
3970 main.log.error( self.name + ": " + self.handle.before )
3971 main.cleanup()
3972 main.exit()
3973 except Exception:
3974 main.log.exception( self.name + ": Uncaught exception!" )
3975 main.cleanup()
3976 main.exit()
3977
3978 def setTestRemove( self, setName, values, clear=False, retain=False ):
3979 """
3980 CLI command to remove elements from a distributed set.
3981 Required arguments:
3982 setName - The name of the set to remove from.
3983 values - The value(s) to remove from the set, space seperated.
3984 Optional arguments:
3985 clear - Clear all elements from the set
3986 retain - Retain only the given values. (intersection of the
3987 original set and the given set)
3988 returns:
3989 main.TRUE on success OR
3990 main.FALSE if the set was not changed OR
3991 main.ERROR on error
3992 """
3993 try:
3994 cmdStr = "set-test-remove "
3995 if clear:
3996 cmdStr += "-c " + str( setName )
3997 elif retain:
3998 cmdStr += "-r " + str( setName ) + " " + str( values )
3999 else:
4000 cmdStr += str( setName ) + " " + str( values )
4001 output = self.sendline( cmdStr )
Jon Hallfeff3082015-05-19 10:23:26 -07004002 try:
Jon Halla495f562016-05-16 18:03:26 -07004003 assert output is not None, "Error in sendline"
Jon Hallfeff3082015-05-19 10:23:26 -07004004 # TODO: Maybe make this less hardcoded
4005 # ConsistentMap Exceptions
4006 assert "org.onosproject.store.service" not in output
4007 # Node not leader
4008 assert "java.lang.IllegalStateException" not in output
4009 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07004010 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07004011 "command: " + str( output ) )
4012 retryTime = 30 # Conservative time, given by Madan
4013 main.log.info( "Waiting " + str( retryTime ) +
4014 "seconds before retrying." )
4015 time.sleep( retryTime ) # Due to change in mastership
4016 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004017 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004018 assert "Command not found:" not in output, output
4019 assert "Error executing command" not in output, output
Jon Hall390696c2015-05-05 17:13:41 -07004020 main.log.info( self.name + ": " + output )
4021 if clear:
4022 pattern = "Set " + str( setName ) + " cleared"
4023 if re.search( pattern, output ):
4024 return main.TRUE
4025 elif retain:
4026 positivePattern = str( setName ) + " was pruned to contain " +\
4027 "only elements of set \[(.*)\]"
4028 negativePattern = str( setName ) + " was not changed by " +\
4029 "retaining only elements of the set " +\
4030 "\[(.*)\]"
4031 if re.search( positivePattern, output ):
4032 return main.TRUE
4033 elif re.search( negativePattern, output ):
4034 return main.FALSE
4035 else:
4036 positivePattern = "\[(.*)\] was removed from the set " +\
4037 str( setName )
4038 if ( len( values.split() ) == 1 ):
4039 negativePattern = "\[(.*)\] was not in set " +\
4040 str( setName )
4041 else:
4042 negativePattern = "No element of \[(.*)\] was in set " +\
4043 str( setName )
4044 if re.search( positivePattern, output ):
4045 return main.TRUE
4046 elif re.search( negativePattern, output ):
4047 return main.FALSE
4048 main.log.error( self.name + ": setTestRemove did not" +
4049 " match expected output" )
4050 main.log.debug( self.name + " expected: " + pattern )
4051 main.log.debug( self.name + " actual: " + repr( output ) )
4052 return main.ERROR
4053 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08004054 main.log.exception( "Error in processing '" + cmdStr + "' commandr. " )
Jon Hall390696c2015-05-05 17:13:41 -07004055 return main.ERROR
4056 except TypeError:
4057 main.log.exception( self.name + ": Object not as expected" )
4058 return main.ERROR
4059 except pexpect.EOF:
4060 main.log.error( self.name + ": EOF exception found" )
4061 main.log.error( self.name + ": " + self.handle.before )
4062 main.cleanup()
4063 main.exit()
4064 except Exception:
4065 main.log.exception( self.name + ": Uncaught exception!" )
4066 main.cleanup()
4067 main.exit()
4068
4069 def setTestGet( self, setName, values="" ):
4070 """
4071 CLI command to get the elements in a distributed set.
4072 Required arguments:
4073 setName - The name of the set to remove from.
4074 Optional arguments:
4075 values - The value(s) to check if in the set, space seperated.
4076 returns:
4077 main.ERROR on error OR
4078 A list of elements in the set if no optional arguments are
4079 supplied OR
4080 A tuple containing the list then:
4081 main.FALSE if the given values are not in the set OR
4082 main.TRUE if the given values are in the set OR
4083 """
4084 try:
4085 values = str( values ).strip()
4086 setName = str( setName ).strip()
4087 length = len( values.split() )
4088 containsCheck = None
4089 # Patterns to match
4090 setPattern = "\[(.*)\]"
4091 pattern = "Items in set " + setName + ":\n" + setPattern
4092 containsTrue = "Set " + setName + " contains the value " + values
4093 containsFalse = "Set " + setName + " did not contain the value " +\
4094 values
4095 containsAllTrue = "Set " + setName + " contains the the subset " +\
4096 setPattern
4097 containsAllFalse = "Set " + setName + " did not contain the the" +\
4098 " subset " + setPattern
4099
4100 cmdStr = "set-test-get "
4101 cmdStr += setName + " " + values
4102 output = self.sendline( cmdStr )
Jon Hallfeff3082015-05-19 10:23:26 -07004103 try:
Jon Halla495f562016-05-16 18:03:26 -07004104 assert output is not None, "Error in sendline"
Jon Hallfeff3082015-05-19 10:23:26 -07004105 # TODO: Maybe make this less hardcoded
4106 # ConsistentMap Exceptions
4107 assert "org.onosproject.store.service" not in output
4108 # Node not leader
4109 assert "java.lang.IllegalStateException" not in output
4110 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07004111 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07004112 "command: " + str( output ) )
4113 retryTime = 30 # Conservative time, given by Madan
4114 main.log.info( "Waiting " + str( retryTime ) +
4115 "seconds before retrying." )
4116 time.sleep( retryTime ) # Due to change in mastership
4117 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004118 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004119 assert "Command not found:" not in output, output
4120 assert "Error executing command" not in output, output
Jon Hall390696c2015-05-05 17:13:41 -07004121 main.log.info( self.name + ": " + output )
4122
4123 if length == 0:
4124 match = re.search( pattern, output )
4125 else: # if given values
4126 if length == 1: # Contains output
4127 patternTrue = pattern + "\n" + containsTrue
4128 patternFalse = pattern + "\n" + containsFalse
4129 else: # ContainsAll output
4130 patternTrue = pattern + "\n" + containsAllTrue
4131 patternFalse = pattern + "\n" + containsAllFalse
4132 matchTrue = re.search( patternTrue, output )
4133 matchFalse = re.search( patternFalse, output )
4134 if matchTrue:
4135 containsCheck = main.TRUE
4136 match = matchTrue
4137 elif matchFalse:
4138 containsCheck = main.FALSE
4139 match = matchFalse
4140 else:
4141 main.log.error( self.name + " setTestGet did not match " +\
4142 "expected output" )
4143 main.log.debug( self.name + " expected: " + pattern )
4144 main.log.debug( self.name + " actual: " + repr( output ) )
4145 match = None
4146 if match:
4147 setMatch = match.group( 1 )
4148 if setMatch == '':
4149 setList = []
4150 else:
4151 setList = setMatch.split( ", " )
4152 if length > 0:
4153 return ( setList, containsCheck )
4154 else:
4155 return setList
4156 else: # no match
4157 main.log.error( self.name + ": setTestGet did not" +
4158 " match expected output" )
4159 main.log.debug( self.name + " expected: " + pattern )
4160 main.log.debug( self.name + " actual: " + repr( output ) )
4161 return main.ERROR
4162 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08004163 main.log.exception( "Error in processing '" + cmdStr + "' command." )
Jon Hall390696c2015-05-05 17:13:41 -07004164 return main.ERROR
4165 except TypeError:
4166 main.log.exception( self.name + ": Object not as expected" )
4167 return main.ERROR
4168 except pexpect.EOF:
4169 main.log.error( self.name + ": EOF exception found" )
4170 main.log.error( self.name + ": " + self.handle.before )
4171 main.cleanup()
4172 main.exit()
4173 except Exception:
4174 main.log.exception( self.name + ": Uncaught exception!" )
4175 main.cleanup()
4176 main.exit()
4177
4178 def setTestSize( self, setName ):
4179 """
4180 CLI command to get the elements in a distributed set.
4181 Required arguments:
4182 setName - The name of the set to remove from.
4183 returns:
Jon Hallfeff3082015-05-19 10:23:26 -07004184 The integer value of the size returned or
Jon Hall390696c2015-05-05 17:13:41 -07004185 None on error
4186 """
4187 try:
4188 # TODO: Should this check against the number of elements returned
4189 # and then return true/false based on that?
4190 setName = str( setName ).strip()
4191 # Patterns to match
4192 setPattern = "\[(.*)\]"
4193 pattern = "There are (\d+) items in set " + setName + ":\n" +\
4194 setPattern
4195 cmdStr = "set-test-get -s "
4196 cmdStr += setName
4197 output = self.sendline( cmdStr )
Jon Hallfeff3082015-05-19 10:23:26 -07004198 try:
Jon Halla495f562016-05-16 18:03:26 -07004199 assert output is not None, "Error in sendline"
Jon Hallfeff3082015-05-19 10:23:26 -07004200 # TODO: Maybe make this less hardcoded
4201 # ConsistentMap Exceptions
4202 assert "org.onosproject.store.service" not in output
4203 # Node not leader
4204 assert "java.lang.IllegalStateException" not in output
4205 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07004206 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07004207 "command: " + str( output ) )
4208 retryTime = 30 # Conservative time, given by Madan
4209 main.log.info( "Waiting " + str( retryTime ) +
4210 "seconds before retrying." )
4211 time.sleep( retryTime ) # Due to change in mastership
4212 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004213 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004214 assert "Command not found:" not in output, output
4215 assert "Error executing command" not in output, output
Jon Hall390696c2015-05-05 17:13:41 -07004216 main.log.info( self.name + ": " + output )
4217 match = re.search( pattern, output )
4218 if match:
4219 setSize = int( match.group( 1 ) )
4220 setMatch = match.group( 2 )
4221 if len( setMatch.split() ) == setSize:
4222 main.log.info( "The size returned by " + self.name +
4223 " matches the number of elements in " +
4224 "the returned set" )
4225 else:
4226 main.log.error( "The size returned by " + self.name +
4227 " does not match the number of " +
4228 "elements in the returned set." )
4229 return setSize
4230 else: # no match
4231 main.log.error( self.name + ": setTestGet did not" +
4232 " match expected output" )
4233 main.log.debug( self.name + " expected: " + pattern )
4234 main.log.debug( self.name + " actual: " + repr( output ) )
4235 return None
4236 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08004237 main.log.exception( "Error in processing '" + cmdStr + "' command." )
acsmarsa4a4d1e2015-07-10 16:01:24 -07004238 return None
Jon Hall390696c2015-05-05 17:13:41 -07004239 except TypeError:
4240 main.log.exception( self.name + ": Object not as expected" )
4241 return None
4242 except pexpect.EOF:
4243 main.log.error( self.name + ": EOF exception found" )
4244 main.log.error( self.name + ": " + self.handle.before )
4245 main.cleanup()
4246 main.exit()
4247 except Exception:
4248 main.log.exception( self.name + ": Uncaught exception!" )
4249 main.cleanup()
4250 main.exit()
4251
Jon Hall80daded2015-05-27 16:07:00 -07004252 def counters( self, jsonFormat=True ):
Jon Hall390696c2015-05-05 17:13:41 -07004253 """
4254 Command to list the various counters in the system.
4255 returns:
Jon Hall80daded2015-05-27 16:07:00 -07004256 if jsonFormat, a string of the json object returned by the cli
4257 command
4258 if not jsonFormat, the normal string output of the cli command
Jon Hall390696c2015-05-05 17:13:41 -07004259 None on error
4260 """
Jon Hall390696c2015-05-05 17:13:41 -07004261 try:
4262 counters = {}
4263 cmdStr = "counters"
Jon Hall80daded2015-05-27 16:07:00 -07004264 if jsonFormat:
4265 cmdStr += " -j"
Jon Hall390696c2015-05-05 17:13:41 -07004266 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004267 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004268 assert "Command not found:" not in output, output
4269 assert "Error executing command" not in output, output
Jon Hall390696c2015-05-05 17:13:41 -07004270 main.log.info( self.name + ": " + output )
Jon Hall80daded2015-05-27 16:07:00 -07004271 return output
Jon Hall390696c2015-05-05 17:13:41 -07004272 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08004273 main.log.exception( "Error in processing 'counters' command." )
Jon Hall80daded2015-05-27 16:07:00 -07004274 return None
Jon Hall390696c2015-05-05 17:13:41 -07004275 except TypeError:
4276 main.log.exception( self.name + ": Object not as expected" )
Jon Hall80daded2015-05-27 16:07:00 -07004277 return None
Jon Hall390696c2015-05-05 17:13:41 -07004278 except pexpect.EOF:
4279 main.log.error( self.name + ": EOF exception found" )
4280 main.log.error( self.name + ": " + self.handle.before )
4281 main.cleanup()
4282 main.exit()
4283 except Exception:
4284 main.log.exception( self.name + ": Uncaught exception!" )
4285 main.cleanup()
4286 main.exit()
4287
Jon Hall935db192016-04-19 00:22:04 -07004288 def counterTestAddAndGet( self, counter, delta=1 ):
Jon Hall390696c2015-05-05 17:13:41 -07004289 """
Jon Halle1a3b752015-07-22 13:02:46 -07004290 CLI command to add a delta to then get a distributed counter.
Jon Hall390696c2015-05-05 17:13:41 -07004291 Required arguments:
4292 counter - The name of the counter to increment.
4293 Optional arguments:
Jon Halle1a3b752015-07-22 13:02:46 -07004294 delta - The long to add to the counter
Jon Hall390696c2015-05-05 17:13:41 -07004295 returns:
4296 integer value of the counter or
4297 None on Error
4298 """
4299 try:
4300 counter = str( counter )
Jon Halle1a3b752015-07-22 13:02:46 -07004301 delta = int( delta )
Jon Hall390696c2015-05-05 17:13:41 -07004302 cmdStr = "counter-test-increment "
Jon Hall390696c2015-05-05 17:13:41 -07004303 cmdStr += counter
Jon Halle1a3b752015-07-22 13:02:46 -07004304 if delta != 1:
4305 cmdStr += " " + str( delta )
Jon Hall390696c2015-05-05 17:13:41 -07004306 output = self.sendline( cmdStr )
Jon Hallfeff3082015-05-19 10:23:26 -07004307 try:
Jon Halla495f562016-05-16 18:03:26 -07004308 assert output is not None, "Error in sendline"
Jon Hallfeff3082015-05-19 10:23:26 -07004309 # TODO: Maybe make this less hardcoded
4310 # ConsistentMap Exceptions
4311 assert "org.onosproject.store.service" not in output
4312 # Node not leader
4313 assert "java.lang.IllegalStateException" not in output
4314 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07004315 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07004316 "command: " + str( output ) )
4317 retryTime = 30 # Conservative time, given by Madan
4318 main.log.info( "Waiting " + str( retryTime ) +
4319 "seconds before retrying." )
4320 time.sleep( retryTime ) # Due to change in mastership
4321 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004322 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004323 assert "Command not found:" not in output, output
4324 assert "Error executing command" not in output, output
Jon Hall390696c2015-05-05 17:13:41 -07004325 main.log.info( self.name + ": " + output )
Jon Halle1a3b752015-07-22 13:02:46 -07004326 pattern = counter + " was updated to (-?\d+)"
Jon Hall390696c2015-05-05 17:13:41 -07004327 match = re.search( pattern, output )
4328 if match:
4329 return int( match.group( 1 ) )
4330 else:
Jon Halle1a3b752015-07-22 13:02:46 -07004331 main.log.error( self.name + ": counterTestAddAndGet did not" +
Jon Hall390696c2015-05-05 17:13:41 -07004332 " match expected output." )
4333 main.log.debug( self.name + " expected: " + pattern )
4334 main.log.debug( self.name + " actual: " + repr( output ) )
4335 return None
4336 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08004337 main.log.exception( "Error in processing '" + cmdStr + "' command." )
Jon Hall390696c2015-05-05 17:13:41 -07004338 return None
4339 except TypeError:
4340 main.log.exception( self.name + ": Object not as expected" )
4341 return None
4342 except pexpect.EOF:
4343 main.log.error( self.name + ": EOF exception found" )
4344 main.log.error( self.name + ": " + self.handle.before )
4345 main.cleanup()
4346 main.exit()
4347 except Exception:
4348 main.log.exception( self.name + ": Uncaught exception!" )
4349 main.cleanup()
4350 main.exit()
4351
Jon Hall935db192016-04-19 00:22:04 -07004352 def counterTestGetAndAdd( self, counter, delta=1 ):
Jon Halle1a3b752015-07-22 13:02:46 -07004353 """
4354 CLI command to get a distributed counter then add a delta to it.
4355 Required arguments:
4356 counter - The name of the counter to increment.
4357 Optional arguments:
4358 delta - The long to add to the counter
Jon Halle1a3b752015-07-22 13:02:46 -07004359 returns:
4360 integer value of the counter or
4361 None on Error
4362 """
4363 try:
4364 counter = str( counter )
4365 delta = int( delta )
4366 cmdStr = "counter-test-increment -g "
Jon Halle1a3b752015-07-22 13:02:46 -07004367 cmdStr += counter
4368 if delta != 1:
4369 cmdStr += " " + str( delta )
4370 output = self.sendline( cmdStr )
4371 try:
Jon Halla495f562016-05-16 18:03:26 -07004372 assert output is not None, "Error in sendline"
Jon Halle1a3b752015-07-22 13:02:46 -07004373 # TODO: Maybe make this less hardcoded
4374 # ConsistentMap Exceptions
4375 assert "org.onosproject.store.service" not in output
4376 # Node not leader
4377 assert "java.lang.IllegalStateException" not in output
4378 except AssertionError:
4379 main.log.error( "Error in processing '" + cmdStr + "' " +
4380 "command: " + str( output ) )
4381 retryTime = 30 # Conservative time, given by Madan
4382 main.log.info( "Waiting " + str( retryTime ) +
4383 "seconds before retrying." )
4384 time.sleep( retryTime ) # Due to change in mastership
4385 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004386 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004387 assert "Command not found:" not in output, output
4388 assert "Error executing command" not in output, output
Jon Halle1a3b752015-07-22 13:02:46 -07004389 main.log.info( self.name + ": " + output )
4390 pattern = counter + " was updated to (-?\d+)"
4391 match = re.search( pattern, output )
4392 if match:
4393 return int( match.group( 1 ) )
4394 else:
4395 main.log.error( self.name + ": counterTestGetAndAdd did not" +
4396 " match expected output." )
4397 main.log.debug( self.name + " expected: " + pattern )
4398 main.log.debug( self.name + " actual: " + repr( output ) )
4399 return None
4400 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08004401 main.log.exception( "Error in processing '" + cmdStr + "' command." )
Jon Halle1a3b752015-07-22 13:02:46 -07004402 return None
4403 except TypeError:
4404 main.log.exception( self.name + ": Object not as expected" )
4405 return None
4406 except pexpect.EOF:
4407 main.log.error( self.name + ": EOF exception found" )
4408 main.log.error( self.name + ": " + self.handle.before )
4409 main.cleanup()
4410 main.exit()
4411 except Exception:
4412 main.log.exception( self.name + ": Uncaught exception!" )
4413 main.cleanup()
4414 main.exit()
4415
YPZhangfebf7302016-05-24 16:45:56 -07004416 def summary( self, jsonFormat=True, timeout=30 ):
kelvin-onlaba297c4d2015-06-01 13:53:55 -07004417 """
4418 Description: Execute summary command in onos
4419 Returns: json object ( summary -j ), returns main.FALSE if there is
4420 no output
4421
4422 """
4423 try:
4424 cmdStr = "summary"
4425 if jsonFormat:
4426 cmdStr += " -j"
YPZhangfebf7302016-05-24 16:45:56 -07004427 handle = self.sendline( cmdStr, timeout=timeout )
Jon Halla495f562016-05-16 18:03:26 -07004428 assert handle is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004429 assert "Command not found:" not in handle, handle
Jon Hall6e709752016-02-01 13:38:46 -08004430 assert "Error:" not in handle, handle
kelvin-onlaba297c4d2015-06-01 13:53:55 -07004431 if not handle:
4432 main.log.error( self.name + ": There is no output in " +
4433 "summary command" )
4434 return main.FALSE
4435 return handle
Jon Hallc6793552016-01-19 14:18:37 -08004436 except AssertionError:
Jon Hall6e709752016-02-01 13:38:46 -08004437 main.log.exception( "{} Error in summary output:".format( self.name ) )
Jon Hallc6793552016-01-19 14:18:37 -08004438 return None
kelvin-onlaba297c4d2015-06-01 13:53:55 -07004439 except TypeError:
4440 main.log.exception( self.name + ": Object not as expected" )
4441 return None
4442 except pexpect.EOF:
4443 main.log.error( self.name + ": EOF exception found" )
4444 main.log.error( self.name + ": " + self.handle.before )
4445 main.cleanup()
4446 main.exit()
4447 except Exception:
4448 main.log.exception( self.name + ": Uncaught exception!" )
4449 main.cleanup()
4450 main.exit()
Jon Hall2a5002c2015-08-21 16:49:11 -07004451
Jon Hall935db192016-04-19 00:22:04 -07004452 def transactionalMapGet( self, keyName ):
Jon Hall2a5002c2015-08-21 16:49:11 -07004453 """
4454 CLI command to get the value of a key in a consistent map using
4455 transactions. This a test function and can only get keys from the
4456 test map hard coded into the cli command
4457 Required arguments:
4458 keyName - The name of the key to get
Jon Hall2a5002c2015-08-21 16:49:11 -07004459 returns:
4460 The string value of the key or
4461 None on Error
4462 """
4463 try:
4464 keyName = str( keyName )
4465 cmdStr = "transactional-map-test-get "
Jon Hall2a5002c2015-08-21 16:49:11 -07004466 cmdStr += keyName
4467 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004468 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004469 assert "Command not found:" not in output, output
Jon Hall2a5002c2015-08-21 16:49:11 -07004470 try:
4471 # TODO: Maybe make this less hardcoded
4472 # ConsistentMap Exceptions
4473 assert "org.onosproject.store.service" not in output
4474 # Node not leader
4475 assert "java.lang.IllegalStateException" not in output
4476 except AssertionError:
4477 main.log.error( "Error in processing '" + cmdStr + "' " +
4478 "command: " + str( output ) )
4479 return None
4480 pattern = "Key-value pair \(" + keyName + ", (?P<value>.+)\) found."
4481 if "Key " + keyName + " not found." in output:
Jon Hall9bfadd22016-05-11 14:48:07 -07004482 main.log.warn( output )
Jon Hall2a5002c2015-08-21 16:49:11 -07004483 return None
4484 else:
4485 match = re.search( pattern, output )
4486 if match:
4487 return match.groupdict()[ 'value' ]
4488 else:
4489 main.log.error( self.name + ": transactionlMapGet did not" +
4490 " match expected output." )
4491 main.log.debug( self.name + " expected: " + pattern )
4492 main.log.debug( self.name + " actual: " + repr( output ) )
4493 return None
Jon Hallc6793552016-01-19 14:18:37 -08004494 except AssertionError:
4495 main.log.exception( "" )
4496 return None
Jon Hall2a5002c2015-08-21 16:49:11 -07004497 except TypeError:
4498 main.log.exception( self.name + ": Object not as expected" )
4499 return None
4500 except pexpect.EOF:
4501 main.log.error( self.name + ": EOF exception found" )
4502 main.log.error( self.name + ": " + self.handle.before )
4503 main.cleanup()
4504 main.exit()
4505 except Exception:
4506 main.log.exception( self.name + ": Uncaught exception!" )
4507 main.cleanup()
4508 main.exit()
4509
Jon Hall935db192016-04-19 00:22:04 -07004510 def transactionalMapPut( self, numKeys, value ):
Jon Hall2a5002c2015-08-21 16:49:11 -07004511 """
4512 CLI command to put a value into 'numKeys' number of keys in a
4513 consistent map using transactions. This a test function and can only
4514 put into keys named 'Key#' of the test map hard coded into the cli command
4515 Required arguments:
4516 numKeys - Number of keys to add the value to
4517 value - The string value to put into the keys
Jon Hall2a5002c2015-08-21 16:49:11 -07004518 returns:
4519 A dictionary whose keys are the name of the keys put into the map
4520 and the values of the keys are dictionaries whose key-values are
4521 'value': value put into map and optionaly
4522 'oldValue': Previous value in the key or
4523 None on Error
4524
4525 Example output
4526 { 'Key1': {'oldValue': 'oldTestValue', 'value': 'Testing'},
4527 'Key2': {'value': 'Testing'} }
4528 """
4529 try:
4530 numKeys = str( numKeys )
4531 value = str( value )
4532 cmdStr = "transactional-map-test-put "
Jon Hall2a5002c2015-08-21 16:49:11 -07004533 cmdStr += numKeys + " " + value
4534 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004535 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004536 assert "Command not found:" not in output, output
Jon Hall2a5002c2015-08-21 16:49:11 -07004537 try:
4538 # TODO: Maybe make this less hardcoded
4539 # ConsistentMap Exceptions
4540 assert "org.onosproject.store.service" not in output
4541 # Node not leader
4542 assert "java.lang.IllegalStateException" not in output
4543 except AssertionError:
4544 main.log.error( "Error in processing '" + cmdStr + "' " +
4545 "command: " + str( output ) )
4546 return None
4547 newPattern = 'Created Key (?P<key>(\w)+) with value (?P<value>(.)+)\.'
4548 updatedPattern = "Put (?P<value>(.)+) into key (?P<key>(\w)+)\. The old value was (?P<oldValue>(.)+)\."
4549 results = {}
4550 for line in output.splitlines():
4551 new = re.search( newPattern, line )
4552 updated = re.search( updatedPattern, line )
4553 if new:
4554 results[ new.groupdict()[ 'key' ] ] = { 'value': new.groupdict()[ 'value' ] }
4555 elif updated:
4556 results[ updated.groupdict()[ 'key' ] ] = { 'value': updated.groupdict()[ 'value' ],
Jon Hallc6793552016-01-19 14:18:37 -08004557 'oldValue': updated.groupdict()[ 'oldValue' ] }
Jon Hall2a5002c2015-08-21 16:49:11 -07004558 else:
4559 main.log.error( self.name + ": transactionlMapGet did not" +
4560 " match expected output." )
Jon Hallc6793552016-01-19 14:18:37 -08004561 main.log.debug( "{} expected: {!r} or {!r}".format( self.name,
4562 newPattern,
4563 updatedPattern ) )
Jon Hall2a5002c2015-08-21 16:49:11 -07004564 main.log.debug( self.name + " actual: " + repr( output ) )
4565 return results
Jon Hallc6793552016-01-19 14:18:37 -08004566 except AssertionError:
4567 main.log.exception( "" )
4568 return None
Jon Hall2a5002c2015-08-21 16:49:11 -07004569 except TypeError:
4570 main.log.exception( self.name + ": Object not as expected" )
4571 return None
4572 except pexpect.EOF:
4573 main.log.error( self.name + ": EOF exception found" )
4574 main.log.error( self.name + ": " + self.handle.before )
4575 main.cleanup()
4576 main.exit()
4577 except Exception:
4578 main.log.exception( self.name + ": Uncaught exception!" )
4579 main.cleanup()
4580 main.exit()
Jon Hallc6793552016-01-19 14:18:37 -08004581
acsmarsdaea66c2015-09-03 11:44:06 -07004582 def maps( self, jsonFormat=True ):
4583 """
4584 Description: Returns result of onos:maps
4585 Optional:
4586 * jsonFormat: enable json formatting of output
4587 """
4588 try:
4589 cmdStr = "maps"
4590 if jsonFormat:
4591 cmdStr += " -j"
4592 handle = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004593 assert handle is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004594 assert "Command not found:" not in handle, handle
acsmarsdaea66c2015-09-03 11:44:06 -07004595 return handle
Jon Hallc6793552016-01-19 14:18:37 -08004596 except AssertionError:
4597 main.log.exception( "" )
4598 return None
acsmarsdaea66c2015-09-03 11:44:06 -07004599 except TypeError:
4600 main.log.exception( self.name + ": Object not as expected" )
4601 return None
4602 except pexpect.EOF:
4603 main.log.error( self.name + ": EOF exception found" )
4604 main.log.error( self.name + ": " + self.handle.before )
4605 main.cleanup()
4606 main.exit()
4607 except Exception:
4608 main.log.exception( self.name + ": Uncaught exception!" )
4609 main.cleanup()
4610 main.exit()
GlennRC050596c2015-11-18 17:06:41 -08004611
4612 def getSwController( self, uri, jsonFormat=True ):
4613 """
4614 Descrition: Gets the controller information from the device
4615 """
4616 try:
4617 cmd = "device-controllers "
4618 if jsonFormat:
4619 cmd += "-j "
4620 response = self.sendline( cmd + uri )
Jon Halla495f562016-05-16 18:03:26 -07004621 assert response is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004622 assert "Command not found:" not in response, response
GlennRC050596c2015-11-18 17:06:41 -08004623 return response
Jon Hallc6793552016-01-19 14:18:37 -08004624 except AssertionError:
4625 main.log.exception( "" )
4626 return None
GlennRC050596c2015-11-18 17:06:41 -08004627 except TypeError:
4628 main.log.exception( self.name + ": Object not as expected" )
4629 return None
4630 except pexpect.EOF:
4631 main.log.error( self.name + ": EOF exception found" )
4632 main.log.error( self.name + ": " + self.handle.before )
4633 main.cleanup()
4634 main.exit()
4635 except Exception:
4636 main.log.exception( self.name + ": Uncaught exception!" )
4637 main.cleanup()
4638 main.exit()
4639
4640 def setSwController( self, uri, ip, proto="tcp", port="6653", jsonFormat=True ):
4641 """
4642 Descrition: sets the controller(s) for the specified device
4643
4644 Parameters:
4645 Required: uri - String: The uri of the device(switch).
4646 ip - String or List: The ip address of the controller.
4647 This parameter can be formed in a couple of different ways.
4648 VALID:
4649 10.0.0.1 - just the ip address
4650 tcp:10.0.0.1 - the protocol and the ip address
4651 tcp:10.0.0.1:6653 - the protocol and port can be specified,
4652 so that you can add controllers with different
4653 protocols and ports
4654 INVALID:
4655 10.0.0.1:6653 - this is not supported by ONOS
4656
4657 Optional: proto - The type of connection e.g. tcp, ssl. If a list of ips are given
4658 port - The port number.
4659 jsonFormat - If set ONOS will output in json NOTE: This is currently not supported
4660
4661 Returns: main.TRUE if ONOS returns without any errors, otherwise returns main.FALSE
4662 """
4663 try:
4664 cmd = "device-setcontrollers"
4665
4666 if jsonFormat:
4667 cmd += " -j"
4668 cmd += " " + uri
4669 if isinstance( ip, str ):
4670 ip = [ip]
4671 for item in ip:
4672 if ":" in item:
4673 sitem = item.split( ":" )
4674 if len(sitem) == 3:
4675 cmd += " " + item
4676 elif "." in sitem[1]:
4677 cmd += " {}:{}".format(item, port)
4678 else:
4679 main.log.error( "Malformed entry: " + item )
4680 raise TypeError
4681 else:
4682 cmd += " {}:{}:{}".format( proto, item, port )
GlennRC050596c2015-11-18 17:06:41 -08004683 response = self.sendline( cmd )
Jon Halla495f562016-05-16 18:03:26 -07004684 assert response is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004685 assert "Command not found:" not in response, response
GlennRC050596c2015-11-18 17:06:41 -08004686 if "Error" in response:
4687 main.log.error( response )
4688 return main.FALSE
GlennRC050596c2015-11-18 17:06:41 -08004689 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -08004690 except AssertionError:
4691 main.log.exception( "" )
4692 return None
GlennRC050596c2015-11-18 17:06:41 -08004693 except TypeError:
4694 main.log.exception( self.name + ": Object not as expected" )
4695 return main.FALSE
4696 except pexpect.EOF:
4697 main.log.error( self.name + ": EOF exception found" )
4698 main.log.error( self.name + ": " + self.handle.before )
4699 main.cleanup()
4700 main.exit()
4701 except Exception:
4702 main.log.exception( self.name + ": Uncaught exception!" )
4703 main.cleanup()
4704 main.exit()
GlennRC20fc6522015-12-23 23:26:57 -08004705
4706 def removeDevice( self, device ):
4707 '''
4708 Description:
4709 Remove a device from ONOS by passing the uri of the device(s).
4710 Parameters:
4711 device - (str or list) the id or uri of the device ex. "of:0000000000000001"
4712 Returns:
4713 Returns main.FALSE if an exception is thrown or an error is present
4714 in the response. Otherwise, returns main.TRUE.
4715 NOTE:
4716 If a host cannot be removed, then this function will return main.FALSE
4717 '''
4718 try:
4719 if type( device ) is str:
You Wang823f5022016-08-18 15:24:41 -07004720 deviceStr = device
4721 device = []
4722 device.append( deviceStr )
GlennRC20fc6522015-12-23 23:26:57 -08004723
4724 for d in device:
4725 time.sleep( 1 )
4726 response = self.sendline( "device-remove {}".format( d ) )
Jon Halla495f562016-05-16 18:03:26 -07004727 assert response is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004728 assert "Command not found:" not in response, response
GlennRC20fc6522015-12-23 23:26:57 -08004729 if "Error" in response:
4730 main.log.warn( "Error for device: {}\nResponse: {}".format( d, response ) )
4731 return main.FALSE
GlennRC20fc6522015-12-23 23:26:57 -08004732 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -08004733 except AssertionError:
4734 main.log.exception( "" )
4735 return main.FALSE
GlennRC20fc6522015-12-23 23:26:57 -08004736 except TypeError:
4737 main.log.exception( self.name + ": Object not as expected" )
4738 return main.FALSE
4739 except pexpect.EOF:
4740 main.log.error( self.name + ": EOF exception found" )
4741 main.log.error( self.name + ": " + self.handle.before )
4742 main.cleanup()
4743 main.exit()
4744 except Exception:
4745 main.log.exception( self.name + ": Uncaught exception!" )
4746 main.cleanup()
4747 main.exit()
4748
4749 def removeHost( self, host ):
4750 '''
4751 Description:
4752 Remove a host from ONOS by passing the id of the host(s)
4753 Parameters:
4754 hostId - (str or list) the id or mac of the host ex. "00:00:00:00:00:01"
4755 Returns:
4756 Returns main.FALSE if an exception is thrown or an error is present
4757 in the response. Otherwise, returns main.TRUE.
4758 NOTE:
4759 If a host cannot be removed, then this function will return main.FALSE
4760 '''
4761 try:
4762 if type( host ) is str:
4763 host = list( host )
4764
4765 for h in host:
4766 time.sleep( 1 )
4767 response = self.sendline( "host-remove {}".format( h ) )
Jon Halla495f562016-05-16 18:03:26 -07004768 assert response is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004769 assert "Command not found:" not in response, response
GlennRC20fc6522015-12-23 23:26:57 -08004770 if "Error" in response:
4771 main.log.warn( "Error for host: {}\nResponse: {}".format( h, response ) )
4772 return main.FALSE
GlennRC20fc6522015-12-23 23:26:57 -08004773 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -08004774 except AssertionError:
4775 main.log.exception( "" )
4776 return None
GlennRC20fc6522015-12-23 23:26:57 -08004777 except TypeError:
4778 main.log.exception( self.name + ": Object not as expected" )
4779 return main.FALSE
4780 except pexpect.EOF:
4781 main.log.error( self.name + ": EOF exception found" )
4782 main.log.error( self.name + ": " + self.handle.before )
4783 main.cleanup()
4784 main.exit()
4785 except Exception:
4786 main.log.exception( self.name + ": Uncaught exception!" )
4787 main.cleanup()
4788 main.exit()
GlennRCed771242016-01-13 17:02:47 -08004789
YPZhangfebf7302016-05-24 16:45:56 -07004790 def link( self, begin, end, state, timeout=30, showResponse=True ):
GlennRCed771242016-01-13 17:02:47 -08004791 '''
4792 Description:
4793 Bring link down or up in the null-provider.
4794 params:
4795 begin - (string) One end of a device or switch.
4796 end - (string) the other end of the device or switch
4797 returns:
4798 main.TRUE if no exceptions were thrown and no Errors are
4799 present in the resoponse. Otherwise, returns main.FALSE
4800 '''
4801 try:
Jon Hallc6793552016-01-19 14:18:37 -08004802 cmd = "null-link null:{} null:{} {}".format( begin, end, state )
YPZhangfebf7302016-05-24 16:45:56 -07004803 response = self.sendline( cmd, showResponse=showResponse, timeout=timeout )
Jon Halla495f562016-05-16 18:03:26 -07004804 assert response is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004805 assert "Command not found:" not in response, response
GlennRCed771242016-01-13 17:02:47 -08004806 if "Error" in response or "Failure" in response:
4807 main.log.error( response )
4808 return main.FALSE
GlennRCed771242016-01-13 17:02:47 -08004809 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -08004810 except AssertionError:
4811 main.log.exception( "" )
4812 return None
GlennRCed771242016-01-13 17:02:47 -08004813 except TypeError:
4814 main.log.exception( self.name + ": Object not as expected" )
4815 return main.FALSE
4816 except pexpect.EOF:
4817 main.log.error( self.name + ": EOF exception found" )
4818 main.log.error( self.name + ": " + self.handle.before )
4819 main.cleanup()
4820 main.exit()
4821 except Exception:
4822 main.log.exception( self.name + ": Uncaught exception!" )
4823 main.cleanup()
4824 main.exit()
4825
Flavio Castro82ee2f62016-06-07 15:04:12 -07004826 def portstate(self, dpid='of:0000000000000102', port='2', state='enable'):
4827 '''
4828 Description:
4829 Changes the state of port in an OF switch by means of the
4830 PORTSTATUS OF messages.
4831 params:
4832 dpid - (string) Datapath ID of the device
4833 port - (string) target port in the device
4834 state - (string) target state (enable or disabled)
4835 returns:
4836 main.TRUE if no exceptions were thrown and no Errors are
4837 present in the resoponse. Otherwise, returns main.FALSE
4838 '''
4839 try:
4840 cmd = "portstate {} {} {}".format( dpid, port, state )
4841 response = self.sendline( cmd, showResponse=True )
4842 assert response is not None, "Error in sendline"
4843 assert "Command not found:" not in response, response
4844 if "Error" in response or "Failure" in response:
4845 main.log.error( response )
4846 return main.FALSE
4847 return main.TRUE
4848 except AssertionError:
4849 main.log.exception( "" )
4850 return None
4851 except TypeError:
4852 main.log.exception( self.name + ": Object not as expected" )
4853 return main.FALSE
4854 except pexpect.EOF:
4855 main.log.error( self.name + ": EOF exception found" )
4856 main.log.error( self.name + ": " + self.handle.before )
4857 main.cleanup()
4858 main.exit()
4859 except Exception:
4860 main.log.exception( self.name + ": Uncaught exception!" )
4861 main.cleanup()
4862 main.exit()
4863
4864 def logSet( self, level="INFO", app="org.onosproject" ):
4865 """
4866 Set the logging level to lvl for a specific app
4867 returns main.TRUE on success
4868 returns main.FALSE if Error occurred
4869 if noExit is True, TestON will not exit, but clean up
4870 Available level: DEBUG, TRACE, INFO, WARN, ERROR
4871 Level defaults to INFO
4872 """
4873 try:
4874 self.handle.sendline( "log:set %s %s" %( level, app ) )
4875 self.handle.expect( "onos>" )
4876
4877 response = self.handle.before
4878 if re.search( "Error", response ):
4879 return main.FALSE
4880 return main.TRUE
4881 except pexpect.TIMEOUT:
4882 main.log.exception( self.name + ": TIMEOUT exception found" )
4883 main.cleanup()
4884 main.exit()
4885 except pexpect.EOF:
4886 main.log.error( self.name + ": EOF exception found" )
4887 main.log.error( self.name + ": " + self.handle.before )
4888 main.cleanup()
4889 main.exit()
4890 except Exception:
4891 main.log.exception( self.name + ": Uncaught exception!" )
4892 main.cleanup()
4893 main.exit()
You Wangdb8cd0a2016-05-26 15:19:45 -07004894
4895 def getGraphDict( self, timeout=60, includeHost=False ):
4896 """
4897 Return a dictionary which describes the latest network topology data as a
4898 graph.
4899 An example of the dictionary:
4900 { vertex1: { 'edges': ..., 'name': ..., 'protocol': ... },
4901 vertex2: { 'edges': ..., 'name': ..., 'protocol': ... } }
4902 Each vertex should at least have an 'edges' attribute which describes the
4903 adjacency information. The value of 'edges' attribute is also represented by
4904 a dictionary, which maps each edge (identified by the neighbor vertex) to a
4905 list of attributes.
4906 An example of the edges dictionary:
4907 'edges': { vertex2: { 'port': ..., 'weight': ... },
4908 vertex3: { 'port': ..., 'weight': ... } }
4909 If includeHost == True, all hosts (and host-switch links) will be included
4910 in topology data.
4911 """
4912 graphDict = {}
4913 try:
4914 links = self.links()
4915 links = json.loads( links )
4916 devices = self.devices()
4917 devices = json.loads( devices )
4918 idToDevice = {}
4919 for device in devices:
4920 idToDevice[ device[ 'id' ] ] = device
4921 if includeHost:
4922 hosts = self.hosts()
4923 # FIXME: support 'includeHost' argument
4924 for link in links:
4925 nodeA = link[ 'src' ][ 'device' ]
4926 nodeB = link[ 'dst' ][ 'device' ]
4927 assert idToDevice[ nodeA ][ 'available' ] and idToDevice[ nodeB ][ 'available' ]
4928 if not nodeA in graphDict.keys():
4929 graphDict[ nodeA ] = { 'edges':{},
4930 'dpid':idToDevice[ nodeA ][ 'id' ][3:],
4931 'type':idToDevice[ nodeA ][ 'type' ],
4932 'available':idToDevice[ nodeA ][ 'available' ],
4933 'role':idToDevice[ nodeA ][ 'role' ],
4934 'mfr':idToDevice[ nodeA ][ 'mfr' ],
4935 'hw':idToDevice[ nodeA ][ 'hw' ],
4936 'sw':idToDevice[ nodeA ][ 'sw' ],
4937 'serial':idToDevice[ nodeA ][ 'serial' ],
4938 'chassisId':idToDevice[ nodeA ][ 'chassisId' ],
4939 'annotations':idToDevice[ nodeA ][ 'annotations' ]}
4940 else:
4941 # Assert nodeB is not connected to any current links of nodeA
4942 assert nodeB not in graphDict[ nodeA ][ 'edges' ].keys()
4943 graphDict[ nodeA ][ 'edges' ][ nodeB ] = { 'port':link[ 'src' ][ 'port' ],
4944 'type':link[ 'type' ],
4945 'state':link[ 'state' ] }
4946 return graphDict
4947 except ( TypeError, ValueError ):
4948 main.log.exception( self.name + ": Object not as expected" )
4949 return None
4950 except KeyError:
4951 main.log.exception( self.name + ": KeyError exception found" )
4952 return None
4953 except AssertionError:
4954 main.log.exception( self.name + ": AssertionError exception found" )
4955 return None
4956 except pexpect.EOF:
4957 main.log.error( self.name + ": EOF exception found" )
4958 main.log.error( self.name + ": " + self.handle.before )
4959 return None
4960 except Exception:
4961 main.log.exception( self.name + ": Uncaught exception!" )
4962 return None
YPZhangcbc2a062016-07-11 10:55:44 -07004963
4964 def getIntentPerfSummary( self ):
4965 '''
4966 Send command to check intent-perf summary
4967 Returns: dictionary for intent-perf summary
4968 if something wrong, function will return None
4969 '''
4970 cmd = "intent-perf -s"
4971 respDic = {}
4972 resp = self.sendline( cmd )
4973 try:
4974 # Generate the dictionary to return
4975 for l in resp.split( "\n" ):
4976 # Delete any white space in line
4977 temp = re.sub( r'\s+', '', l )
4978 temp = temp.split( ":" )
4979 respDic[ temp[0] ] = temp[ 1 ]
4980
4981 except (TypeError, ValueError):
4982 main.log.exception( self.name + ": Object not as expected" )
4983 return None
4984 except KeyError:
4985 main.log.exception( self.name + ": KeyError exception found" )
4986 return None
4987 except AssertionError:
4988 main.log.exception( self.name + ": AssertionError exception found" )
4989 return None
4990 except pexpect.EOF:
4991 main.log.error( self.name + ": EOF exception found" )
4992 main.log.error( self.name + ": " + self.handle.before )
4993 return None
4994 except Exception:
4995 main.log.exception( self.name + ": Uncaught exception!" )
4996 return None
4997 return respDic
4998
4999