blob: ff3a56c9369482527df9b06eb5efcfa78ccbdd2b [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' ]
2219 if len( intentDict ) != len( intentDictONOS ):
2220 main.log.info( self.name + ": expected intent count does not match that in ONOS, " +
2221 str( len( intentDict ) ) + " expected and " +
2222 str( len( intentDictONOS ) ) + " actual" )
2223 return main.FALSE
2224 returnValue = main.TRUE
2225 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
2229 elif intentDict[ intentID ] != intentDictONOS[ intentID ]:
2230 main.log.debug( self.name + ": intent ID - " + intentID +
2231 " expected state is " + intentDict[ intentID ] +
2232 " but actual state is " + intentDictONOS[ intentID ] )
2233 returnValue = main.FALSE
2234 if returnValue == main.TRUE:
2235 main.log.info( self.name + ": all intent IDs and states match that in ONOS" )
2236 return returnValue
You Wang1be9a512016-05-26 16:54:17 -07002237 except KeyError:
2238 main.log.exception( self.name + ": KeyError exception found" )
2239 return main.ERROR
You Wang66518af2016-05-16 15:32:59 -07002240 except ( TypeError, ValueError ):
2241 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, intentsRaw ) )
You Wang85560372016-05-18 10:44:33 -07002242 return main.ERROR
You Wang66518af2016-05-16 15:32:59 -07002243 except pexpect.EOF:
2244 main.log.error( self.name + ": EOF exception found" )
2245 main.log.error( self.name + ": " + self.handle.before )
2246 main.cleanup()
2247 main.exit()
2248 except Exception:
2249 main.log.exception( self.name + ": Uncaught exception!" )
2250 main.cleanup()
2251 main.exit()
2252
YPZhang14a4aa92016-07-15 13:37:15 -07002253 def checkIntentSummary( self, timeout=60, noExit=True ):
GlennRCed771242016-01-13 17:02:47 -08002254 """
2255 Description:
2256 Check the number of installed intents.
2257 Optional:
2258 timeout - the timeout for pexcept
YPZhang14a4aa92016-07-15 13:37:15 -07002259 noExit - If noExit, TestON will not exit if any except.
GlennRCed771242016-01-13 17:02:47 -08002260 Return:
2261 Returns main.TRUE only if the number of all installed intents are the same as total intents number
2262 , otherwise, returns main.FALSE.
2263 """
2264
2265 try:
2266 cmd = "intents -s -j"
2267
2268 # Check response if something wrong
YPZhang14a4aa92016-07-15 13:37:15 -07002269 response = self.sendline( cmd, timeout=timeout, noExit=noExit )
GlennRCed771242016-01-13 17:02:47 -08002270 if response == None:
YPZhang0584d432016-06-21 15:20:13 -07002271 return main.FALSE
GlennRCed771242016-01-13 17:02:47 -08002272 response = json.loads( response )
2273
2274 # get total and installed number, see if they are match
2275 allState = response.get( 'all' )
2276 if allState.get('total') == allState.get('installed'):
YPZhangb5d3f832016-01-23 22:54:26 -08002277 main.log.info( 'Total Intents: {} Installed Intents: {}'.format( allState.get('total'), allState.get('installed') ) )
GlennRCed771242016-01-13 17:02:47 -08002278 return main.TRUE
YPZhangb5d3f832016-01-23 22:54:26 -08002279 main.log.info( 'Verified Intents failed Excepte intetnes: {} installed intents: {}'.format( allState.get('total'), allState.get('installed') ) )
GlennRCed771242016-01-13 17:02:47 -08002280 return main.FALSE
2281
Jon Hallc6793552016-01-19 14:18:37 -08002282 except ( TypeError, ValueError ):
2283 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, response ) )
GlennRCed771242016-01-13 17:02:47 -08002284 return None
2285 except pexpect.EOF:
2286 main.log.error( self.name + ": EOF exception found" )
2287 main.log.error( self.name + ": " + self.handle.before )
YPZhang14a4aa92016-07-15 13:37:15 -07002288 if noExit:
2289 return main.FALSE
2290 else:
2291 main.cleanup()
2292 main.exit()
GlennRCed771242016-01-13 17:02:47 -08002293 except Exception:
2294 main.log.exception( self.name + ": Uncaught exception!" )
YPZhang14a4aa92016-07-15 13:37:15 -07002295 if noExit:
2296 return main.FALSE
2297 else:
2298 main.cleanup()
2299 main.exit()
YPZhangebf9eb52016-05-12 15:20:24 -07002300 except pexpect.TIMEOUT:
2301 main.log.error( self.name + ": ONOS timeout" )
2302 return None
GlennRCed771242016-01-13 17:02:47 -08002303
Jeremy Songster306ed7a2016-07-19 10:59:07 -07002304 def flows( self, state="", jsonFormat=True, timeout=60, noExit=False, noCore=False ):
kelvin8ec71442015-01-15 16:57:00 -08002305 """
Shreya Shah0f01c812014-10-26 20:15:28 -04002306 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002307 * jsonFormat: enable output formatting in json
Jeremy Songster306ed7a2016-07-19 10:59:07 -07002308 * noCore: suppress core flows
Shreya Shah0f01c812014-10-26 20:15:28 -04002309 Description:
Jon Halle3f39ff2015-01-13 11:50:53 -08002310 Obtain flows currently installed
kelvin-onlab898a6c62015-01-16 14:13:53 -08002311 """
Shreya Shah0f01c812014-10-26 20:15:28 -04002312 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002313 cmdStr = "flows"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002314 if jsonFormat:
GlennRCed771242016-01-13 17:02:47 -08002315 cmdStr += " -j "
Jeremy Songster306ed7a2016-07-19 10:59:07 -07002316 if noCore:
2317 cmdStr += " -n "
GlennRCed771242016-01-13 17:02:47 -08002318 cmdStr += state
YPZhangebf9eb52016-05-12 15:20:24 -07002319 handle = self.sendline( cmdStr, timeout=timeout, noExit=noExit )
Jon Hallc6793552016-01-19 14:18:37 -08002320 assert "Command not found:" not in handle, handle
2321 if re.search( "Error:", handle ):
2322 main.log.error( self.name + ": flows() response: " +
2323 str( handle ) )
2324 return handle
2325 except AssertionError:
2326 main.log.exception( "" )
GlennRCed771242016-01-13 17:02:47 -08002327 return None
Jon Halld4d4b372015-01-28 16:02:41 -08002328 except TypeError:
2329 main.log.exception( self.name + ": Object not as expected" )
2330 return None
Jon Hallc6793552016-01-19 14:18:37 -08002331 except pexpect.TIMEOUT:
2332 main.log.error( self.name + ": ONOS timeout" )
2333 return None
Shreya Shah0f01c812014-10-26 20:15:28 -04002334 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002335 main.log.error( self.name + ": EOF exception found" )
2336 main.log.error( self.name + ": " + self.handle.before )
Shreya Shah0f01c812014-10-26 20:15:28 -04002337 main.cleanup()
2338 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002339 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002340 main.log.exception( self.name + ": Uncaught exception!" )
Shreya Shah0f01c812014-10-26 20:15:28 -04002341 main.cleanup()
2342 main.exit()
2343
Flavio Castrod2ffffa2016-04-26 15:56:56 -07002344 def checkFlowCount(self, min=0, timeout=60 ):
Flavio Castroa1286fe2016-07-25 14:48:51 -07002345 count = self.getTotalFlowsNum( timeout=timeout )
2346 count = int (count) if count else 0
Flavio Castrod2ffffa2016-04-26 15:56:56 -07002347 return count if (count > min) else False
GlennRCed771242016-01-13 17:02:47 -08002348
YPZhangebf9eb52016-05-12 15:20:24 -07002349 def checkFlowsState( self, isPENDING=True, timeout=60,noExit=False ):
kelvin-onlab4df89f22015-04-13 18:10:23 -07002350 """
2351 Description:
GlennRCed771242016-01-13 17:02:47 -08002352 Check the if all the current flows are in ADDED state
Jon Hallc6793552016-01-19 14:18:37 -08002353 We check PENDING_ADD, PENDING_REMOVE, REMOVED, and FAILED flows,
2354 if the count of those states is 0, which means all current flows
2355 are in ADDED state, and return main.TRUE otherwise return main.FALSE
pingping-linbab7f8a2015-09-21 17:33:36 -07002356 Optional:
GlennRCed771242016-01-13 17:02:47 -08002357 * isPENDING: whether the PENDING_ADD is also a correct status
kelvin-onlab4df89f22015-04-13 18:10:23 -07002358 Return:
2359 returnValue - Returns main.TRUE only if all flows are in
Jon Hallc6793552016-01-19 14:18:37 -08002360 ADDED state or PENDING_ADD if the isPENDING
pingping-linbab7f8a2015-09-21 17:33:36 -07002361 parameter is set true, return main.FALSE otherwise.
kelvin-onlab4df89f22015-04-13 18:10:23 -07002362 """
2363 try:
GlennRCed771242016-01-13 17:02:47 -08002364 states = ["PENDING_ADD", "PENDING_REMOVE", "REMOVED", "FAILED"]
2365 checkedStates = []
2366 statesCount = [0, 0, 0, 0]
2367 for s in states:
Jon Hallc6793552016-01-19 14:18:37 -08002368 rawFlows = self.flows( state=s, timeout = timeout )
YPZhang240842b2016-05-17 12:00:50 -07002369 if rawFlows:
2370 # if we didn't get flows or flows function return None, we should return
2371 # main.Flase
2372 checkedStates.append( json.loads( rawFlows ) )
2373 else:
2374 return main.FALSE
Jon Hallc6793552016-01-19 14:18:37 -08002375 for i in range( len( states ) ):
GlennRCed771242016-01-13 17:02:47 -08002376 for c in checkedStates[i]:
Jon Hallc6793552016-01-19 14:18:37 -08002377 try:
2378 statesCount[i] += int( c.get( "flowCount" ) )
2379 except TypeError:
2380 main.log.exception( "Json object not as expected" )
2381 main.log.info( states[i] + " flows: " + str( statesCount[i] ) )
kelvin-onlabf2ec6e02015-05-27 14:15:28 -07002382
GlennRCed771242016-01-13 17:02:47 -08002383 # We want to count PENDING_ADD if isPENDING is true
2384 if isPENDING:
2385 if statesCount[1] + statesCount[2] + statesCount[3] > 0:
2386 return main.FALSE
pingping-linbab7f8a2015-09-21 17:33:36 -07002387 else:
GlennRCed771242016-01-13 17:02:47 -08002388 if statesCount[0] + statesCount[1] + statesCount[2] + statesCount[3] > 0:
2389 return main.FALSE
GlennRCed771242016-01-13 17:02:47 -08002390 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -08002391 except ( TypeError, ValueError ):
2392 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, rawFlows ) )
kelvin-onlab4df89f22015-04-13 18:10:23 -07002393 return None
Jeremy Songster9385d412016-06-02 17:57:36 -07002394
YPZhang240842b2016-05-17 12:00:50 -07002395 except AssertionError:
2396 main.log.exception( "" )
2397 return None
kelvin-onlab4df89f22015-04-13 18:10:23 -07002398 except pexpect.EOF:
2399 main.log.error( self.name + ": EOF exception found" )
2400 main.log.error( self.name + ": " + self.handle.before )
2401 main.cleanup()
2402 main.exit()
2403 except Exception:
2404 main.log.exception( self.name + ": Uncaught exception!" )
2405 main.cleanup()
2406 main.exit()
YPZhangebf9eb52016-05-12 15:20:24 -07002407 except pexpect.TIMEOUT:
2408 main.log.error( self.name + ": ONOS timeout" )
2409 return None
2410
kelvin-onlab4df89f22015-04-13 18:10:23 -07002411
GlennRCed771242016-01-13 17:02:47 -08002412 def pushTestIntents( self, ingress, egress, batchSize, offset="",
YPZhangb34b7e12016-06-14 14:28:19 -07002413 options="", timeout=10, background = False, noExit=False, getResponse=False ):
kelvin8ec71442015-01-15 16:57:00 -08002414 """
andrewonlab87852b02014-11-19 18:44:19 -05002415 Description:
Jon Halle3f39ff2015-01-13 11:50:53 -08002416 Push a number of intents in a batch format to
andrewonlab87852b02014-11-19 18:44:19 -05002417 a specific point-to-point intent definition
2418 Required:
GlennRCed771242016-01-13 17:02:47 -08002419 * ingress: specify source dpid
2420 * egress: specify destination dpid
2421 * batchSize: specify number of intents to push
andrewonlab87852b02014-11-19 18:44:19 -05002422 Optional:
GlennRCed771242016-01-13 17:02:47 -08002423 * offset: the keyOffset is where the next batch of intents
2424 will be installed
YPZhangb34b7e12016-06-14 14:28:19 -07002425 * noExit: If set to True, TestON will not exit if any error when issus command
2426 * getResponse: If set to True, function will return ONOS response.
2427
GlennRCed771242016-01-13 17:02:47 -08002428 Returns: If failed to push test intents, it will returen None,
2429 if successful, return true.
2430 Timeout expection will return None,
2431 TypeError will return false
2432 other expections will exit()
kelvin8ec71442015-01-15 16:57:00 -08002433 """
andrewonlab87852b02014-11-19 18:44:19 -05002434 try:
GlennRCed771242016-01-13 17:02:47 -08002435 if background:
2436 back = "&"
andrewonlab87852b02014-11-19 18:44:19 -05002437 else:
GlennRCed771242016-01-13 17:02:47 -08002438 back = ""
2439 cmd = "push-test-intents {} {} {} {} {} {}".format( options,
Jon Hallc6793552016-01-19 14:18:37 -08002440 ingress,
2441 egress,
2442 batchSize,
2443 offset,
2444 back )
YPZhangebf9eb52016-05-12 15:20:24 -07002445 response = self.sendline( cmd, timeout=timeout, noExit=noExit )
Jon Hallc6793552016-01-19 14:18:37 -08002446 assert "Command not found:" not in response, response
GlennRCed771242016-01-13 17:02:47 -08002447 main.log.info( response )
2448 if response == None:
2449 return None
2450
YPZhangb34b7e12016-06-14 14:28:19 -07002451 if getResponse:
2452 return response
2453
GlennRCed771242016-01-13 17:02:47 -08002454 # TODO: We should handle if there is failure in installation
2455 return main.TRUE
2456
Jon Hallc6793552016-01-19 14:18:37 -08002457 except AssertionError:
2458 main.log.exception( "" )
2459 return None
GlennRCed771242016-01-13 17:02:47 -08002460 except pexpect.TIMEOUT:
2461 main.log.error( self.name + ": ONOS timeout" )
Jon Halld4d4b372015-01-28 16:02:41 -08002462 return None
andrewonlab87852b02014-11-19 18:44:19 -05002463 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002464 main.log.error( self.name + ": EOF exception found" )
2465 main.log.error( self.name + ": " + self.handle.before )
andrewonlab87852b02014-11-19 18:44:19 -05002466 main.cleanup()
2467 main.exit()
GlennRCed771242016-01-13 17:02:47 -08002468 except TypeError:
2469 main.log.exception( self.name + ": Object not as expected" )
Jon Hallc6793552016-01-19 14:18:37 -08002470 return None
Jon Hallfebb1c72015-03-05 13:30:09 -08002471 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002472 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab87852b02014-11-19 18:44:19 -05002473 main.cleanup()
2474 main.exit()
2475
YPZhangebf9eb52016-05-12 15:20:24 -07002476 def getTotalFlowsNum( self, timeout=60, noExit=False ):
YPZhangb5d3f832016-01-23 22:54:26 -08002477 """
2478 Description:
YPZhangf6f14a02016-01-28 15:17:31 -08002479 Get the number of ADDED flows.
YPZhangb5d3f832016-01-23 22:54:26 -08002480 Return:
YPZhangf6f14a02016-01-28 15:17:31 -08002481 The number of ADDED flows
YPZhang14a4aa92016-07-15 13:37:15 -07002482 Or return None if any exceptions
YPZhangb5d3f832016-01-23 22:54:26 -08002483 """
YPZhange3109a72016-02-02 11:25:37 -08002484
YPZhangb5d3f832016-01-23 22:54:26 -08002485 try:
YPZhange3109a72016-02-02 11:25:37 -08002486 # get total added flows number
YPZhang14a4aa92016-07-15 13:37:15 -07002487 cmd = "flows -c added"
2488 rawFlows = self.sendline( cmd, timeout=timeout, noExit=noExit )
2489 if rawFlows:
2490 rawFlows = rawFlows.split("\n")
YPZhange3109a72016-02-02 11:25:37 -08002491 totalFlows = 0
YPZhang14a4aa92016-07-15 13:37:15 -07002492 for l in rawFlows:
2493 totalFlows += int(l.split("Count=")[1])
2494 else:
2495 main.log.error("Response not as expected!")
2496 return None
2497 return totalFlows
YPZhange3109a72016-02-02 11:25:37 -08002498
You Wangd3cb2ce2016-05-16 14:01:24 -07002499 except ( TypeError, ValueError ):
YPZhang14a4aa92016-07-15 13:37:15 -07002500 main.log.exception( "{}: Object not as expected!".format( self.name ) )
YPZhangb5d3f832016-01-23 22:54:26 -08002501 return None
2502 except pexpect.EOF:
2503 main.log.error( self.name + ": EOF exception found" )
2504 main.log.error( self.name + ": " + self.handle.before )
YPZhang14a4aa92016-07-15 13:37:15 -07002505 if not noExit:
2506 main.cleanup()
2507 main.exit()
2508 return None
YPZhangb5d3f832016-01-23 22:54:26 -08002509 except Exception:
2510 main.log.exception( self.name + ": Uncaught exception!" )
YPZhang14a4aa92016-07-15 13:37:15 -07002511 if not noExit:
2512 main.cleanup()
2513 main.exit()
2514 return None
YPZhangebf9eb52016-05-12 15:20:24 -07002515 except pexpect.TIMEOUT:
2516 main.log.error( self.name + ": ONOS timeout" )
2517 return None
YPZhangb5d3f832016-01-23 22:54:26 -08002518
YPZhang14a4aa92016-07-15 13:37:15 -07002519 def getTotalIntentsNum( self, timeout=60, noExit = False ):
YPZhangb5d3f832016-01-23 22:54:26 -08002520 """
2521 Description:
2522 Get the total number of intents, include every states.
YPZhang14a4aa92016-07-15 13:37:15 -07002523 Optional:
2524 noExit - If noExit, TestON will not exit if any except.
YPZhangb5d3f832016-01-23 22:54:26 -08002525 Return:
2526 The number of intents
2527 """
2528 try:
2529 cmd = "summary -j"
YPZhang14a4aa92016-07-15 13:37:15 -07002530 response = self.sendline( cmd, timeout=timeout, noExit=noExit )
YPZhangb5d3f832016-01-23 22:54:26 -08002531 if response == None:
2532 return -1
2533 response = json.loads( response )
2534 return int( response.get("intents") )
You Wangd3cb2ce2016-05-16 14:01:24 -07002535 except ( TypeError, ValueError ):
2536 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, response ) )
YPZhangb5d3f832016-01-23 22:54:26 -08002537 return None
2538 except pexpect.EOF:
2539 main.log.error( self.name + ": EOF exception found" )
2540 main.log.error( self.name + ": " + self.handle.before )
YPZhang14a4aa92016-07-15 13:37:15 -07002541 if noExit:
2542 return -1
2543 else:
2544 main.cleanup()
2545 main.exit()
YPZhangb5d3f832016-01-23 22:54:26 -08002546 except Exception:
2547 main.log.exception( self.name + ": Uncaught exception!" )
YPZhang14a4aa92016-07-15 13:37:15 -07002548 if noExit:
2549 return -1
2550 else:
2551 main.cleanup()
2552 main.exit()
YPZhangb5d3f832016-01-23 22:54:26 -08002553
kelvin-onlabd3b64892015-01-20 13:26:24 -08002554 def intentsEventsMetrics( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -08002555 """
Jon Halle3f39ff2015-01-13 11:50:53 -08002556 Description:Returns topology metrics
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002557 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002558 * jsonFormat: enable json formatting of output
kelvin8ec71442015-01-15 16:57:00 -08002559 """
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002560 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002561 cmdStr = "intents-events-metrics"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002562 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002563 cmdStr += " -j"
2564 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002565 assert "Command not found:" not in handle, handle
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002566 return handle
Jon Hallc6793552016-01-19 14:18:37 -08002567 except AssertionError:
2568 main.log.exception( "" )
2569 return None
Jon Halld4d4b372015-01-28 16:02:41 -08002570 except TypeError:
2571 main.log.exception( self.name + ": Object not as expected" )
2572 return None
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002573 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002574 main.log.error( self.name + ": EOF exception found" )
2575 main.log.error( self.name + ": " + self.handle.before )
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002576 main.cleanup()
2577 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002578 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002579 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002580 main.cleanup()
2581 main.exit()
Shreya Shah0f01c812014-10-26 20:15:28 -04002582
kelvin-onlabd3b64892015-01-20 13:26:24 -08002583 def topologyEventsMetrics( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -08002584 """
2585 Description:Returns topology metrics
andrewonlab867212a2014-10-22 20:13:38 -04002586 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002587 * jsonFormat: enable json formatting of output
kelvin8ec71442015-01-15 16:57:00 -08002588 """
andrewonlab867212a2014-10-22 20:13:38 -04002589 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002590 cmdStr = "topology-events-metrics"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002591 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002592 cmdStr += " -j"
2593 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002594 assert "Command not found:" not in handle, handle
jenkins7ead5a82015-03-13 10:28:21 -07002595 if handle:
2596 return handle
Jon Hallc6358dd2015-04-10 12:44:28 -07002597 elif jsonFormat:
Jon Hallbe379602015-03-24 13:39:32 -07002598 # Return empty json
jenkins7ead5a82015-03-13 10:28:21 -07002599 return '{}'
Jon Hallc6358dd2015-04-10 12:44:28 -07002600 else:
2601 return handle
Jon Hallc6793552016-01-19 14:18:37 -08002602 except AssertionError:
2603 main.log.exception( "" )
2604 return None
Jon Halld4d4b372015-01-28 16:02:41 -08002605 except TypeError:
2606 main.log.exception( self.name + ": Object not as expected" )
2607 return None
andrewonlab867212a2014-10-22 20:13:38 -04002608 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002609 main.log.error( self.name + ": EOF exception found" )
2610 main.log.error( self.name + ": " + self.handle.before )
andrewonlab867212a2014-10-22 20:13:38 -04002611 main.cleanup()
2612 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002613 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002614 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab867212a2014-10-22 20:13:38 -04002615 main.cleanup()
2616 main.exit()
2617
kelvin8ec71442015-01-15 16:57:00 -08002618 # Wrapper functions ****************
2619 # Wrapper functions use existing driver
2620 # functions and extends their use case.
2621 # For example, we may use the output of
2622 # a normal driver function, and parse it
2623 # using a wrapper function
andrewonlabc2d05aa2014-10-13 16:51:10 -04002624
kelvin-onlabd3b64892015-01-20 13:26:24 -08002625 def getAllIntentsId( self ):
kelvin8ec71442015-01-15 16:57:00 -08002626 """
andrewonlab9a50dfe2014-10-17 17:22:31 -04002627 Description:
2628 Obtain all intent id's in a list
kelvin8ec71442015-01-15 16:57:00 -08002629 """
andrewonlab9a50dfe2014-10-17 17:22:31 -04002630 try:
kelvin8ec71442015-01-15 16:57:00 -08002631 # Obtain output of intents function
kelvin-onlabfb521662015-02-27 09:52:40 -08002632 intentsStr = self.intents(jsonFormat=False)
kelvin-onlabd3b64892015-01-20 13:26:24 -08002633 intentIdList = []
andrewonlab9a50dfe2014-10-17 17:22:31 -04002634
kelvin8ec71442015-01-15 16:57:00 -08002635 # Parse the intents output for ID's
kelvin-onlabd3b64892015-01-20 13:26:24 -08002636 intentsList = [ s.strip() for s in intentsStr.splitlines() ]
2637 for intents in intentsList:
kelvin-onlabfb521662015-02-27 09:52:40 -08002638 match = re.search('id=0x([\da-f]+),', intents)
2639 if match:
2640 tmpId = match.group()[3:-1]
2641 intentIdList.append( tmpId )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002642 return intentIdList
andrewonlab9a50dfe2014-10-17 17:22:31 -04002643
Jon Halld4d4b372015-01-28 16:02:41 -08002644 except TypeError:
2645 main.log.exception( self.name + ": Object not as expected" )
2646 return None
andrewonlab9a50dfe2014-10-17 17:22:31 -04002647 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002648 main.log.error( self.name + ": EOF exception found" )
2649 main.log.error( self.name + ": " + self.handle.before )
andrewonlab9a50dfe2014-10-17 17:22:31 -04002650 main.cleanup()
2651 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002652 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002653 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab9a50dfe2014-10-17 17:22:31 -04002654 main.cleanup()
2655 main.exit()
2656
Jon Hall30b82fa2015-03-04 17:15:43 -08002657 def FlowAddedCount( self, deviceId ):
2658 """
2659 Determine the number of flow rules for the given device id that are
2660 in the added state
2661 """
2662 try:
2663 cmdStr = "flows any " + str( deviceId ) + " | " +\
2664 "grep 'state=ADDED' | wc -l"
2665 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002666 assert "Command not found:" not in handle, handle
Jon Hall30b82fa2015-03-04 17:15:43 -08002667 return handle
Jon Hallc6793552016-01-19 14:18:37 -08002668 except AssertionError:
2669 main.log.exception( "" )
2670 return None
Jon Hall30b82fa2015-03-04 17:15:43 -08002671 except pexpect.EOF:
2672 main.log.error( self.name + ": EOF exception found" )
2673 main.log.error( self.name + ": " + self.handle.before )
2674 main.cleanup()
2675 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002676 except Exception:
Jon Hall30b82fa2015-03-04 17:15:43 -08002677 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ce8322014-10-13 14:12:04 -04002678 main.cleanup()
2679 main.exit()
2680
kelvin-onlabd3b64892015-01-20 13:26:24 -08002681 def getAllDevicesId( self ):
kelvin8ec71442015-01-15 16:57:00 -08002682 """
andrewonlab7e4d2d32014-10-15 13:23:21 -04002683 Use 'devices' function to obtain list of all devices
2684 and parse the result to obtain a list of all device
2685 id's. Returns this list. Returns empty list if no
2686 devices exist
kelvin8ec71442015-01-15 16:57:00 -08002687 List is ordered sequentially
2688
andrewonlab3e15ead2014-10-15 14:21:34 -04002689 This function may be useful if you are not sure of the
kelvin8ec71442015-01-15 16:57:00 -08002690 device id, and wish to execute other commands using
andrewonlab3e15ead2014-10-15 14:21:34 -04002691 the ids. By obtaining the list of device ids on the fly,
2692 you can iterate through the list to get mastership, etc.
kelvin8ec71442015-01-15 16:57:00 -08002693 """
andrewonlab7e4d2d32014-10-15 13:23:21 -04002694 try:
kelvin8ec71442015-01-15 16:57:00 -08002695 # Call devices and store result string
kelvin-onlabd3b64892015-01-20 13:26:24 -08002696 devicesStr = self.devices( jsonFormat=False )
2697 idList = []
kelvin8ec71442015-01-15 16:57:00 -08002698
kelvin-onlabd3b64892015-01-20 13:26:24 -08002699 if not devicesStr:
kelvin8ec71442015-01-15 16:57:00 -08002700 main.log.info( "There are no devices to get id from" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002701 return idList
kelvin8ec71442015-01-15 16:57:00 -08002702
2703 # Split the string into list by comma
kelvin-onlabd3b64892015-01-20 13:26:24 -08002704 deviceList = devicesStr.split( "," )
kelvin8ec71442015-01-15 16:57:00 -08002705 # Get temporary list of all arguments with string 'id='
kelvin-onlabd3b64892015-01-20 13:26:24 -08002706 tempList = [ dev for dev in deviceList if "id=" in dev ]
kelvin8ec71442015-01-15 16:57:00 -08002707 # Split list further into arguments before and after string
2708 # 'id='. Get the latter portion ( the actual device id ) and
kelvin-onlabd3b64892015-01-20 13:26:24 -08002709 # append to idList
2710 for arg in tempList:
2711 idList.append( arg.split( "id=" )[ 1 ] )
2712 return idList
andrewonlab7e4d2d32014-10-15 13:23:21 -04002713
Jon Halld4d4b372015-01-28 16:02:41 -08002714 except TypeError:
2715 main.log.exception( self.name + ": Object not as expected" )
2716 return None
andrewonlab7e4d2d32014-10-15 13:23:21 -04002717 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002718 main.log.error( self.name + ": EOF exception found" )
2719 main.log.error( self.name + ": " + self.handle.before )
andrewonlab7e4d2d32014-10-15 13:23:21 -04002720 main.cleanup()
2721 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002722 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002723 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab7e4d2d32014-10-15 13:23:21 -04002724 main.cleanup()
2725 main.exit()
2726
kelvin-onlabd3b64892015-01-20 13:26:24 -08002727 def getAllNodesId( self ):
kelvin8ec71442015-01-15 16:57:00 -08002728 """
andrewonlab7c211572014-10-15 16:45:20 -04002729 Uses 'nodes' function to obtain list of all nodes
2730 and parse the result of nodes to obtain just the
kelvin8ec71442015-01-15 16:57:00 -08002731 node id's.
andrewonlab7c211572014-10-15 16:45:20 -04002732 Returns:
2733 list of node id's
kelvin8ec71442015-01-15 16:57:00 -08002734 """
andrewonlab7c211572014-10-15 16:45:20 -04002735 try:
Jon Hall5aa168b2015-03-23 14:23:09 -07002736 nodesStr = self.nodes( jsonFormat=True )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002737 idList = []
Jon Hall5aa168b2015-03-23 14:23:09 -07002738 # Sample nodesStr output
Jon Hallbd182782016-03-28 16:42:22 -07002739 # id=local, address=127.0.0.1:9876, state=READY *
kelvin-onlabd3b64892015-01-20 13:26:24 -08002740 if not nodesStr:
kelvin8ec71442015-01-15 16:57:00 -08002741 main.log.info( "There are no nodes to get id from" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002742 return idList
Jon Hall5aa168b2015-03-23 14:23:09 -07002743 nodesJson = json.loads( nodesStr )
2744 idList = [ node.get('id') for node in nodesJson ]
kelvin-onlabd3b64892015-01-20 13:26:24 -08002745 return idList
Jon Hallc6793552016-01-19 14:18:37 -08002746 except ( TypeError, ValueError ):
2747 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, nodesStr ) )
Jon Halld4d4b372015-01-28 16:02:41 -08002748 return None
andrewonlab7c211572014-10-15 16:45:20 -04002749 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002750 main.log.error( self.name + ": EOF exception found" )
2751 main.log.error( self.name + ": " + self.handle.before )
andrewonlab7c211572014-10-15 16:45:20 -04002752 main.cleanup()
2753 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002754 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002755 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab7c211572014-10-15 16:45:20 -04002756 main.cleanup()
2757 main.exit()
andrewonlab7e4d2d32014-10-15 13:23:21 -04002758
kelvin-onlabd3b64892015-01-20 13:26:24 -08002759 def getDevice( self, dpid=None ):
kelvin8ec71442015-01-15 16:57:00 -08002760 """
Jon Halla91c4dc2014-10-22 12:57:04 -04002761 Return the first device from the devices api whose 'id' contains 'dpid'
2762 Return None if there is no match
kelvin8ec71442015-01-15 16:57:00 -08002763 """
Jon Halla91c4dc2014-10-22 12:57:04 -04002764 try:
kelvin8ec71442015-01-15 16:57:00 -08002765 if dpid is None:
Jon Halla91c4dc2014-10-22 12:57:04 -04002766 return None
2767 else:
kelvin8ec71442015-01-15 16:57:00 -08002768 dpid = dpid.replace( ':', '' )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002769 rawDevices = self.devices()
2770 devicesJson = json.loads( rawDevices )
kelvin8ec71442015-01-15 16:57:00 -08002771 # search json for the device with dpid then return the device
kelvin-onlabd3b64892015-01-20 13:26:24 -08002772 for device in devicesJson:
kelvin8ec71442015-01-15 16:57:00 -08002773 # print "%s in %s?" % ( dpid, device[ 'id' ] )
2774 if dpid in device[ 'id' ]:
Jon Halla91c4dc2014-10-22 12:57:04 -04002775 return device
2776 return None
Jon Hallc6793552016-01-19 14:18:37 -08002777 except ( TypeError, ValueError ):
2778 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, rawDevices ) )
Jon Halld4d4b372015-01-28 16:02:41 -08002779 return None
Jon Halla91c4dc2014-10-22 12:57:04 -04002780 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002781 main.log.error( self.name + ": EOF exception found" )
2782 main.log.error( self.name + ": " + self.handle.before )
Jon Halla91c4dc2014-10-22 12:57:04 -04002783 main.cleanup()
2784 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002785 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002786 main.log.exception( self.name + ": Uncaught exception!" )
Jon Halla91c4dc2014-10-22 12:57:04 -04002787 main.cleanup()
2788 main.exit()
2789
You Wang24139872016-05-03 11:48:47 -07002790 def getTopology( self, topologyOutput ):
2791 """
2792 Definition:
2793 Loads a json topology output
2794 Return:
2795 topology = current ONOS topology
2796 """
2797 import json
2798 try:
2799 # either onos:topology or 'topology' will work in CLI
2800 topology = json.loads(topologyOutput)
Jeremy Songsterbc2d8ac2016-05-04 11:25:42 -07002801 main.log.debug( topology )
You Wang24139872016-05-03 11:48:47 -07002802 return topology
You Wangd3cb2ce2016-05-16 14:01:24 -07002803 except ( TypeError, ValueError ):
2804 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, topologyOutput ) )
2805 return None
You Wang24139872016-05-03 11:48:47 -07002806 except pexpect.EOF:
2807 main.log.error( self.name + ": EOF exception found" )
2808 main.log.error( self.name + ": " + self.handle.before )
2809 main.cleanup()
2810 main.exit()
2811 except Exception:
2812 main.log.exception( self.name + ": Uncaught exception!" )
2813 main.cleanup()
2814 main.exit()
2815
Flavio Castro82ee2f62016-06-07 15:04:12 -07002816 def checkStatus(self, numoswitch, numolink, numoctrl = -1, logLevel="info"):
kelvin8ec71442015-01-15 16:57:00 -08002817 """
Jon Hallefbd9792015-03-05 16:11:36 -08002818 Checks the number of switches & links that ONOS sees against the
kelvin8ec71442015-01-15 16:57:00 -08002819 supplied values. By default this will report to main.log, but the
You Wang24139872016-05-03 11:48:47 -07002820 log level can be specific.
kelvin8ec71442015-01-15 16:57:00 -08002821
Flavio Castro82ee2f62016-06-07 15:04:12 -07002822 Params: numoswitch = expected number of switches
Jon Hallefbd9792015-03-05 16:11:36 -08002823 numolink = expected number of links
Flavio Castro82ee2f62016-06-07 15:04:12 -07002824 numoctrl = expected number of controllers
You Wang24139872016-05-03 11:48:47 -07002825 logLevel = level to log to.
2826 Currently accepts 'info', 'warn' and 'report'
Jon Hall42db6dc2014-10-24 19:03:48 -04002827
Jon Hallefbd9792015-03-05 16:11:36 -08002828 Returns: main.TRUE if the number of switches and links are correct,
2829 main.FALSE if the number of switches and links is incorrect,
Jon Hall42db6dc2014-10-24 19:03:48 -04002830 and main.ERROR otherwise
kelvin8ec71442015-01-15 16:57:00 -08002831 """
Flavio Castro82ee2f62016-06-07 15:04:12 -07002832 import json
Jon Hall42db6dc2014-10-24 19:03:48 -04002833 try:
You Wang13310252016-07-31 10:56:14 -07002834 summary = self.summary()
2835 summary = json.loads( summary )
Flavio Castrof5b3f872016-06-23 17:52:31 -07002836 except ( TypeError, ValueError ):
2837 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, summary ) )
2838 return main.ERROR
2839 try:
2840 topology = self.getTopology( self.topology() )
Flavio Castro82ee2f62016-06-07 15:04:12 -07002841 if topology == {} or topology == None or summary == {} or summary == None:
Jon Hall42db6dc2014-10-24 19:03:48 -04002842 return main.ERROR
2843 output = ""
kelvin8ec71442015-01-15 16:57:00 -08002844 # Is the number of switches is what we expected
2845 devices = topology.get( 'devices', False )
2846 links = topology.get( 'links', False )
Flavio Castro82ee2f62016-06-07 15:04:12 -07002847 nodes = summary.get( 'nodes', False )
2848 if devices is False or links is False or nodes is False:
Jon Hall42db6dc2014-10-24 19:03:48 -04002849 return main.ERROR
kelvin-onlabd3b64892015-01-20 13:26:24 -08002850 switchCheck = ( int( devices ) == int( numoswitch ) )
kelvin8ec71442015-01-15 16:57:00 -08002851 # Is the number of links is what we expected
kelvin-onlabd3b64892015-01-20 13:26:24 -08002852 linkCheck = ( int( links ) == int( numolink ) )
Flavio Castro82ee2f62016-06-07 15:04:12 -07002853 nodeCheck = ( int( nodes ) == int( numoctrl ) ) or int( numoctrl ) == -1
2854 if switchCheck and linkCheck and nodeCheck:
kelvin8ec71442015-01-15 16:57:00 -08002855 # We expected the correct numbers
You Wang24139872016-05-03 11:48:47 -07002856 output = output + "The number of links and switches match "\
2857 + "what was expected"
Jon Hall42db6dc2014-10-24 19:03:48 -04002858 result = main.TRUE
2859 else:
You Wang24139872016-05-03 11:48:47 -07002860 output = output + \
2861 "The number of links and switches does not match " + \
2862 "what was expected"
Jon Hall42db6dc2014-10-24 19:03:48 -04002863 result = main.FALSE
You Wang24139872016-05-03 11:48:47 -07002864 output = output + "\n ONOS sees %i devices" % int( devices )
2865 output = output + " (%i expected) " % int( numoswitch )
2866 output = output + "and %i links " % int( links )
2867 output = output + "(%i expected)" % int( numolink )
YPZhangd7e4b6e2016-06-17 16:07:55 -07002868 if int( numoctrl ) > 0:
Flavio Castro82ee2f62016-06-07 15:04:12 -07002869 output = output + "and %i controllers " % int( nodes )
2870 output = output + "(%i expected)" % int( numoctrl )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002871 if logLevel == "report":
kelvin8ec71442015-01-15 16:57:00 -08002872 main.log.report( output )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002873 elif logLevel == "warn":
kelvin8ec71442015-01-15 16:57:00 -08002874 main.log.warn( output )
Jon Hall42db6dc2014-10-24 19:03:48 -04002875 else:
You Wang24139872016-05-03 11:48:47 -07002876 main.log.info( output )
kelvin8ec71442015-01-15 16:57:00 -08002877 return result
Jon Hall42db6dc2014-10-24 19:03:48 -04002878 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002879 main.log.error( self.name + ": EOF exception found" )
2880 main.log.error( self.name + ": " + self.handle.before )
Jon Hall42db6dc2014-10-24 19:03:48 -04002881 main.cleanup()
2882 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002883 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002884 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall42db6dc2014-10-24 19:03:48 -04002885 main.cleanup()
2886 main.exit()
Jon Hall1c9e8732014-10-27 19:29:27 -04002887
kelvin-onlabd3b64892015-01-20 13:26:24 -08002888 def deviceRole( self, deviceId, onosNode, role="master" ):
kelvin8ec71442015-01-15 16:57:00 -08002889 """
Jon Hall1c9e8732014-10-27 19:29:27 -04002890 Calls the device-role cli command.
kelvin-onlabd3b64892015-01-20 13:26:24 -08002891 deviceId must be the id of a device as seen in the onos devices command
2892 onosNode is the ip of one of the onos nodes in the cluster
Jon Hall1c9e8732014-10-27 19:29:27 -04002893 role must be either master, standby, or none
2894
Jon Halle3f39ff2015-01-13 11:50:53 -08002895 Returns:
2896 main.TRUE or main.FALSE based on argument verification and
2897 main.ERROR if command returns and error
kelvin-onlab898a6c62015-01-16 14:13:53 -08002898 """
Jon Hall1c9e8732014-10-27 19:29:27 -04002899 try:
Jon Halle3f39ff2015-01-13 11:50:53 -08002900 if role.lower() == "master" or role.lower() == "standby" or\
Jon Hall1c9e8732014-10-27 19:29:27 -04002901 role.lower() == "none":
kelvin-onlabd3b64892015-01-20 13:26:24 -08002902 cmdStr = "device-role " +\
2903 str( deviceId ) + " " +\
2904 str( onosNode ) + " " +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08002905 str( role )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002906 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002907 assert "Command not found:" not in handle, handle
kelvin-onlab898a6c62015-01-16 14:13:53 -08002908 if re.search( "Error", handle ):
2909 # end color output to escape any colours
2910 # from the cli
kelvin8ec71442015-01-15 16:57:00 -08002911 main.log.error( self.name + ": " +
kelvin-onlab898a6c62015-01-16 14:13:53 -08002912 handle + '\033[0m' )
kelvin8ec71442015-01-15 16:57:00 -08002913 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -08002914 return main.TRUE
Jon Hall1c9e8732014-10-27 19:29:27 -04002915 else:
kelvin-onlab898a6c62015-01-16 14:13:53 -08002916 main.log.error( "Invalid 'role' given to device_role(). " +
2917 "Value was '" + str(role) + "'." )
Jon Hall1c9e8732014-10-27 19:29:27 -04002918 return main.FALSE
Jon Hallc6793552016-01-19 14:18:37 -08002919 except AssertionError:
2920 main.log.exception( "" )
2921 return None
Jon Halld4d4b372015-01-28 16:02:41 -08002922 except TypeError:
2923 main.log.exception( self.name + ": Object not as expected" )
2924 return None
Jon Hall1c9e8732014-10-27 19:29:27 -04002925 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002926 main.log.error( self.name + ": EOF exception found" )
2927 main.log.error( self.name + ": " + self.handle.before )
Jon Hall1c9e8732014-10-27 19:29:27 -04002928 main.cleanup()
2929 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002930 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002931 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall1c9e8732014-10-27 19:29:27 -04002932 main.cleanup()
2933 main.exit()
2934
kelvin-onlabd3b64892015-01-20 13:26:24 -08002935 def clusters( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -08002936 """
Jon Hall73cf9cc2014-11-20 22:28:38 -08002937 Lists all clusters
Jon Hallffb386d2014-11-21 13:43:38 -08002938 Optional argument:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002939 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -08002940 """
Jon Hall73cf9cc2014-11-20 22:28:38 -08002941 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002942 cmdStr = "clusters"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002943 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002944 cmdStr += " -j"
2945 handle = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002946 assert "Command not found:" not in handle, handle
Jon Hallc6358dd2015-04-10 12:44:28 -07002947 return handle
Jon Hallc6793552016-01-19 14:18:37 -08002948 except AssertionError:
2949 main.log.exception( "" )
2950 return None
Jon Halld4d4b372015-01-28 16:02:41 -08002951 except TypeError:
2952 main.log.exception( self.name + ": Object not as expected" )
2953 return None
Jon Hall73cf9cc2014-11-20 22:28:38 -08002954 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002955 main.log.error( self.name + ": EOF exception found" )
2956 main.log.error( self.name + ": " + self.handle.before )
Jon Hall73cf9cc2014-11-20 22:28:38 -08002957 main.cleanup()
2958 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002959 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002960 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall73cf9cc2014-11-20 22:28:38 -08002961 main.cleanup()
2962 main.exit()
2963
kelvin-onlabd3b64892015-01-20 13:26:24 -08002964 def electionTestLeader( self ):
kelvin-onlab898a6c62015-01-16 14:13:53 -08002965 """
Jon Halle3f39ff2015-01-13 11:50:53 -08002966 CLI command to get the current leader for the Election test application
2967 NOTE: Requires installation of the onos-app-election feature
2968 Returns: Node IP of the leader if one exists
2969 None if none exists
2970 Main.FALSE on error
kelvin-onlab898a6c62015-01-16 14:13:53 -08002971 """
Jon Hall94fd0472014-12-08 11:52:42 -08002972 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002973 cmdStr = "election-test-leader"
2974 response = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08002975 assert "Command not found:" not in response, response
Jon Halle3f39ff2015-01-13 11:50:53 -08002976 # Leader
2977 leaderPattern = "The\scurrent\sleader\sfor\sthe\sElection\s" +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08002978 "app\sis\s(?P<node>.+)\."
kelvin-onlabd3b64892015-01-20 13:26:24 -08002979 nodeSearch = re.search( leaderPattern, response )
2980 if nodeSearch:
2981 node = nodeSearch.group( 'node' )
Jon Halle3f39ff2015-01-13 11:50:53 -08002982 main.log.info( "Election-test-leader on " + str( self.name ) +
kelvin-onlab898a6c62015-01-16 14:13:53 -08002983 " found " + node + " as the leader" )
Jon Hall94fd0472014-12-08 11:52:42 -08002984 return node
Jon Halle3f39ff2015-01-13 11:50:53 -08002985 # no leader
2986 nullPattern = "There\sis\scurrently\sno\sleader\selected\sfor\s" +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08002987 "the\sElection\sapp"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002988 nullSearch = re.search( nullPattern, response )
2989 if nullSearch:
Jon Halle3f39ff2015-01-13 11:50:53 -08002990 main.log.info( "Election-test-leader found no leader on " +
kelvin-onlab898a6c62015-01-16 14:13:53 -08002991 self.name )
Jon Hall94fd0472014-12-08 11:52:42 -08002992 return None
kelvin-onlab898a6c62015-01-16 14:13:53 -08002993 # error
Jon Hall97cf84a2016-06-20 13:35:58 -07002994 main.log.error( "Error in electionTestLeader on " + self.name +
2995 ": " + "unexpected response" )
2996 main.log.error( repr( response ) )
2997 return main.FALSE
Jon Hallc6793552016-01-19 14:18:37 -08002998 except AssertionError:
2999 main.log.exception( "" )
3000 return None
Jon Halld4d4b372015-01-28 16:02:41 -08003001 except TypeError:
3002 main.log.exception( self.name + ": Object not as expected" )
3003 return main.FALSE
Jon Hall94fd0472014-12-08 11:52:42 -08003004 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08003005 main.log.error( self.name + ": EOF exception found" )
3006 main.log.error( self.name + ": " + self.handle.before )
Jon Hall94fd0472014-12-08 11:52:42 -08003007 main.cleanup()
3008 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003009 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08003010 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall94fd0472014-12-08 11:52:42 -08003011 main.cleanup()
3012 main.exit()
3013
kelvin-onlabd3b64892015-01-20 13:26:24 -08003014 def electionTestRun( self ):
kelvin-onlab898a6c62015-01-16 14:13:53 -08003015 """
Jon Halle3f39ff2015-01-13 11:50:53 -08003016 CLI command to run for leadership of the Election test application.
3017 NOTE: Requires installation of the onos-app-election feature
3018 Returns: Main.TRUE on success
3019 Main.FALSE on error
kelvin-onlab898a6c62015-01-16 14:13:53 -08003020 """
Jon Hall94fd0472014-12-08 11:52:42 -08003021 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08003022 cmdStr = "election-test-run"
3023 response = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08003024 assert "Command not found:" not in response, response
kelvin-onlab898a6c62015-01-16 14:13:53 -08003025 # success
Jon Halle3f39ff2015-01-13 11:50:53 -08003026 successPattern = "Entering\sleadership\selections\sfor\sthe\s" +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08003027 "Election\sapp."
Jon Halle3f39ff2015-01-13 11:50:53 -08003028 search = re.search( successPattern, response )
Jon Hall94fd0472014-12-08 11:52:42 -08003029 if search:
Jon Halle3f39ff2015-01-13 11:50:53 -08003030 main.log.info( self.name + " entering leadership elections " +
kelvin-onlab898a6c62015-01-16 14:13:53 -08003031 "for the Election app." )
Jon Hall94fd0472014-12-08 11:52:42 -08003032 return main.TRUE
kelvin-onlab898a6c62015-01-16 14:13:53 -08003033 # error
Jon Hall97cf84a2016-06-20 13:35:58 -07003034 main.log.error( "Error in electionTestRun on " + self.name +
3035 ": " + "unexpected response" )
3036 main.log.error( repr( response ) )
3037 return main.FALSE
Jon Hallc6793552016-01-19 14:18:37 -08003038 except AssertionError:
3039 main.log.exception( "" )
3040 return None
Jon Halld4d4b372015-01-28 16:02:41 -08003041 except TypeError:
3042 main.log.exception( self.name + ": Object not as expected" )
3043 return main.FALSE
Jon Hall94fd0472014-12-08 11:52:42 -08003044 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08003045 main.log.error( self.name + ": EOF exception found" )
3046 main.log.error( self.name + ": " + self.handle.before )
Jon Hall94fd0472014-12-08 11:52:42 -08003047 main.cleanup()
3048 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003049 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08003050 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall94fd0472014-12-08 11:52:42 -08003051 main.cleanup()
3052 main.exit()
3053
kelvin-onlabd3b64892015-01-20 13:26:24 -08003054 def electionTestWithdraw( self ):
kelvin8ec71442015-01-15 16:57:00 -08003055 """
Jon Hall94fd0472014-12-08 11:52:42 -08003056 * CLI command to withdraw the local node from leadership election for
3057 * the Election test application.
3058 #NOTE: Requires installation of the onos-app-election feature
3059 Returns: Main.TRUE on success
3060 Main.FALSE on error
kelvin8ec71442015-01-15 16:57:00 -08003061 """
Jon Hall94fd0472014-12-08 11:52:42 -08003062 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08003063 cmdStr = "election-test-withdraw"
3064 response = self.sendline( cmdStr )
Jon Hallc6793552016-01-19 14:18:37 -08003065 assert "Command not found:" not in response, response
kelvin-onlab898a6c62015-01-16 14:13:53 -08003066 # success
Jon Halle3f39ff2015-01-13 11:50:53 -08003067 successPattern = "Withdrawing\sfrom\sleadership\selections\sfor" +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08003068 "\sthe\sElection\sapp."
Jon Halle3f39ff2015-01-13 11:50:53 -08003069 if re.search( successPattern, response ):
3070 main.log.info( self.name + " withdrawing from leadership " +
kelvin-onlab898a6c62015-01-16 14:13:53 -08003071 "elections for the Election app." )
Jon Hall94fd0472014-12-08 11:52:42 -08003072 return main.TRUE
kelvin-onlab898a6c62015-01-16 14:13:53 -08003073 # error
Jon Hall97cf84a2016-06-20 13:35:58 -07003074 main.log.error( "Error in electionTestWithdraw on " +
3075 self.name + ": " + "unexpected response" )
3076 main.log.error( repr( response ) )
3077 return main.FALSE
Jon Hallc6793552016-01-19 14:18:37 -08003078 except AssertionError:
3079 main.log.exception( "" )
3080 return None
Jon Halld4d4b372015-01-28 16:02:41 -08003081 except TypeError:
3082 main.log.exception( self.name + ": Object not as expected" )
3083 return main.FALSE
Jon Hall94fd0472014-12-08 11:52:42 -08003084 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08003085 main.log.error( self.name + ": EOF exception found" )
3086 main.log.error( self.name + ": " + self.handle.before )
Jon Hall94fd0472014-12-08 11:52:42 -08003087 main.cleanup()
3088 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003089 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08003090 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall94fd0472014-12-08 11:52:42 -08003091 main.cleanup()
3092 main.exit()
Jon Hall1c9e8732014-10-27 19:29:27 -04003093
kelvin8ec71442015-01-15 16:57:00 -08003094 def getDevicePortsEnabledCount( self, dpid ):
3095 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003096 Get the count of all enabled ports on a particular device/switch
kelvin8ec71442015-01-15 16:57:00 -08003097 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003098 try:
Jon Halle3f39ff2015-01-13 11:50:53 -08003099 dpid = str( dpid )
kelvin-onlabd3b64892015-01-20 13:26:24 -08003100 cmdStr = "onos:ports -e " + dpid + " | wc -l"
3101 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003102 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003103 assert "Command not found:" not in output, output
Jon Halle3f39ff2015-01-13 11:50:53 -08003104 if re.search( "No such device", output ):
3105 main.log.error( "Error in getting ports" )
3106 return ( output, "Error" )
Jon Halla495f562016-05-16 18:03:26 -07003107 return output
Jon Hallc6793552016-01-19 14:18:37 -08003108 except AssertionError:
3109 main.log.exception( "" )
3110 return None
Jon Halld4d4b372015-01-28 16:02:41 -08003111 except TypeError:
3112 main.log.exception( self.name + ": Object not as expected" )
3113 return ( output, "Error" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003114 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08003115 main.log.error( self.name + ": EOF exception found" )
3116 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003117 main.cleanup()
3118 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003119 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08003120 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003121 main.cleanup()
3122 main.exit()
3123
kelvin8ec71442015-01-15 16:57:00 -08003124 def getDeviceLinksActiveCount( self, dpid ):
3125 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003126 Get the count of all enabled ports on a particular device/switch
kelvin8ec71442015-01-15 16:57:00 -08003127 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003128 try:
kelvin-onlab898a6c62015-01-16 14:13:53 -08003129 dpid = str( dpid )
kelvin-onlabd3b64892015-01-20 13:26:24 -08003130 cmdStr = "onos:links " + dpid + " | grep ACTIVE | wc -l"
3131 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003132 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003133 assert "Command not found:" not in output, output
Jon Halle3f39ff2015-01-13 11:50:53 -08003134 if re.search( "No such device", output ):
kelvin-onlab898a6c62015-01-16 14:13:53 -08003135 main.log.error( "Error in getting ports " )
3136 return ( output, "Error " )
Jon Halla495f562016-05-16 18:03:26 -07003137 return output
Jon Hallc6793552016-01-19 14:18:37 -08003138 except AssertionError:
3139 main.log.exception( "" )
3140 return None
Jon Halld4d4b372015-01-28 16:02:41 -08003141 except TypeError:
3142 main.log.exception( self.name + ": Object not as expected" )
3143 return ( output, "Error " )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003144 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08003145 main.log.error( self.name + ": EOF exception found" )
3146 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003147 main.cleanup()
3148 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003149 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08003150 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003151 main.cleanup()
3152 main.exit()
3153
kelvin8ec71442015-01-15 16:57:00 -08003154 def getAllIntentIds( self ):
3155 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003156 Return a list of all Intent IDs
kelvin8ec71442015-01-15 16:57:00 -08003157 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003158 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08003159 cmdStr = "onos:intents | grep id="
3160 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003161 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003162 assert "Command not found:" not in output, output
Jon Halle3f39ff2015-01-13 11:50:53 -08003163 if re.search( "Error", output ):
3164 main.log.error( "Error in getting ports" )
3165 return ( output, "Error" )
Jon Halla495f562016-05-16 18:03:26 -07003166 return output
Jon Hallc6793552016-01-19 14:18:37 -08003167 except AssertionError:
3168 main.log.exception( "" )
3169 return None
Jon Halld4d4b372015-01-28 16:02:41 -08003170 except TypeError:
3171 main.log.exception( self.name + ": Object not as expected" )
3172 return ( output, "Error" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003173 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08003174 main.log.error( self.name + ": EOF exception found" )
3175 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003176 main.cleanup()
3177 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003178 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08003179 main.log.exception( self.name + ": Uncaught exception!" )
3180 main.cleanup()
3181 main.exit()
3182
Jon Hall73509952015-02-24 16:42:56 -08003183 def intentSummary( self ):
3184 """
Jon Hallefbd9792015-03-05 16:11:36 -08003185 Returns a dictionary containing the current intent states and the count
Jon Hall73509952015-02-24 16:42:56 -08003186 """
3187 try:
3188 intents = self.intents( )
Jon Hall08f61bc2015-04-13 16:00:30 -07003189 states = []
Jon Hall5aa168b2015-03-23 14:23:09 -07003190 for intent in json.loads( intents ):
Jon Hall08f61bc2015-04-13 16:00:30 -07003191 states.append( intent.get( 'state', None ) )
3192 out = [ ( i, states.count( i ) ) for i in set( states ) ]
Jon Hall63604932015-02-26 17:09:50 -08003193 main.log.info( dict( out ) )
Jon Hall73509952015-02-24 16:42:56 -08003194 return dict( out )
Jon Hallc6793552016-01-19 14:18:37 -08003195 except ( TypeError, ValueError ):
3196 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, intents ) )
Jon Hall73509952015-02-24 16:42:56 -08003197 return None
3198 except pexpect.EOF:
3199 main.log.error( self.name + ": EOF exception found" )
3200 main.log.error( self.name + ": " + self.handle.before )
3201 main.cleanup()
3202 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08003203 except Exception:
Jon Hall73509952015-02-24 16:42:56 -08003204 main.log.exception( self.name + ": Uncaught exception!" )
3205 main.cleanup()
3206 main.exit()
Jon Hall63604932015-02-26 17:09:50 -08003207
Jon Hall61282e32015-03-19 11:34:11 -07003208 def leaders( self, jsonFormat=True ):
Jon Hall63604932015-02-26 17:09:50 -08003209 """
3210 Returns the output of the leaders command.
Jon Hall61282e32015-03-19 11:34:11 -07003211 Optional argument:
3212 * jsonFormat - boolean indicating if you want output in json
Jon Hall63604932015-02-26 17:09:50 -08003213 """
Jon Hall63604932015-02-26 17:09:50 -08003214 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07003215 cmdStr = "onos:leaders"
Jon Hall61282e32015-03-19 11:34:11 -07003216 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07003217 cmdStr += " -j"
3218 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003219 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003220 assert "Command not found:" not in output, output
Jon Hallc6358dd2015-04-10 12:44:28 -07003221 return output
Jon Hallc6793552016-01-19 14:18:37 -08003222 except AssertionError:
3223 main.log.exception( "" )
3224 return None
Jon Hall63604932015-02-26 17:09:50 -08003225 except TypeError:
3226 main.log.exception( self.name + ": Object not as expected" )
3227 return None
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003228 except pexpect.EOF:
3229 main.log.error( self.name + ": EOF exception found" )
3230 main.log.error( self.name + ": " + self.handle.before )
3231 main.cleanup()
3232 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003233 except Exception:
Jon Hall63604932015-02-26 17:09:50 -08003234 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08003235 main.cleanup()
3236 main.exit()
Jon Hall63604932015-02-26 17:09:50 -08003237
acsmarsa4a4d1e2015-07-10 16:01:24 -07003238 def leaderCandidates( self, jsonFormat=True ):
3239 """
3240 Returns the output of the leaders -c command.
3241 Optional argument:
3242 * jsonFormat - boolean indicating if you want output in json
3243 """
3244 try:
3245 cmdStr = "onos:leaders -c"
3246 if jsonFormat:
3247 cmdStr += " -j"
3248 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003249 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003250 assert "Command not found:" not in output, output
acsmarsa4a4d1e2015-07-10 16:01:24 -07003251 return output
Jon Hallc6793552016-01-19 14:18:37 -08003252 except AssertionError:
3253 main.log.exception( "" )
3254 return None
acsmarsa4a4d1e2015-07-10 16:01:24 -07003255 except TypeError:
3256 main.log.exception( self.name + ": Object not as expected" )
3257 return None
3258 except pexpect.EOF:
3259 main.log.error( self.name + ": EOF exception found" )
3260 main.log.error( self.name + ": " + self.handle.before )
3261 main.cleanup()
3262 main.exit()
3263 except Exception:
3264 main.log.exception( self.name + ": Uncaught exception!" )
3265 main.cleanup()
3266 main.exit()
3267
Jon Hallc6793552016-01-19 14:18:37 -08003268 def specificLeaderCandidate( self, topic ):
acsmarsa4a4d1e2015-07-10 16:01:24 -07003269 """
3270 Returns a list in format [leader,candidate1,candidate2,...] for a given
3271 topic parameter and an empty list if the topic doesn't exist
3272 If no leader is elected leader in the returned list will be "none"
3273 Returns None if there is a type error processing the json object
3274 """
3275 try:
Jon Hall6e709752016-02-01 13:38:46 -08003276 cmdStr = "onos:leaders -j"
Jon Hallc6793552016-01-19 14:18:37 -08003277 rawOutput = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003278 assert rawOutput is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003279 assert "Command not found:" not in rawOutput, rawOutput
3280 output = json.loads( rawOutput )
acsmarsa4a4d1e2015-07-10 16:01:24 -07003281 results = []
3282 for dict in output:
3283 if dict["topic"] == topic:
3284 leader = dict["leader"]
Jon Hallc6793552016-01-19 14:18:37 -08003285 candidates = re.split( ", ", dict["candidates"][1:-1] )
3286 results.append( leader )
3287 results.extend( candidates )
acsmarsa4a4d1e2015-07-10 16:01:24 -07003288 return results
Jon Hallc6793552016-01-19 14:18:37 -08003289 except AssertionError:
3290 main.log.exception( "" )
3291 return None
3292 except ( TypeError, ValueError ):
3293 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, rawOutput ) )
acsmarsa4a4d1e2015-07-10 16:01:24 -07003294 return None
3295 except pexpect.EOF:
3296 main.log.error( self.name + ": EOF exception found" )
3297 main.log.error( self.name + ": " + self.handle.before )
3298 main.cleanup()
3299 main.exit()
3300 except Exception:
3301 main.log.exception( self.name + ": Uncaught exception!" )
3302 main.cleanup()
3303 main.exit()
3304
Jon Hall61282e32015-03-19 11:34:11 -07003305 def pendingMap( self, jsonFormat=True ):
Jon Hall63604932015-02-26 17:09:50 -08003306 """
3307 Returns the output of the intent Pending map.
3308 """
Jon Hall63604932015-02-26 17:09:50 -08003309 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07003310 cmdStr = "onos:intents -p"
Jon Hall61282e32015-03-19 11:34:11 -07003311 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07003312 cmdStr += " -j"
3313 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003314 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003315 assert "Command not found:" not in output, output
Jon Hallc6358dd2015-04-10 12:44:28 -07003316 return output
Jon Hallc6793552016-01-19 14:18:37 -08003317 except AssertionError:
3318 main.log.exception( "" )
3319 return None
Jon Hall63604932015-02-26 17:09:50 -08003320 except TypeError:
3321 main.log.exception( self.name + ": Object not as expected" )
3322 return None
3323 except pexpect.EOF:
3324 main.log.error( self.name + ": EOF exception found" )
3325 main.log.error( self.name + ": " + self.handle.before )
3326 main.cleanup()
3327 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003328 except Exception:
Jon Hall63604932015-02-26 17:09:50 -08003329 main.log.exception( self.name + ": Uncaught exception!" )
3330 main.cleanup()
3331 main.exit()
3332
Jon Hall61282e32015-03-19 11:34:11 -07003333 def partitions( self, jsonFormat=True ):
Jon Hall63604932015-02-26 17:09:50 -08003334 """
3335 Returns the output of the raft partitions command for ONOS.
3336 """
Jon Hall61282e32015-03-19 11:34:11 -07003337 # Sample JSON
3338 # {
3339 # "leader": "tcp://10.128.30.11:7238",
3340 # "members": [
3341 # "tcp://10.128.30.11:7238",
3342 # "tcp://10.128.30.17:7238",
3343 # "tcp://10.128.30.13:7238",
3344 # ],
3345 # "name": "p1",
3346 # "term": 3
3347 # },
Jon Hall63604932015-02-26 17:09:50 -08003348 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07003349 cmdStr = "onos:partitions"
Jon Hall61282e32015-03-19 11:34:11 -07003350 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07003351 cmdStr += " -j"
3352 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003353 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003354 assert "Command not found:" not in output, output
Jon Hallc6358dd2015-04-10 12:44:28 -07003355 return output
Jon Hallc6793552016-01-19 14:18:37 -08003356 except AssertionError:
3357 main.log.exception( "" )
3358 return None
Jon Hall63604932015-02-26 17:09:50 -08003359 except TypeError:
3360 main.log.exception( self.name + ": Object not as expected" )
3361 return None
3362 except pexpect.EOF:
3363 main.log.error( self.name + ": EOF exception found" )
3364 main.log.error( self.name + ": " + self.handle.before )
3365 main.cleanup()
3366 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003367 except Exception:
Jon Hall63604932015-02-26 17:09:50 -08003368 main.log.exception( self.name + ": Uncaught exception!" )
3369 main.cleanup()
3370 main.exit()
3371
Jon Hallbe379602015-03-24 13:39:32 -07003372 def apps( self, jsonFormat=True ):
3373 """
3374 Returns the output of the apps command for ONOS. This command lists
3375 information about installed ONOS applications
3376 """
3377 # Sample JSON object
3378 # [{"name":"org.onosproject.openflow","id":0,"version":"1.2.0",
3379 # "description":"ONOS OpenFlow protocol southbound providers",
3380 # "origin":"ON.Lab","permissions":"[]","featuresRepo":"",
3381 # "features":"[onos-openflow]","state":"ACTIVE"}]
3382 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07003383 cmdStr = "onos:apps"
Jon Hallbe379602015-03-24 13:39:32 -07003384 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07003385 cmdStr += " -j"
3386 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003387 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003388 assert "Command not found:" not in output, output
3389 assert "Error executing command" not in output, output
Jon Hallc6358dd2015-04-10 12:44:28 -07003390 return output
Jon Hallbe379602015-03-24 13:39:32 -07003391 # FIXME: look at specific exceptions/Errors
3392 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08003393 main.log.exception( "Error in processing onos:app command." )
Jon Hallbe379602015-03-24 13:39:32 -07003394 return None
3395 except TypeError:
3396 main.log.exception( self.name + ": Object not as expected" )
3397 return None
3398 except pexpect.EOF:
3399 main.log.error( self.name + ": EOF exception found" )
3400 main.log.error( self.name + ": " + self.handle.before )
3401 main.cleanup()
3402 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003403 except Exception:
Jon Hallbe379602015-03-24 13:39:32 -07003404 main.log.exception( self.name + ": Uncaught exception!" )
3405 main.cleanup()
3406 main.exit()
3407
Jon Hall146f1522015-03-24 15:33:24 -07003408 def appStatus( self, appName ):
3409 """
3410 Uses the onos:apps cli command to return the status of an application.
3411 Returns:
3412 "ACTIVE" - If app is installed and activated
3413 "INSTALLED" - If app is installed and deactivated
3414 "UNINSTALLED" - If app is not installed
3415 None - on error
3416 """
Jon Hall146f1522015-03-24 15:33:24 -07003417 try:
3418 if not isinstance( appName, types.StringType ):
3419 main.log.error( self.name + ".appStatus(): appName must be" +
3420 " a string" )
3421 return None
3422 output = self.apps( jsonFormat=True )
3423 appsJson = json.loads( output )
3424 state = None
3425 for app in appsJson:
3426 if appName == app.get('name'):
3427 state = app.get('state')
3428 break
3429 if state == "ACTIVE" or state == "INSTALLED":
3430 return state
3431 elif state is None:
3432 return "UNINSTALLED"
3433 elif state:
3434 main.log.error( "Unexpected state from 'onos:apps': " +
3435 str( state ) )
3436 return state
Jon Hallc6793552016-01-19 14:18:37 -08003437 except ( TypeError, ValueError ):
3438 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, output ) )
Jon Hall146f1522015-03-24 15:33:24 -07003439 return None
3440 except pexpect.EOF:
3441 main.log.error( self.name + ": EOF exception found" )
3442 main.log.error( self.name + ": " + self.handle.before )
3443 main.cleanup()
3444 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003445 except Exception:
Jon Hall146f1522015-03-24 15:33:24 -07003446 main.log.exception( self.name + ": Uncaught exception!" )
3447 main.cleanup()
3448 main.exit()
3449
Jon Hallbe379602015-03-24 13:39:32 -07003450 def app( self, appName, option ):
3451 """
3452 Interacts with the app command for ONOS. This command manages
3453 application inventory.
3454 """
Jon Hallbe379602015-03-24 13:39:32 -07003455 try:
Jon Hallbd16b922015-03-26 17:53:15 -07003456 # Validate argument types
3457 valid = True
3458 if not isinstance( appName, types.StringType ):
3459 main.log.error( self.name + ".app(): appName must be a " +
3460 "string" )
3461 valid = False
3462 if not isinstance( option, types.StringType ):
3463 main.log.error( self.name + ".app(): option must be a string" )
3464 valid = False
3465 if not valid:
3466 return main.FALSE
3467 # Validate Option
3468 option = option.lower()
3469 # NOTE: Install may become a valid option
3470 if option == "activate":
3471 pass
3472 elif option == "deactivate":
3473 pass
3474 elif option == "uninstall":
3475 pass
3476 else:
3477 # Invalid option
3478 main.log.error( "The ONOS app command argument only takes " +
3479 "the values: (activate|deactivate|uninstall)" +
3480 "; was given '" + option + "'")
3481 return main.FALSE
Jon Hall146f1522015-03-24 15:33:24 -07003482 cmdStr = "onos:app " + option + " " + appName
Jon Hallbe379602015-03-24 13:39:32 -07003483 output = self.sendline( cmdStr )
Jon Hallbe379602015-03-24 13:39:32 -07003484 if "Error executing command" in output:
3485 main.log.error( "Error in processing onos:app command: " +
3486 str( output ) )
Jon Hall146f1522015-03-24 15:33:24 -07003487 return main.FALSE
Jon Hallbe379602015-03-24 13:39:32 -07003488 elif "No such application" in output:
3489 main.log.error( "The application '" + appName +
3490 "' is not installed in ONOS" )
Jon Hall146f1522015-03-24 15:33:24 -07003491 return main.FALSE
3492 elif "Command not found:" in output:
3493 main.log.error( "Error in processing onos:app command: " +
3494 str( output ) )
3495 return main.FALSE
Jon Hallbd16b922015-03-26 17:53:15 -07003496 elif "Unsupported command:" in output:
3497 main.log.error( "Incorrect command given to 'app': " +
3498 str( output ) )
Jon Hallbe379602015-03-24 13:39:32 -07003499 # NOTE: we may need to add more checks here
Jon Hallbd16b922015-03-26 17:53:15 -07003500 # else: Command was successful
Jon Hall08f61bc2015-04-13 16:00:30 -07003501 # main.log.debug( "app response: " + repr( output ) )
Jon Hallbe379602015-03-24 13:39:32 -07003502 return main.TRUE
3503 except TypeError:
3504 main.log.exception( self.name + ": Object not as expected" )
3505 return main.ERROR
3506 except pexpect.EOF:
3507 main.log.error( self.name + ": EOF exception found" )
3508 main.log.error( self.name + ": " + self.handle.before )
3509 main.cleanup()
3510 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003511 except Exception:
Jon Hallbe379602015-03-24 13:39:32 -07003512 main.log.exception( self.name + ": Uncaught exception!" )
3513 main.cleanup()
3514 main.exit()
Jon Hall146f1522015-03-24 15:33:24 -07003515
Jon Hallbd16b922015-03-26 17:53:15 -07003516 def activateApp( self, appName, check=True ):
Jon Hall146f1522015-03-24 15:33:24 -07003517 """
3518 Activate an app that is already installed in ONOS
Jon Hallbd16b922015-03-26 17:53:15 -07003519 appName is the hierarchical app name, not the feature name
3520 If check is True, method will check the status of the app after the
3521 command is issued
Jon Hall146f1522015-03-24 15:33:24 -07003522 Returns main.TRUE if the command was successfully sent
3523 main.FALSE if the cli responded with an error or given
3524 incorrect input
3525 """
3526 try:
3527 if not isinstance( appName, types.StringType ):
3528 main.log.error( self.name + ".activateApp(): appName must be" +
3529 " a string" )
3530 return main.FALSE
3531 status = self.appStatus( appName )
3532 if status == "INSTALLED":
3533 response = self.app( appName, "activate" )
Jon Hallbd16b922015-03-26 17:53:15 -07003534 if check and response == main.TRUE:
3535 for i in range(10): # try 10 times then give up
Jon Hallbd16b922015-03-26 17:53:15 -07003536 status = self.appStatus( appName )
3537 if status == "ACTIVE":
3538 return main.TRUE
3539 else:
Jon Hall050e1bd2015-03-30 13:33:02 -07003540 main.log.debug( "The state of application " +
3541 appName + " is " + status )
Jon Hallbd16b922015-03-26 17:53:15 -07003542 time.sleep( 1 )
3543 return main.FALSE
3544 else: # not 'check' or command didn't succeed
3545 return response
Jon Hall146f1522015-03-24 15:33:24 -07003546 elif status == "ACTIVE":
3547 return main.TRUE
3548 elif status == "UNINSTALLED":
3549 main.log.error( self.name + ": Tried to activate the " +
3550 "application '" + appName + "' which is not " +
3551 "installed." )
3552 else:
3553 main.log.error( "Unexpected return value from appStatus: " +
3554 str( status ) )
3555 return main.ERROR
3556 except TypeError:
3557 main.log.exception( self.name + ": Object not as expected" )
3558 return main.ERROR
3559 except pexpect.EOF:
3560 main.log.error( self.name + ": EOF exception found" )
3561 main.log.error( self.name + ": " + self.handle.before )
3562 main.cleanup()
3563 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003564 except Exception:
Jon Hall146f1522015-03-24 15:33:24 -07003565 main.log.exception( self.name + ": Uncaught exception!" )
3566 main.cleanup()
3567 main.exit()
3568
Jon Hallbd16b922015-03-26 17:53:15 -07003569 def deactivateApp( self, appName, check=True ):
Jon Hall146f1522015-03-24 15:33:24 -07003570 """
3571 Deactivate an app that is already activated in ONOS
Jon Hallbd16b922015-03-26 17:53:15 -07003572 appName is the hierarchical app name, not the feature name
3573 If check is True, method will check the status of the app after the
3574 command is issued
Jon Hall146f1522015-03-24 15:33:24 -07003575 Returns main.TRUE if the command was successfully sent
3576 main.FALSE if the cli responded with an error or given
3577 incorrect input
3578 """
3579 try:
3580 if not isinstance( appName, types.StringType ):
3581 main.log.error( self.name + ".deactivateApp(): appName must " +
3582 "be a string" )
3583 return main.FALSE
3584 status = self.appStatus( appName )
3585 if status == "INSTALLED":
3586 return main.TRUE
3587 elif status == "ACTIVE":
3588 response = self.app( appName, "deactivate" )
Jon Hallbd16b922015-03-26 17:53:15 -07003589 if check and response == main.TRUE:
3590 for i in range(10): # try 10 times then give up
3591 status = self.appStatus( appName )
3592 if status == "INSTALLED":
3593 return main.TRUE
3594 else:
3595 time.sleep( 1 )
3596 return main.FALSE
3597 else: # not check or command didn't succeed
3598 return response
Jon Hall146f1522015-03-24 15:33:24 -07003599 elif status == "UNINSTALLED":
3600 main.log.warn( self.name + ": Tried to deactivate the " +
3601 "application '" + appName + "' which is not " +
3602 "installed." )
3603 return main.TRUE
3604 else:
3605 main.log.error( "Unexpected return value from appStatus: " +
3606 str( status ) )
3607 return main.ERROR
3608 except TypeError:
3609 main.log.exception( self.name + ": Object not as expected" )
3610 return main.ERROR
3611 except pexpect.EOF:
3612 main.log.error( self.name + ": EOF exception found" )
3613 main.log.error( self.name + ": " + self.handle.before )
3614 main.cleanup()
3615 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003616 except Exception:
Jon Hall146f1522015-03-24 15:33:24 -07003617 main.log.exception( self.name + ": Uncaught exception!" )
3618 main.cleanup()
3619 main.exit()
3620
Jon Hallbd16b922015-03-26 17:53:15 -07003621 def uninstallApp( self, appName, check=True ):
Jon Hall146f1522015-03-24 15:33:24 -07003622 """
3623 Uninstall an app that is already installed in ONOS
Jon Hallbd16b922015-03-26 17:53:15 -07003624 appName is the hierarchical app name, not the feature name
3625 If check is True, method will check the status of the app after the
3626 command is issued
Jon Hall146f1522015-03-24 15:33:24 -07003627 Returns main.TRUE if the command was successfully sent
3628 main.FALSE if the cli responded with an error or given
3629 incorrect input
3630 """
3631 # TODO: check with Thomas about the state machine for apps
3632 try:
3633 if not isinstance( appName, types.StringType ):
3634 main.log.error( self.name + ".uninstallApp(): appName must " +
3635 "be a string" )
3636 return main.FALSE
3637 status = self.appStatus( appName )
3638 if status == "INSTALLED":
3639 response = self.app( appName, "uninstall" )
Jon Hallbd16b922015-03-26 17:53:15 -07003640 if check and response == main.TRUE:
3641 for i in range(10): # try 10 times then give up
3642 status = self.appStatus( appName )
3643 if status == "UNINSTALLED":
3644 return main.TRUE
3645 else:
3646 time.sleep( 1 )
3647 return main.FALSE
3648 else: # not check or command didn't succeed
3649 return response
Jon Hall146f1522015-03-24 15:33:24 -07003650 elif status == "ACTIVE":
3651 main.log.warn( self.name + ": Tried to uninstall the " +
3652 "application '" + appName + "' which is " +
3653 "currently active." )
3654 response = self.app( appName, "uninstall" )
Jon Hallbd16b922015-03-26 17:53:15 -07003655 if check and response == main.TRUE:
3656 for i in range(10): # try 10 times then give up
3657 status = self.appStatus( appName )
3658 if status == "UNINSTALLED":
3659 return main.TRUE
3660 else:
3661 time.sleep( 1 )
3662 return main.FALSE
3663 else: # not check or command didn't succeed
3664 return response
Jon Hall146f1522015-03-24 15:33:24 -07003665 elif status == "UNINSTALLED":
3666 return main.TRUE
3667 else:
3668 main.log.error( "Unexpected return value from appStatus: " +
3669 str( status ) )
3670 return main.ERROR
3671 except TypeError:
3672 main.log.exception( self.name + ": Object not as expected" )
3673 return main.ERROR
3674 except pexpect.EOF:
3675 main.log.error( self.name + ": EOF exception found" )
3676 main.log.error( self.name + ": " + self.handle.before )
3677 main.cleanup()
3678 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003679 except Exception:
Jon Hall146f1522015-03-24 15:33:24 -07003680 main.log.exception( self.name + ": Uncaught exception!" )
3681 main.cleanup()
3682 main.exit()
Jon Hallbd16b922015-03-26 17:53:15 -07003683
3684 def appIDs( self, jsonFormat=True ):
3685 """
3686 Show the mappings between app id and app names given by the 'app-ids'
3687 cli command
3688 """
3689 try:
3690 cmdStr = "app-ids"
3691 if jsonFormat:
3692 cmdStr += " -j"
Jon Hallc6358dd2015-04-10 12:44:28 -07003693 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003694 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003695 assert "Command not found:" not in output, output
3696 assert "Error executing command" not in output, output
Jon Hallc6358dd2015-04-10 12:44:28 -07003697 return output
Jon Hallbd16b922015-03-26 17:53:15 -07003698 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08003699 main.log.exception( "Error in processing onos:app-ids command." )
Jon Hallbd16b922015-03-26 17:53:15 -07003700 return None
3701 except TypeError:
3702 main.log.exception( self.name + ": Object not as expected" )
3703 return None
3704 except pexpect.EOF:
3705 main.log.error( self.name + ": EOF exception found" )
3706 main.log.error( self.name + ": " + self.handle.before )
3707 main.cleanup()
3708 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003709 except Exception:
Jon Hallbd16b922015-03-26 17:53:15 -07003710 main.log.exception( self.name + ": Uncaught exception!" )
3711 main.cleanup()
3712 main.exit()
3713
3714 def appToIDCheck( self ):
3715 """
3716 This method will check that each application's ID listed in 'apps' is
3717 the same as the ID listed in 'app-ids'. The check will also check that
3718 there are no duplicate IDs issued. Note that an app ID should be
3719 a globaly unique numerical identifier for app/app-like features. Once
3720 an ID is registered, the ID is never freed up so that if an app is
3721 reinstalled it will have the same ID.
3722
3723 Returns: main.TRUE if the check passes and
3724 main.FALSE if the check fails or
3725 main.ERROR if there is some error in processing the test
3726 """
3727 try:
Jon Hall390696c2015-05-05 17:13:41 -07003728 bail = False
Jon Hallc6793552016-01-19 14:18:37 -08003729 rawJson = self.appIDs( jsonFormat=True )
3730 if rawJson:
3731 ids = json.loads( rawJson )
Jon Hall390696c2015-05-05 17:13:41 -07003732 else:
Jon Hallc6793552016-01-19 14:18:37 -08003733 main.log.error( "app-ids returned nothing:" + repr( rawJson ) )
Jon Hall390696c2015-05-05 17:13:41 -07003734 bail = True
Jon Hallc6793552016-01-19 14:18:37 -08003735 rawJson = self.apps( jsonFormat=True )
3736 if rawJson:
3737 apps = json.loads( rawJson )
Jon Hall390696c2015-05-05 17:13:41 -07003738 else:
Jon Hallc6793552016-01-19 14:18:37 -08003739 main.log.error( "apps returned nothing:" + repr( rawJson ) )
Jon Hall390696c2015-05-05 17:13:41 -07003740 bail = True
3741 if bail:
3742 return main.FALSE
Jon Hallbd16b922015-03-26 17:53:15 -07003743 result = main.TRUE
3744 for app in apps:
3745 appID = app.get( 'id' )
3746 if appID is None:
3747 main.log.error( "Error parsing app: " + str( app ) )
3748 result = main.FALSE
3749 appName = app.get( 'name' )
3750 if appName is None:
3751 main.log.error( "Error parsing app: " + str( app ) )
3752 result = main.FALSE
3753 # get the entry in ids that has the same appID
Jon Hall390696c2015-05-05 17:13:41 -07003754 current = filter( lambda item: item[ 'id' ] == appID, ids )
Jon Hall050e1bd2015-03-30 13:33:02 -07003755 # main.log.debug( "Comparing " + str( app ) + " to " +
3756 # str( current ) )
Jon Hallbd16b922015-03-26 17:53:15 -07003757 if not current: # if ids doesn't have this id
3758 result = main.FALSE
3759 main.log.error( "'app-ids' does not have the ID for " +
3760 str( appName ) + " that apps does." )
3761 elif len( current ) > 1:
3762 # there is more than one app with this ID
3763 result = main.FALSE
3764 # We will log this later in the method
3765 elif not current[0][ 'name' ] == appName:
3766 currentName = current[0][ 'name' ]
3767 result = main.FALSE
3768 main.log.error( "'app-ids' has " + str( currentName ) +
3769 " registered under id:" + str( appID ) +
3770 " but 'apps' has " + str( appName ) )
3771 else:
3772 pass # id and name match!
3773 # now make sure that app-ids has no duplicates
3774 idsList = []
3775 namesList = []
3776 for item in ids:
3777 idsList.append( item[ 'id' ] )
3778 namesList.append( item[ 'name' ] )
3779 if len( idsList ) != len( set( idsList ) ) or\
3780 len( namesList ) != len( set( namesList ) ):
3781 main.log.error( "'app-ids' has some duplicate entries: \n"
3782 + json.dumps( ids,
3783 sort_keys=True,
3784 indent=4,
3785 separators=( ',', ': ' ) ) )
3786 result = main.FALSE
3787 return result
Jon Hallc6793552016-01-19 14:18:37 -08003788 except ( TypeError, ValueError ):
3789 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, rawJson ) )
Jon Hallbd16b922015-03-26 17:53:15 -07003790 return main.ERROR
3791 except pexpect.EOF:
3792 main.log.error( self.name + ": EOF exception found" )
3793 main.log.error( self.name + ": " + self.handle.before )
3794 main.cleanup()
3795 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003796 except Exception:
Jon Hallbd16b922015-03-26 17:53:15 -07003797 main.log.exception( self.name + ": Uncaught exception!" )
3798 main.cleanup()
3799 main.exit()
3800
Jon Hallfb760a02015-04-13 15:35:03 -07003801 def getCfg( self, component=None, propName=None, short=False,
3802 jsonFormat=True ):
3803 """
3804 Get configuration settings from onos cli
3805 Optional arguments:
3806 component - Optionally only list configurations for a specific
3807 component. If None, all components with configurations
3808 are displayed. Case Sensitive string.
3809 propName - If component is specified, propName option will show
3810 only this specific configuration from that component.
3811 Case Sensitive string.
3812 jsonFormat - Returns output as json. Note that this will override
3813 the short option
3814 short - Short, less verbose, version of configurations.
3815 This is overridden by the json option
3816 returns:
3817 Output from cli as a string or None on error
3818 """
3819 try:
3820 baseStr = "cfg"
3821 cmdStr = " get"
3822 componentStr = ""
3823 if component:
3824 componentStr += " " + component
3825 if propName:
3826 componentStr += " " + propName
3827 if jsonFormat:
3828 baseStr += " -j"
3829 elif short:
3830 baseStr += " -s"
3831 output = self.sendline( baseStr + cmdStr + componentStr )
Jon Halla495f562016-05-16 18:03:26 -07003832 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003833 assert "Command not found:" not in output, output
3834 assert "Error executing command" not in output, output
Jon Hallfb760a02015-04-13 15:35:03 -07003835 return output
3836 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08003837 main.log.exception( "Error in processing 'cfg get' command." )
Jon Hallfb760a02015-04-13 15:35:03 -07003838 return None
3839 except TypeError:
3840 main.log.exception( self.name + ": Object not as expected" )
3841 return None
3842 except pexpect.EOF:
3843 main.log.error( self.name + ": EOF exception found" )
3844 main.log.error( self.name + ": " + self.handle.before )
3845 main.cleanup()
3846 main.exit()
3847 except Exception:
3848 main.log.exception( self.name + ": Uncaught exception!" )
3849 main.cleanup()
3850 main.exit()
3851
3852 def setCfg( self, component, propName, value=None, check=True ):
3853 """
3854 Set/Unset configuration settings from ONOS cli
Jon Hall390696c2015-05-05 17:13:41 -07003855 Required arguments:
Jon Hallfb760a02015-04-13 15:35:03 -07003856 component - The case sensitive name of the component whose
3857 property is to be set
3858 propName - The case sensitive name of the property to be set/unset
Jon Hall390696c2015-05-05 17:13:41 -07003859 Optional arguments:
Jon Hallfb760a02015-04-13 15:35:03 -07003860 value - The value to set the property to. If None, will unset the
3861 property and revert it to it's default value(if applicable)
3862 check - Boolean, Check whether the option was successfully set this
3863 only applies when a value is given.
3864 returns:
3865 main.TRUE on success or main.FALSE on failure. If check is False,
3866 will return main.TRUE unless there is an error
3867 """
3868 try:
3869 baseStr = "cfg"
3870 cmdStr = " set " + str( component ) + " " + str( propName )
3871 if value is not None:
3872 cmdStr += " " + str( value )
3873 output = self.sendline( baseStr + cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003874 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003875 assert "Command not found:" not in output, output
3876 assert "Error executing command" not in output, output
Jon Hallfb760a02015-04-13 15:35:03 -07003877 if value and check:
3878 results = self.getCfg( component=str( component ),
3879 propName=str( propName ),
3880 jsonFormat=True )
3881 # Check if current value is what we just set
3882 try:
3883 jsonOutput = json.loads( results )
3884 current = jsonOutput[ 'value' ]
Jon Hallc6793552016-01-19 14:18:37 -08003885 except ( TypeError, ValueError ):
Jon Hallfb760a02015-04-13 15:35:03 -07003886 main.log.exception( "Error parsing cfg output" )
3887 main.log.error( "output:" + repr( results ) )
3888 return main.FALSE
3889 if current == str( value ):
3890 return main.TRUE
3891 return main.FALSE
3892 return main.TRUE
3893 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08003894 main.log.exception( "Error in processing 'cfg set' command." )
Jon Hallfb760a02015-04-13 15:35:03 -07003895 return main.FALSE
Jon Hallc6793552016-01-19 14:18:37 -08003896 except ( TypeError, ValueError ):
3897 main.log.exception( "{}: Object not as expected: {!r}".format( self.name, results ) )
Jon Hallfb760a02015-04-13 15:35:03 -07003898 return main.FALSE
3899 except pexpect.EOF:
3900 main.log.error( self.name + ": EOF exception found" )
3901 main.log.error( self.name + ": " + self.handle.before )
3902 main.cleanup()
3903 main.exit()
3904 except Exception:
3905 main.log.exception( self.name + ": Uncaught exception!" )
3906 main.cleanup()
3907 main.exit()
3908
Jon Hall390696c2015-05-05 17:13:41 -07003909 def setTestAdd( self, setName, values ):
3910 """
3911 CLI command to add elements to a distributed set.
3912 Arguments:
3913 setName - The name of the set to add to.
3914 values - The value(s) to add to the set, space seperated.
3915 Example usages:
3916 setTestAdd( "set1", "a b c" )
3917 setTestAdd( "set2", "1" )
3918 returns:
3919 main.TRUE on success OR
3920 main.FALSE if elements were already in the set OR
3921 main.ERROR on error
3922 """
3923 try:
3924 cmdStr = "set-test-add " + str( setName ) + " " + str( values )
3925 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003926 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08003927 assert "Command not found:" not in output, output
Jon Hallfeff3082015-05-19 10:23:26 -07003928 try:
3929 # TODO: Maybe make this less hardcoded
3930 # ConsistentMap Exceptions
3931 assert "org.onosproject.store.service" not in output
3932 # Node not leader
3933 assert "java.lang.IllegalStateException" not in output
3934 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07003935 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07003936 "command: " + str( output ) )
3937 retryTime = 30 # Conservative time, given by Madan
3938 main.log.info( "Waiting " + str( retryTime ) +
3939 "seconds before retrying." )
3940 time.sleep( retryTime ) # Due to change in mastership
3941 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07003942 assert output is not None, "Error in sendline"
Jon Hall390696c2015-05-05 17:13:41 -07003943 assert "Error executing command" not in output
3944 positiveMatch = "\[(.*)\] was added to the set " + str( setName )
3945 negativeMatch = "\[(.*)\] was already in set " + str( setName )
3946 main.log.info( self.name + ": " + output )
3947 if re.search( positiveMatch, output):
3948 return main.TRUE
3949 elif re.search( negativeMatch, output):
3950 return main.FALSE
3951 else:
3952 main.log.error( self.name + ": setTestAdd did not" +
3953 " match expected output" )
Jon Hall390696c2015-05-05 17:13:41 -07003954 main.log.debug( self.name + " actual: " + repr( output ) )
3955 return main.ERROR
3956 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08003957 main.log.exception( "Error in processing '" + cmdStr + "' command. " )
Jon Hall390696c2015-05-05 17:13:41 -07003958 return main.ERROR
3959 except TypeError:
3960 main.log.exception( self.name + ": Object not as expected" )
3961 return main.ERROR
3962 except pexpect.EOF:
3963 main.log.error( self.name + ": EOF exception found" )
3964 main.log.error( self.name + ": " + self.handle.before )
3965 main.cleanup()
3966 main.exit()
3967 except Exception:
3968 main.log.exception( self.name + ": Uncaught exception!" )
3969 main.cleanup()
3970 main.exit()
3971
3972 def setTestRemove( self, setName, values, clear=False, retain=False ):
3973 """
3974 CLI command to remove elements from a distributed set.
3975 Required arguments:
3976 setName - The name of the set to remove from.
3977 values - The value(s) to remove from the set, space seperated.
3978 Optional arguments:
3979 clear - Clear all elements from the set
3980 retain - Retain only the given values. (intersection of the
3981 original set and the given set)
3982 returns:
3983 main.TRUE on success OR
3984 main.FALSE if the set was not changed OR
3985 main.ERROR on error
3986 """
3987 try:
3988 cmdStr = "set-test-remove "
3989 if clear:
3990 cmdStr += "-c " + str( setName )
3991 elif retain:
3992 cmdStr += "-r " + str( setName ) + " " + str( values )
3993 else:
3994 cmdStr += str( setName ) + " " + str( values )
3995 output = self.sendline( cmdStr )
Jon Hallfeff3082015-05-19 10:23:26 -07003996 try:
Jon Halla495f562016-05-16 18:03:26 -07003997 assert output is not None, "Error in sendline"
Jon Hallfeff3082015-05-19 10:23:26 -07003998 # TODO: Maybe make this less hardcoded
3999 # ConsistentMap Exceptions
4000 assert "org.onosproject.store.service" not in output
4001 # Node not leader
4002 assert "java.lang.IllegalStateException" not in output
4003 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07004004 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07004005 "command: " + str( output ) )
4006 retryTime = 30 # Conservative time, given by Madan
4007 main.log.info( "Waiting " + str( retryTime ) +
4008 "seconds before retrying." )
4009 time.sleep( retryTime ) # Due to change in mastership
4010 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004011 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004012 assert "Command not found:" not in output, output
4013 assert "Error executing command" not in output, output
Jon Hall390696c2015-05-05 17:13:41 -07004014 main.log.info( self.name + ": " + output )
4015 if clear:
4016 pattern = "Set " + str( setName ) + " cleared"
4017 if re.search( pattern, output ):
4018 return main.TRUE
4019 elif retain:
4020 positivePattern = str( setName ) + " was pruned to contain " +\
4021 "only elements of set \[(.*)\]"
4022 negativePattern = str( setName ) + " was not changed by " +\
4023 "retaining only elements of the set " +\
4024 "\[(.*)\]"
4025 if re.search( positivePattern, output ):
4026 return main.TRUE
4027 elif re.search( negativePattern, output ):
4028 return main.FALSE
4029 else:
4030 positivePattern = "\[(.*)\] was removed from the set " +\
4031 str( setName )
4032 if ( len( values.split() ) == 1 ):
4033 negativePattern = "\[(.*)\] was not in set " +\
4034 str( setName )
4035 else:
4036 negativePattern = "No element of \[(.*)\] was in set " +\
4037 str( setName )
4038 if re.search( positivePattern, output ):
4039 return main.TRUE
4040 elif re.search( negativePattern, output ):
4041 return main.FALSE
4042 main.log.error( self.name + ": setTestRemove did not" +
4043 " match expected output" )
4044 main.log.debug( self.name + " expected: " + pattern )
4045 main.log.debug( self.name + " actual: " + repr( output ) )
4046 return main.ERROR
4047 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08004048 main.log.exception( "Error in processing '" + cmdStr + "' commandr. " )
Jon Hall390696c2015-05-05 17:13:41 -07004049 return main.ERROR
4050 except TypeError:
4051 main.log.exception( self.name + ": Object not as expected" )
4052 return main.ERROR
4053 except pexpect.EOF:
4054 main.log.error( self.name + ": EOF exception found" )
4055 main.log.error( self.name + ": " + self.handle.before )
4056 main.cleanup()
4057 main.exit()
4058 except Exception:
4059 main.log.exception( self.name + ": Uncaught exception!" )
4060 main.cleanup()
4061 main.exit()
4062
4063 def setTestGet( self, setName, values="" ):
4064 """
4065 CLI command to get the elements in a distributed set.
4066 Required arguments:
4067 setName - The name of the set to remove from.
4068 Optional arguments:
4069 values - The value(s) to check if in the set, space seperated.
4070 returns:
4071 main.ERROR on error OR
4072 A list of elements in the set if no optional arguments are
4073 supplied OR
4074 A tuple containing the list then:
4075 main.FALSE if the given values are not in the set OR
4076 main.TRUE if the given values are in the set OR
4077 """
4078 try:
4079 values = str( values ).strip()
4080 setName = str( setName ).strip()
4081 length = len( values.split() )
4082 containsCheck = None
4083 # Patterns to match
4084 setPattern = "\[(.*)\]"
4085 pattern = "Items in set " + setName + ":\n" + setPattern
4086 containsTrue = "Set " + setName + " contains the value " + values
4087 containsFalse = "Set " + setName + " did not contain the value " +\
4088 values
4089 containsAllTrue = "Set " + setName + " contains the the subset " +\
4090 setPattern
4091 containsAllFalse = "Set " + setName + " did not contain the the" +\
4092 " subset " + setPattern
4093
4094 cmdStr = "set-test-get "
4095 cmdStr += setName + " " + values
4096 output = self.sendline( cmdStr )
Jon Hallfeff3082015-05-19 10:23:26 -07004097 try:
Jon Halla495f562016-05-16 18:03:26 -07004098 assert output is not None, "Error in sendline"
Jon Hallfeff3082015-05-19 10:23:26 -07004099 # TODO: Maybe make this less hardcoded
4100 # ConsistentMap Exceptions
4101 assert "org.onosproject.store.service" not in output
4102 # Node not leader
4103 assert "java.lang.IllegalStateException" not in output
4104 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07004105 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07004106 "command: " + str( output ) )
4107 retryTime = 30 # Conservative time, given by Madan
4108 main.log.info( "Waiting " + str( retryTime ) +
4109 "seconds before retrying." )
4110 time.sleep( retryTime ) # Due to change in mastership
4111 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004112 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004113 assert "Command not found:" not in output, output
4114 assert "Error executing command" not in output, output
Jon Hall390696c2015-05-05 17:13:41 -07004115 main.log.info( self.name + ": " + output )
4116
4117 if length == 0:
4118 match = re.search( pattern, output )
4119 else: # if given values
4120 if length == 1: # Contains output
4121 patternTrue = pattern + "\n" + containsTrue
4122 patternFalse = pattern + "\n" + containsFalse
4123 else: # ContainsAll output
4124 patternTrue = pattern + "\n" + containsAllTrue
4125 patternFalse = pattern + "\n" + containsAllFalse
4126 matchTrue = re.search( patternTrue, output )
4127 matchFalse = re.search( patternFalse, output )
4128 if matchTrue:
4129 containsCheck = main.TRUE
4130 match = matchTrue
4131 elif matchFalse:
4132 containsCheck = main.FALSE
4133 match = matchFalse
4134 else:
4135 main.log.error( self.name + " setTestGet did not match " +\
4136 "expected output" )
4137 main.log.debug( self.name + " expected: " + pattern )
4138 main.log.debug( self.name + " actual: " + repr( output ) )
4139 match = None
4140 if match:
4141 setMatch = match.group( 1 )
4142 if setMatch == '':
4143 setList = []
4144 else:
4145 setList = setMatch.split( ", " )
4146 if length > 0:
4147 return ( setList, containsCheck )
4148 else:
4149 return setList
4150 else: # no match
4151 main.log.error( self.name + ": setTestGet did not" +
4152 " match expected output" )
4153 main.log.debug( self.name + " expected: " + pattern )
4154 main.log.debug( self.name + " actual: " + repr( output ) )
4155 return main.ERROR
4156 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08004157 main.log.exception( "Error in processing '" + cmdStr + "' command." )
Jon Hall390696c2015-05-05 17:13:41 -07004158 return main.ERROR
4159 except TypeError:
4160 main.log.exception( self.name + ": Object not as expected" )
4161 return main.ERROR
4162 except pexpect.EOF:
4163 main.log.error( self.name + ": EOF exception found" )
4164 main.log.error( self.name + ": " + self.handle.before )
4165 main.cleanup()
4166 main.exit()
4167 except Exception:
4168 main.log.exception( self.name + ": Uncaught exception!" )
4169 main.cleanup()
4170 main.exit()
4171
4172 def setTestSize( self, setName ):
4173 """
4174 CLI command to get the elements in a distributed set.
4175 Required arguments:
4176 setName - The name of the set to remove from.
4177 returns:
Jon Hallfeff3082015-05-19 10:23:26 -07004178 The integer value of the size returned or
Jon Hall390696c2015-05-05 17:13:41 -07004179 None on error
4180 """
4181 try:
4182 # TODO: Should this check against the number of elements returned
4183 # and then return true/false based on that?
4184 setName = str( setName ).strip()
4185 # Patterns to match
4186 setPattern = "\[(.*)\]"
4187 pattern = "There are (\d+) items in set " + setName + ":\n" +\
4188 setPattern
4189 cmdStr = "set-test-get -s "
4190 cmdStr += setName
4191 output = self.sendline( cmdStr )
Jon Hallfeff3082015-05-19 10:23:26 -07004192 try:
Jon Halla495f562016-05-16 18:03:26 -07004193 assert output is not None, "Error in sendline"
Jon Hallfeff3082015-05-19 10:23:26 -07004194 # TODO: Maybe make this less hardcoded
4195 # ConsistentMap Exceptions
4196 assert "org.onosproject.store.service" not in output
4197 # Node not leader
4198 assert "java.lang.IllegalStateException" not in output
4199 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07004200 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07004201 "command: " + str( output ) )
4202 retryTime = 30 # Conservative time, given by Madan
4203 main.log.info( "Waiting " + str( retryTime ) +
4204 "seconds before retrying." )
4205 time.sleep( retryTime ) # Due to change in mastership
4206 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004207 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004208 assert "Command not found:" not in output, output
4209 assert "Error executing command" not in output, output
Jon Hall390696c2015-05-05 17:13:41 -07004210 main.log.info( self.name + ": " + output )
4211 match = re.search( pattern, output )
4212 if match:
4213 setSize = int( match.group( 1 ) )
4214 setMatch = match.group( 2 )
4215 if len( setMatch.split() ) == setSize:
4216 main.log.info( "The size returned by " + self.name +
4217 " matches the number of elements in " +
4218 "the returned set" )
4219 else:
4220 main.log.error( "The size returned by " + self.name +
4221 " does not match the number of " +
4222 "elements in the returned set." )
4223 return setSize
4224 else: # no match
4225 main.log.error( self.name + ": setTestGet did not" +
4226 " match expected output" )
4227 main.log.debug( self.name + " expected: " + pattern )
4228 main.log.debug( self.name + " actual: " + repr( output ) )
4229 return None
4230 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08004231 main.log.exception( "Error in processing '" + cmdStr + "' command." )
acsmarsa4a4d1e2015-07-10 16:01:24 -07004232 return None
Jon Hall390696c2015-05-05 17:13:41 -07004233 except TypeError:
4234 main.log.exception( self.name + ": Object not as expected" )
4235 return None
4236 except pexpect.EOF:
4237 main.log.error( self.name + ": EOF exception found" )
4238 main.log.error( self.name + ": " + self.handle.before )
4239 main.cleanup()
4240 main.exit()
4241 except Exception:
4242 main.log.exception( self.name + ": Uncaught exception!" )
4243 main.cleanup()
4244 main.exit()
4245
Jon Hall80daded2015-05-27 16:07:00 -07004246 def counters( self, jsonFormat=True ):
Jon Hall390696c2015-05-05 17:13:41 -07004247 """
4248 Command to list the various counters in the system.
4249 returns:
Jon Hall80daded2015-05-27 16:07:00 -07004250 if jsonFormat, a string of the json object returned by the cli
4251 command
4252 if not jsonFormat, the normal string output of the cli command
Jon Hall390696c2015-05-05 17:13:41 -07004253 None on error
4254 """
Jon Hall390696c2015-05-05 17:13:41 -07004255 try:
4256 counters = {}
4257 cmdStr = "counters"
Jon Hall80daded2015-05-27 16:07:00 -07004258 if jsonFormat:
4259 cmdStr += " -j"
Jon Hall390696c2015-05-05 17:13:41 -07004260 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004261 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004262 assert "Command not found:" not in output, output
4263 assert "Error executing command" not in output, output
Jon Hall390696c2015-05-05 17:13:41 -07004264 main.log.info( self.name + ": " + output )
Jon Hall80daded2015-05-27 16:07:00 -07004265 return output
Jon Hall390696c2015-05-05 17:13:41 -07004266 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08004267 main.log.exception( "Error in processing 'counters' command." )
Jon Hall80daded2015-05-27 16:07:00 -07004268 return None
Jon Hall390696c2015-05-05 17:13:41 -07004269 except TypeError:
4270 main.log.exception( self.name + ": Object not as expected" )
Jon Hall80daded2015-05-27 16:07:00 -07004271 return None
Jon Hall390696c2015-05-05 17:13:41 -07004272 except pexpect.EOF:
4273 main.log.error( self.name + ": EOF exception found" )
4274 main.log.error( self.name + ": " + self.handle.before )
4275 main.cleanup()
4276 main.exit()
4277 except Exception:
4278 main.log.exception( self.name + ": Uncaught exception!" )
4279 main.cleanup()
4280 main.exit()
4281
Jon Hall935db192016-04-19 00:22:04 -07004282 def counterTestAddAndGet( self, counter, delta=1 ):
Jon Hall390696c2015-05-05 17:13:41 -07004283 """
Jon Halle1a3b752015-07-22 13:02:46 -07004284 CLI command to add a delta to then get a distributed counter.
Jon Hall390696c2015-05-05 17:13:41 -07004285 Required arguments:
4286 counter - The name of the counter to increment.
4287 Optional arguments:
Jon Halle1a3b752015-07-22 13:02:46 -07004288 delta - The long to add to the counter
Jon Hall390696c2015-05-05 17:13:41 -07004289 returns:
4290 integer value of the counter or
4291 None on Error
4292 """
4293 try:
4294 counter = str( counter )
Jon Halle1a3b752015-07-22 13:02:46 -07004295 delta = int( delta )
Jon Hall390696c2015-05-05 17:13:41 -07004296 cmdStr = "counter-test-increment "
Jon Hall390696c2015-05-05 17:13:41 -07004297 cmdStr += counter
Jon Halle1a3b752015-07-22 13:02:46 -07004298 if delta != 1:
4299 cmdStr += " " + str( delta )
Jon Hall390696c2015-05-05 17:13:41 -07004300 output = self.sendline( cmdStr )
Jon Hallfeff3082015-05-19 10:23:26 -07004301 try:
Jon Halla495f562016-05-16 18:03:26 -07004302 assert output is not None, "Error in sendline"
Jon Hallfeff3082015-05-19 10:23:26 -07004303 # TODO: Maybe make this less hardcoded
4304 # ConsistentMap Exceptions
4305 assert "org.onosproject.store.service" not in output
4306 # Node not leader
4307 assert "java.lang.IllegalStateException" not in output
4308 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07004309 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07004310 "command: " + str( output ) )
4311 retryTime = 30 # Conservative time, given by Madan
4312 main.log.info( "Waiting " + str( retryTime ) +
4313 "seconds before retrying." )
4314 time.sleep( retryTime ) # Due to change in mastership
4315 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004316 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004317 assert "Command not found:" not in output, output
4318 assert "Error executing command" not in output, output
Jon Hall390696c2015-05-05 17:13:41 -07004319 main.log.info( self.name + ": " + output )
Jon Halle1a3b752015-07-22 13:02:46 -07004320 pattern = counter + " was updated to (-?\d+)"
Jon Hall390696c2015-05-05 17:13:41 -07004321 match = re.search( pattern, output )
4322 if match:
4323 return int( match.group( 1 ) )
4324 else:
Jon Halle1a3b752015-07-22 13:02:46 -07004325 main.log.error( self.name + ": counterTestAddAndGet did not" +
Jon Hall390696c2015-05-05 17:13:41 -07004326 " match expected output." )
4327 main.log.debug( self.name + " expected: " + pattern )
4328 main.log.debug( self.name + " actual: " + repr( output ) )
4329 return None
4330 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08004331 main.log.exception( "Error in processing '" + cmdStr + "' command." )
Jon Hall390696c2015-05-05 17:13:41 -07004332 return None
4333 except TypeError:
4334 main.log.exception( self.name + ": Object not as expected" )
4335 return None
4336 except pexpect.EOF:
4337 main.log.error( self.name + ": EOF exception found" )
4338 main.log.error( self.name + ": " + self.handle.before )
4339 main.cleanup()
4340 main.exit()
4341 except Exception:
4342 main.log.exception( self.name + ": Uncaught exception!" )
4343 main.cleanup()
4344 main.exit()
4345
Jon Hall935db192016-04-19 00:22:04 -07004346 def counterTestGetAndAdd( self, counter, delta=1 ):
Jon Halle1a3b752015-07-22 13:02:46 -07004347 """
4348 CLI command to get a distributed counter then add a delta to it.
4349 Required arguments:
4350 counter - The name of the counter to increment.
4351 Optional arguments:
4352 delta - The long to add to the counter
Jon Halle1a3b752015-07-22 13:02:46 -07004353 returns:
4354 integer value of the counter or
4355 None on Error
4356 """
4357 try:
4358 counter = str( counter )
4359 delta = int( delta )
4360 cmdStr = "counter-test-increment -g "
Jon Halle1a3b752015-07-22 13:02:46 -07004361 cmdStr += counter
4362 if delta != 1:
4363 cmdStr += " " + str( delta )
4364 output = self.sendline( cmdStr )
4365 try:
Jon Halla495f562016-05-16 18:03:26 -07004366 assert output is not None, "Error in sendline"
Jon Halle1a3b752015-07-22 13:02:46 -07004367 # TODO: Maybe make this less hardcoded
4368 # ConsistentMap Exceptions
4369 assert "org.onosproject.store.service" not in output
4370 # Node not leader
4371 assert "java.lang.IllegalStateException" not in output
4372 except AssertionError:
4373 main.log.error( "Error in processing '" + cmdStr + "' " +
4374 "command: " + str( output ) )
4375 retryTime = 30 # Conservative time, given by Madan
4376 main.log.info( "Waiting " + str( retryTime ) +
4377 "seconds before retrying." )
4378 time.sleep( retryTime ) # Due to change in mastership
4379 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004380 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004381 assert "Command not found:" not in output, output
4382 assert "Error executing command" not in output, output
Jon Halle1a3b752015-07-22 13:02:46 -07004383 main.log.info( self.name + ": " + output )
4384 pattern = counter + " was updated to (-?\d+)"
4385 match = re.search( pattern, output )
4386 if match:
4387 return int( match.group( 1 ) )
4388 else:
4389 main.log.error( self.name + ": counterTestGetAndAdd did not" +
4390 " match expected output." )
4391 main.log.debug( self.name + " expected: " + pattern )
4392 main.log.debug( self.name + " actual: " + repr( output ) )
4393 return None
4394 except AssertionError:
Jon Hallc6793552016-01-19 14:18:37 -08004395 main.log.exception( "Error in processing '" + cmdStr + "' command." )
Jon Halle1a3b752015-07-22 13:02:46 -07004396 return None
4397 except TypeError:
4398 main.log.exception( self.name + ": Object not as expected" )
4399 return None
4400 except pexpect.EOF:
4401 main.log.error( self.name + ": EOF exception found" )
4402 main.log.error( self.name + ": " + self.handle.before )
4403 main.cleanup()
4404 main.exit()
4405 except Exception:
4406 main.log.exception( self.name + ": Uncaught exception!" )
4407 main.cleanup()
4408 main.exit()
4409
YPZhangfebf7302016-05-24 16:45:56 -07004410 def summary( self, jsonFormat=True, timeout=30 ):
kelvin-onlaba297c4d2015-06-01 13:53:55 -07004411 """
4412 Description: Execute summary command in onos
4413 Returns: json object ( summary -j ), returns main.FALSE if there is
4414 no output
4415
4416 """
4417 try:
4418 cmdStr = "summary"
4419 if jsonFormat:
4420 cmdStr += " -j"
YPZhangfebf7302016-05-24 16:45:56 -07004421 handle = self.sendline( cmdStr, timeout=timeout )
Jon Halla495f562016-05-16 18:03:26 -07004422 assert handle is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004423 assert "Command not found:" not in handle, handle
Jon Hall6e709752016-02-01 13:38:46 -08004424 assert "Error:" not in handle, handle
kelvin-onlaba297c4d2015-06-01 13:53:55 -07004425 if not handle:
4426 main.log.error( self.name + ": There is no output in " +
4427 "summary command" )
4428 return main.FALSE
4429 return handle
Jon Hallc6793552016-01-19 14:18:37 -08004430 except AssertionError:
Jon Hall6e709752016-02-01 13:38:46 -08004431 main.log.exception( "{} Error in summary output:".format( self.name ) )
Jon Hallc6793552016-01-19 14:18:37 -08004432 return None
kelvin-onlaba297c4d2015-06-01 13:53:55 -07004433 except TypeError:
4434 main.log.exception( self.name + ": Object not as expected" )
4435 return None
4436 except pexpect.EOF:
4437 main.log.error( self.name + ": EOF exception found" )
4438 main.log.error( self.name + ": " + self.handle.before )
4439 main.cleanup()
4440 main.exit()
4441 except Exception:
4442 main.log.exception( self.name + ": Uncaught exception!" )
4443 main.cleanup()
4444 main.exit()
Jon Hall2a5002c2015-08-21 16:49:11 -07004445
Jon Hall935db192016-04-19 00:22:04 -07004446 def transactionalMapGet( self, keyName ):
Jon Hall2a5002c2015-08-21 16:49:11 -07004447 """
4448 CLI command to get the value of a key in a consistent map using
4449 transactions. This a test function and can only get keys from the
4450 test map hard coded into the cli command
4451 Required arguments:
4452 keyName - The name of the key to get
Jon Hall2a5002c2015-08-21 16:49:11 -07004453 returns:
4454 The string value of the key or
4455 None on Error
4456 """
4457 try:
4458 keyName = str( keyName )
4459 cmdStr = "transactional-map-test-get "
Jon Hall2a5002c2015-08-21 16:49:11 -07004460 cmdStr += keyName
4461 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004462 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004463 assert "Command not found:" not in output, output
Jon Hall2a5002c2015-08-21 16:49:11 -07004464 try:
4465 # TODO: Maybe make this less hardcoded
4466 # ConsistentMap Exceptions
4467 assert "org.onosproject.store.service" not in output
4468 # Node not leader
4469 assert "java.lang.IllegalStateException" not in output
4470 except AssertionError:
4471 main.log.error( "Error in processing '" + cmdStr + "' " +
4472 "command: " + str( output ) )
4473 return None
4474 pattern = "Key-value pair \(" + keyName + ", (?P<value>.+)\) found."
4475 if "Key " + keyName + " not found." in output:
Jon Hall9bfadd22016-05-11 14:48:07 -07004476 main.log.warn( output )
Jon Hall2a5002c2015-08-21 16:49:11 -07004477 return None
4478 else:
4479 match = re.search( pattern, output )
4480 if match:
4481 return match.groupdict()[ 'value' ]
4482 else:
4483 main.log.error( self.name + ": transactionlMapGet did not" +
4484 " match expected output." )
4485 main.log.debug( self.name + " expected: " + pattern )
4486 main.log.debug( self.name + " actual: " + repr( output ) )
4487 return None
Jon Hallc6793552016-01-19 14:18:37 -08004488 except AssertionError:
4489 main.log.exception( "" )
4490 return None
Jon Hall2a5002c2015-08-21 16:49:11 -07004491 except TypeError:
4492 main.log.exception( self.name + ": Object not as expected" )
4493 return None
4494 except pexpect.EOF:
4495 main.log.error( self.name + ": EOF exception found" )
4496 main.log.error( self.name + ": " + self.handle.before )
4497 main.cleanup()
4498 main.exit()
4499 except Exception:
4500 main.log.exception( self.name + ": Uncaught exception!" )
4501 main.cleanup()
4502 main.exit()
4503
Jon Hall935db192016-04-19 00:22:04 -07004504 def transactionalMapPut( self, numKeys, value ):
Jon Hall2a5002c2015-08-21 16:49:11 -07004505 """
4506 CLI command to put a value into 'numKeys' number of keys in a
4507 consistent map using transactions. This a test function and can only
4508 put into keys named 'Key#' of the test map hard coded into the cli command
4509 Required arguments:
4510 numKeys - Number of keys to add the value to
4511 value - The string value to put into the keys
Jon Hall2a5002c2015-08-21 16:49:11 -07004512 returns:
4513 A dictionary whose keys are the name of the keys put into the map
4514 and the values of the keys are dictionaries whose key-values are
4515 'value': value put into map and optionaly
4516 'oldValue': Previous value in the key or
4517 None on Error
4518
4519 Example output
4520 { 'Key1': {'oldValue': 'oldTestValue', 'value': 'Testing'},
4521 'Key2': {'value': 'Testing'} }
4522 """
4523 try:
4524 numKeys = str( numKeys )
4525 value = str( value )
4526 cmdStr = "transactional-map-test-put "
Jon Hall2a5002c2015-08-21 16:49:11 -07004527 cmdStr += numKeys + " " + value
4528 output = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004529 assert output is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004530 assert "Command not found:" not in output, output
Jon Hall2a5002c2015-08-21 16:49:11 -07004531 try:
4532 # TODO: Maybe make this less hardcoded
4533 # ConsistentMap Exceptions
4534 assert "org.onosproject.store.service" not in output
4535 # Node not leader
4536 assert "java.lang.IllegalStateException" not in output
4537 except AssertionError:
4538 main.log.error( "Error in processing '" + cmdStr + "' " +
4539 "command: " + str( output ) )
4540 return None
4541 newPattern = 'Created Key (?P<key>(\w)+) with value (?P<value>(.)+)\.'
4542 updatedPattern = "Put (?P<value>(.)+) into key (?P<key>(\w)+)\. The old value was (?P<oldValue>(.)+)\."
4543 results = {}
4544 for line in output.splitlines():
4545 new = re.search( newPattern, line )
4546 updated = re.search( updatedPattern, line )
4547 if new:
4548 results[ new.groupdict()[ 'key' ] ] = { 'value': new.groupdict()[ 'value' ] }
4549 elif updated:
4550 results[ updated.groupdict()[ 'key' ] ] = { 'value': updated.groupdict()[ 'value' ],
Jon Hallc6793552016-01-19 14:18:37 -08004551 'oldValue': updated.groupdict()[ 'oldValue' ] }
Jon Hall2a5002c2015-08-21 16:49:11 -07004552 else:
4553 main.log.error( self.name + ": transactionlMapGet did not" +
4554 " match expected output." )
Jon Hallc6793552016-01-19 14:18:37 -08004555 main.log.debug( "{} expected: {!r} or {!r}".format( self.name,
4556 newPattern,
4557 updatedPattern ) )
Jon Hall2a5002c2015-08-21 16:49:11 -07004558 main.log.debug( self.name + " actual: " + repr( output ) )
4559 return results
Jon Hallc6793552016-01-19 14:18:37 -08004560 except AssertionError:
4561 main.log.exception( "" )
4562 return None
Jon Hall2a5002c2015-08-21 16:49:11 -07004563 except TypeError:
4564 main.log.exception( self.name + ": Object not as expected" )
4565 return None
4566 except pexpect.EOF:
4567 main.log.error( self.name + ": EOF exception found" )
4568 main.log.error( self.name + ": " + self.handle.before )
4569 main.cleanup()
4570 main.exit()
4571 except Exception:
4572 main.log.exception( self.name + ": Uncaught exception!" )
4573 main.cleanup()
4574 main.exit()
Jon Hallc6793552016-01-19 14:18:37 -08004575
acsmarsdaea66c2015-09-03 11:44:06 -07004576 def maps( self, jsonFormat=True ):
4577 """
4578 Description: Returns result of onos:maps
4579 Optional:
4580 * jsonFormat: enable json formatting of output
4581 """
4582 try:
4583 cmdStr = "maps"
4584 if jsonFormat:
4585 cmdStr += " -j"
4586 handle = self.sendline( cmdStr )
Jon Halla495f562016-05-16 18:03:26 -07004587 assert handle is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004588 assert "Command not found:" not in handle, handle
acsmarsdaea66c2015-09-03 11:44:06 -07004589 return handle
Jon Hallc6793552016-01-19 14:18:37 -08004590 except AssertionError:
4591 main.log.exception( "" )
4592 return None
acsmarsdaea66c2015-09-03 11:44:06 -07004593 except TypeError:
4594 main.log.exception( self.name + ": Object not as expected" )
4595 return None
4596 except pexpect.EOF:
4597 main.log.error( self.name + ": EOF exception found" )
4598 main.log.error( self.name + ": " + self.handle.before )
4599 main.cleanup()
4600 main.exit()
4601 except Exception:
4602 main.log.exception( self.name + ": Uncaught exception!" )
4603 main.cleanup()
4604 main.exit()
GlennRC050596c2015-11-18 17:06:41 -08004605
4606 def getSwController( self, uri, jsonFormat=True ):
4607 """
4608 Descrition: Gets the controller information from the device
4609 """
4610 try:
4611 cmd = "device-controllers "
4612 if jsonFormat:
4613 cmd += "-j "
4614 response = self.sendline( cmd + uri )
Jon Halla495f562016-05-16 18:03:26 -07004615 assert response is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004616 assert "Command not found:" not in response, response
GlennRC050596c2015-11-18 17:06:41 -08004617 return response
Jon Hallc6793552016-01-19 14:18:37 -08004618 except AssertionError:
4619 main.log.exception( "" )
4620 return None
GlennRC050596c2015-11-18 17:06:41 -08004621 except TypeError:
4622 main.log.exception( self.name + ": Object not as expected" )
4623 return None
4624 except pexpect.EOF:
4625 main.log.error( self.name + ": EOF exception found" )
4626 main.log.error( self.name + ": " + self.handle.before )
4627 main.cleanup()
4628 main.exit()
4629 except Exception:
4630 main.log.exception( self.name + ": Uncaught exception!" )
4631 main.cleanup()
4632 main.exit()
4633
4634 def setSwController( self, uri, ip, proto="tcp", port="6653", jsonFormat=True ):
4635 """
4636 Descrition: sets the controller(s) for the specified device
4637
4638 Parameters:
4639 Required: uri - String: The uri of the device(switch).
4640 ip - String or List: The ip address of the controller.
4641 This parameter can be formed in a couple of different ways.
4642 VALID:
4643 10.0.0.1 - just the ip address
4644 tcp:10.0.0.1 - the protocol and the ip address
4645 tcp:10.0.0.1:6653 - the protocol and port can be specified,
4646 so that you can add controllers with different
4647 protocols and ports
4648 INVALID:
4649 10.0.0.1:6653 - this is not supported by ONOS
4650
4651 Optional: proto - The type of connection e.g. tcp, ssl. If a list of ips are given
4652 port - The port number.
4653 jsonFormat - If set ONOS will output in json NOTE: This is currently not supported
4654
4655 Returns: main.TRUE if ONOS returns without any errors, otherwise returns main.FALSE
4656 """
4657 try:
4658 cmd = "device-setcontrollers"
4659
4660 if jsonFormat:
4661 cmd += " -j"
4662 cmd += " " + uri
4663 if isinstance( ip, str ):
4664 ip = [ip]
4665 for item in ip:
4666 if ":" in item:
4667 sitem = item.split( ":" )
4668 if len(sitem) == 3:
4669 cmd += " " + item
4670 elif "." in sitem[1]:
4671 cmd += " {}:{}".format(item, port)
4672 else:
4673 main.log.error( "Malformed entry: " + item )
4674 raise TypeError
4675 else:
4676 cmd += " {}:{}:{}".format( proto, item, port )
GlennRC050596c2015-11-18 17:06:41 -08004677 response = self.sendline( cmd )
Jon Halla495f562016-05-16 18:03:26 -07004678 assert response is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004679 assert "Command not found:" not in response, response
GlennRC050596c2015-11-18 17:06:41 -08004680 if "Error" in response:
4681 main.log.error( response )
4682 return main.FALSE
GlennRC050596c2015-11-18 17:06:41 -08004683 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -08004684 except AssertionError:
4685 main.log.exception( "" )
4686 return None
GlennRC050596c2015-11-18 17:06:41 -08004687 except TypeError:
4688 main.log.exception( self.name + ": Object not as expected" )
4689 return main.FALSE
4690 except pexpect.EOF:
4691 main.log.error( self.name + ": EOF exception found" )
4692 main.log.error( self.name + ": " + self.handle.before )
4693 main.cleanup()
4694 main.exit()
4695 except Exception:
4696 main.log.exception( self.name + ": Uncaught exception!" )
4697 main.cleanup()
4698 main.exit()
GlennRC20fc6522015-12-23 23:26:57 -08004699
4700 def removeDevice( self, device ):
4701 '''
4702 Description:
4703 Remove a device from ONOS by passing the uri of the device(s).
4704 Parameters:
4705 device - (str or list) the id or uri of the device ex. "of:0000000000000001"
4706 Returns:
4707 Returns main.FALSE if an exception is thrown or an error is present
4708 in the response. Otherwise, returns main.TRUE.
4709 NOTE:
4710 If a host cannot be removed, then this function will return main.FALSE
4711 '''
4712 try:
4713 if type( device ) is str:
You Wang823f5022016-08-18 15:24:41 -07004714 deviceStr = device
4715 device = []
4716 device.append( deviceStr )
GlennRC20fc6522015-12-23 23:26:57 -08004717
4718 for d in device:
4719 time.sleep( 1 )
4720 response = self.sendline( "device-remove {}".format( d ) )
Jon Halla495f562016-05-16 18:03:26 -07004721 assert response is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004722 assert "Command not found:" not in response, response
GlennRC20fc6522015-12-23 23:26:57 -08004723 if "Error" in response:
4724 main.log.warn( "Error for device: {}\nResponse: {}".format( d, response ) )
4725 return main.FALSE
GlennRC20fc6522015-12-23 23:26:57 -08004726 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -08004727 except AssertionError:
4728 main.log.exception( "" )
4729 return main.FALSE
GlennRC20fc6522015-12-23 23:26:57 -08004730 except TypeError:
4731 main.log.exception( self.name + ": Object not as expected" )
4732 return main.FALSE
4733 except pexpect.EOF:
4734 main.log.error( self.name + ": EOF exception found" )
4735 main.log.error( self.name + ": " + self.handle.before )
4736 main.cleanup()
4737 main.exit()
4738 except Exception:
4739 main.log.exception( self.name + ": Uncaught exception!" )
4740 main.cleanup()
4741 main.exit()
4742
4743 def removeHost( self, host ):
4744 '''
4745 Description:
4746 Remove a host from ONOS by passing the id of the host(s)
4747 Parameters:
4748 hostId - (str or list) the id or mac of the host ex. "00:00:00:00:00:01"
4749 Returns:
4750 Returns main.FALSE if an exception is thrown or an error is present
4751 in the response. Otherwise, returns main.TRUE.
4752 NOTE:
4753 If a host cannot be removed, then this function will return main.FALSE
4754 '''
4755 try:
4756 if type( host ) is str:
4757 host = list( host )
4758
4759 for h in host:
4760 time.sleep( 1 )
4761 response = self.sendline( "host-remove {}".format( h ) )
Jon Halla495f562016-05-16 18:03:26 -07004762 assert response is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004763 assert "Command not found:" not in response, response
GlennRC20fc6522015-12-23 23:26:57 -08004764 if "Error" in response:
4765 main.log.warn( "Error for host: {}\nResponse: {}".format( h, response ) )
4766 return main.FALSE
GlennRC20fc6522015-12-23 23:26:57 -08004767 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -08004768 except AssertionError:
4769 main.log.exception( "" )
4770 return None
GlennRC20fc6522015-12-23 23:26:57 -08004771 except TypeError:
4772 main.log.exception( self.name + ": Object not as expected" )
4773 return main.FALSE
4774 except pexpect.EOF:
4775 main.log.error( self.name + ": EOF exception found" )
4776 main.log.error( self.name + ": " + self.handle.before )
4777 main.cleanup()
4778 main.exit()
4779 except Exception:
4780 main.log.exception( self.name + ": Uncaught exception!" )
4781 main.cleanup()
4782 main.exit()
GlennRCed771242016-01-13 17:02:47 -08004783
YPZhangfebf7302016-05-24 16:45:56 -07004784 def link( self, begin, end, state, timeout=30, showResponse=True ):
GlennRCed771242016-01-13 17:02:47 -08004785 '''
4786 Description:
4787 Bring link down or up in the null-provider.
4788 params:
4789 begin - (string) One end of a device or switch.
4790 end - (string) the other end of the device or switch
4791 returns:
4792 main.TRUE if no exceptions were thrown and no Errors are
4793 present in the resoponse. Otherwise, returns main.FALSE
4794 '''
4795 try:
Jon Hallc6793552016-01-19 14:18:37 -08004796 cmd = "null-link null:{} null:{} {}".format( begin, end, state )
YPZhangfebf7302016-05-24 16:45:56 -07004797 response = self.sendline( cmd, showResponse=showResponse, timeout=timeout )
Jon Halla495f562016-05-16 18:03:26 -07004798 assert response is not None, "Error in sendline"
Jon Hallc6793552016-01-19 14:18:37 -08004799 assert "Command not found:" not in response, response
GlennRCed771242016-01-13 17:02:47 -08004800 if "Error" in response or "Failure" in response:
4801 main.log.error( response )
4802 return main.FALSE
GlennRCed771242016-01-13 17:02:47 -08004803 return main.TRUE
Jon Hallc6793552016-01-19 14:18:37 -08004804 except AssertionError:
4805 main.log.exception( "" )
4806 return None
GlennRCed771242016-01-13 17:02:47 -08004807 except TypeError:
4808 main.log.exception( self.name + ": Object not as expected" )
4809 return main.FALSE
4810 except pexpect.EOF:
4811 main.log.error( self.name + ": EOF exception found" )
4812 main.log.error( self.name + ": " + self.handle.before )
4813 main.cleanup()
4814 main.exit()
4815 except Exception:
4816 main.log.exception( self.name + ": Uncaught exception!" )
4817 main.cleanup()
4818 main.exit()
4819
Flavio Castro82ee2f62016-06-07 15:04:12 -07004820 def portstate(self, dpid='of:0000000000000102', port='2', state='enable'):
4821 '''
4822 Description:
4823 Changes the state of port in an OF switch by means of the
4824 PORTSTATUS OF messages.
4825 params:
4826 dpid - (string) Datapath ID of the device
4827 port - (string) target port in the device
4828 state - (string) target state (enable or disabled)
4829 returns:
4830 main.TRUE if no exceptions were thrown and no Errors are
4831 present in the resoponse. Otherwise, returns main.FALSE
4832 '''
4833 try:
4834 cmd = "portstate {} {} {}".format( dpid, port, state )
4835 response = self.sendline( cmd, showResponse=True )
4836 assert response is not None, "Error in sendline"
4837 assert "Command not found:" not in response, response
4838 if "Error" in response or "Failure" in response:
4839 main.log.error( response )
4840 return main.FALSE
4841 return main.TRUE
4842 except AssertionError:
4843 main.log.exception( "" )
4844 return None
4845 except TypeError:
4846 main.log.exception( self.name + ": Object not as expected" )
4847 return main.FALSE
4848 except pexpect.EOF:
4849 main.log.error( self.name + ": EOF exception found" )
4850 main.log.error( self.name + ": " + self.handle.before )
4851 main.cleanup()
4852 main.exit()
4853 except Exception:
4854 main.log.exception( self.name + ": Uncaught exception!" )
4855 main.cleanup()
4856 main.exit()
4857
4858 def logSet( self, level="INFO", app="org.onosproject" ):
4859 """
4860 Set the logging level to lvl for a specific app
4861 returns main.TRUE on success
4862 returns main.FALSE if Error occurred
4863 if noExit is True, TestON will not exit, but clean up
4864 Available level: DEBUG, TRACE, INFO, WARN, ERROR
4865 Level defaults to INFO
4866 """
4867 try:
4868 self.handle.sendline( "log:set %s %s" %( level, app ) )
4869 self.handle.expect( "onos>" )
4870
4871 response = self.handle.before
4872 if re.search( "Error", response ):
4873 return main.FALSE
4874 return main.TRUE
4875 except pexpect.TIMEOUT:
4876 main.log.exception( self.name + ": TIMEOUT exception found" )
4877 main.cleanup()
4878 main.exit()
4879 except pexpect.EOF:
4880 main.log.error( self.name + ": EOF exception found" )
4881 main.log.error( self.name + ": " + self.handle.before )
4882 main.cleanup()
4883 main.exit()
4884 except Exception:
4885 main.log.exception( self.name + ": Uncaught exception!" )
4886 main.cleanup()
4887 main.exit()
You Wangdb8cd0a2016-05-26 15:19:45 -07004888
4889 def getGraphDict( self, timeout=60, includeHost=False ):
4890 """
4891 Return a dictionary which describes the latest network topology data as a
4892 graph.
4893 An example of the dictionary:
4894 { vertex1: { 'edges': ..., 'name': ..., 'protocol': ... },
4895 vertex2: { 'edges': ..., 'name': ..., 'protocol': ... } }
4896 Each vertex should at least have an 'edges' attribute which describes the
4897 adjacency information. The value of 'edges' attribute is also represented by
4898 a dictionary, which maps each edge (identified by the neighbor vertex) to a
4899 list of attributes.
4900 An example of the edges dictionary:
4901 'edges': { vertex2: { 'port': ..., 'weight': ... },
4902 vertex3: { 'port': ..., 'weight': ... } }
4903 If includeHost == True, all hosts (and host-switch links) will be included
4904 in topology data.
4905 """
4906 graphDict = {}
4907 try:
4908 links = self.links()
4909 links = json.loads( links )
4910 devices = self.devices()
4911 devices = json.loads( devices )
4912 idToDevice = {}
4913 for device in devices:
4914 idToDevice[ device[ 'id' ] ] = device
4915 if includeHost:
4916 hosts = self.hosts()
4917 # FIXME: support 'includeHost' argument
4918 for link in links:
4919 nodeA = link[ 'src' ][ 'device' ]
4920 nodeB = link[ 'dst' ][ 'device' ]
4921 assert idToDevice[ nodeA ][ 'available' ] and idToDevice[ nodeB ][ 'available' ]
4922 if not nodeA in graphDict.keys():
4923 graphDict[ nodeA ] = { 'edges':{},
4924 'dpid':idToDevice[ nodeA ][ 'id' ][3:],
4925 'type':idToDevice[ nodeA ][ 'type' ],
4926 'available':idToDevice[ nodeA ][ 'available' ],
4927 'role':idToDevice[ nodeA ][ 'role' ],
4928 'mfr':idToDevice[ nodeA ][ 'mfr' ],
4929 'hw':idToDevice[ nodeA ][ 'hw' ],
4930 'sw':idToDevice[ nodeA ][ 'sw' ],
4931 'serial':idToDevice[ nodeA ][ 'serial' ],
4932 'chassisId':idToDevice[ nodeA ][ 'chassisId' ],
4933 'annotations':idToDevice[ nodeA ][ 'annotations' ]}
4934 else:
4935 # Assert nodeB is not connected to any current links of nodeA
4936 assert nodeB not in graphDict[ nodeA ][ 'edges' ].keys()
4937 graphDict[ nodeA ][ 'edges' ][ nodeB ] = { 'port':link[ 'src' ][ 'port' ],
4938 'type':link[ 'type' ],
4939 'state':link[ 'state' ] }
4940 return graphDict
4941 except ( TypeError, ValueError ):
4942 main.log.exception( self.name + ": Object not as expected" )
4943 return None
4944 except KeyError:
4945 main.log.exception( self.name + ": KeyError exception found" )
4946 return None
4947 except AssertionError:
4948 main.log.exception( self.name + ": AssertionError exception found" )
4949 return None
4950 except pexpect.EOF:
4951 main.log.error( self.name + ": EOF exception found" )
4952 main.log.error( self.name + ": " + self.handle.before )
4953 return None
4954 except Exception:
4955 main.log.exception( self.name + ": Uncaught exception!" )
4956 return None
YPZhangcbc2a062016-07-11 10:55:44 -07004957
4958 def getIntentPerfSummary( self ):
4959 '''
4960 Send command to check intent-perf summary
4961 Returns: dictionary for intent-perf summary
4962 if something wrong, function will return None
4963 '''
4964 cmd = "intent-perf -s"
4965 respDic = {}
4966 resp = self.sendline( cmd )
4967 try:
4968 # Generate the dictionary to return
4969 for l in resp.split( "\n" ):
4970 # Delete any white space in line
4971 temp = re.sub( r'\s+', '', l )
4972 temp = temp.split( ":" )
4973 respDic[ temp[0] ] = temp[ 1 ]
4974
4975 except (TypeError, ValueError):
4976 main.log.exception( self.name + ": Object not as expected" )
4977 return None
4978 except KeyError:
4979 main.log.exception( self.name + ": KeyError exception found" )
4980 return None
4981 except AssertionError:
4982 main.log.exception( self.name + ": AssertionError exception found" )
4983 return None
4984 except pexpect.EOF:
4985 main.log.error( self.name + ": EOF exception found" )
4986 main.log.error( self.name + ": " + self.handle.before )
4987 return None
4988 except Exception:
4989 main.log.exception( self.name + ": Uncaught exception!" )
4990 return None
4991 return respDic
4992
4993