blob: a361acae9146d9f0660547cdbf6ca18c23004b41 [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
17
kelvin8ec71442015-01-15 16:57:00 -080018"""
andrewonlab95ce8322014-10-13 14:12:04 -040019import pexpect
20import re
Jon Hall30b82fa2015-03-04 17:15:43 -080021import json
22import types
Jon Hallbd16b922015-03-26 17:53:15 -070023import time
kelvin-onlaba4074292015-07-09 15:19:49 -070024import os
andrewonlab95ce8322014-10-13 14:12:04 -040025from drivers.common.clidriver import CLI
26
andrewonlab95ce8322014-10-13 14:12:04 -040027
kelvin8ec71442015-01-15 16:57:00 -080028class OnosCliDriver( CLI ):
andrewonlab95ce8322014-10-13 14:12:04 -040029
kelvin8ec71442015-01-15 16:57:00 -080030 def __init__( self ):
31 """
32 Initialize client
33 """
Jon Hallefbd9792015-03-05 16:11:36 -080034 self.name = None
35 self.home = None
36 self.handle = None
kelvin8ec71442015-01-15 16:57:00 -080037 super( CLI, self ).__init__()
38
39 def connect( self, **connectargs ):
40 """
andrewonlab95ce8322014-10-13 14:12:04 -040041 Creates ssh handle for ONOS cli.
kelvin8ec71442015-01-15 16:57:00 -080042 """
andrewonlab95ce8322014-10-13 14:12:04 -040043 try:
44 for key in connectargs:
kelvin8ec71442015-01-15 16:57:00 -080045 vars( self )[ key ] = connectargs[ key ]
andrew@onlab.us658ec012015-03-11 15:13:09 -070046 self.home = "~/onos"
andrewonlab95ce8322014-10-13 14:12:04 -040047 for key in self.options:
48 if key == "home":
kelvin8ec71442015-01-15 16:57:00 -080049 self.home = self.options[ 'home' ]
andrewonlab95ce8322014-10-13 14:12:04 -040050 break
kelvin-onlabfb521662015-02-27 09:52:40 -080051 if self.home is None or self.home == "":
Jon Halle94919c2015-03-23 11:42:57 -070052 self.home = "~/onos"
andrewonlab95ce8322014-10-13 14:12:04 -040053
kelvin-onlaba4074292015-07-09 15:19:49 -070054 for key in self.options:
55 if key == 'onosIp':
56 self.onosIp = self.options[ 'onosIp' ]
57 break
58
kelvin8ec71442015-01-15 16:57:00 -080059 self.name = self.options[ 'name' ]
kelvin-onlaba4074292015-07-09 15:19:49 -070060
61 try:
62 if os.getenv( str( self.ip_address ) ) != None:
63 self.ip_address = os.getenv( str( self.ip_address ) )
64 else:
65 main.log.info( self.name +
66 ": Trying to connect to " +
67 self.ip_address )
68
69 except KeyError:
70 main.log.info( "Invalid host name," +
71 " connecting to local host instead" )
72 self.ip_address = 'localhost'
73 except Exception as inst:
74 main.log.error( "Uncaught exception: " + str( inst ) )
75
kelvin8ec71442015-01-15 16:57:00 -080076 self.handle = super( OnosCliDriver, self ).connect(
kelvin-onlab08679eb2015-01-21 16:11:48 -080077 user_name=self.user_name,
78 ip_address=self.ip_address,
kelvin-onlab898a6c62015-01-16 14:13:53 -080079 port=self.port,
80 pwd=self.pwd,
81 home=self.home )
andrewonlab95ce8322014-10-13 14:12:04 -040082
kelvin8ec71442015-01-15 16:57:00 -080083 self.handle.sendline( "cd " + self.home )
84 self.handle.expect( "\$" )
andrewonlab95ce8322014-10-13 14:12:04 -040085 if self.handle:
86 return self.handle
kelvin8ec71442015-01-15 16:57:00 -080087 else:
88 main.log.info( "NO ONOS HANDLE" )
andrewonlab95ce8322014-10-13 14:12:04 -040089 return main.FALSE
Jon Halld4d4b372015-01-28 16:02:41 -080090 except TypeError:
91 main.log.exception( self.name + ": Object not as expected" )
92 return None
andrewonlab95ce8322014-10-13 14:12:04 -040093 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -080094 main.log.error( self.name + ": EOF exception found" )
95 main.log.error( self.name + ": " + self.handle.before )
andrewonlab95ce8322014-10-13 14:12:04 -040096 main.cleanup()
97 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -080098 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -080099 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ce8322014-10-13 14:12:04 -0400100 main.cleanup()
101 main.exit()
102
kelvin8ec71442015-01-15 16:57:00 -0800103 def disconnect( self ):
104 """
andrewonlab95ce8322014-10-13 14:12:04 -0400105 Called when Test is complete to disconnect the ONOS handle.
kelvin8ec71442015-01-15 16:57:00 -0800106 """
Jon Halld61331b2015-02-17 16:35:47 -0800107 response = main.TRUE
andrewonlab95ce8322014-10-13 14:12:04 -0400108 try:
Jon Hall61282e32015-03-19 11:34:11 -0700109 if self.handle:
110 i = self.logout()
111 if i == main.TRUE:
112 self.handle.sendline( "" )
113 self.handle.expect( "\$" )
114 self.handle.sendline( "exit" )
115 self.handle.expect( "closed" )
Jon Halld4d4b372015-01-28 16:02:41 -0800116 except TypeError:
117 main.log.exception( self.name + ": Object not as expected" )
Jon Halld61331b2015-02-17 16:35:47 -0800118 response = main.FALSE
andrewonlab95ce8322014-10-13 14:12:04 -0400119 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800120 main.log.error( self.name + ": EOF exception found" )
121 main.log.error( self.name + ": " + self.handle.before )
Jon Hall61282e32015-03-19 11:34:11 -0700122 except ValueError:
Jon Hall1a77a1e2015-04-06 10:41:13 -0700123 main.log.exception( "Exception in disconnect of " + self.name )
Jon Hall61282e32015-03-19 11:34:11 -0700124 response = main.TRUE
Jon Hallfebb1c72015-03-05 13:30:09 -0800125 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800126 main.log.exception( self.name + ": Connection failed to the host" )
andrewonlab95ce8322014-10-13 14:12:04 -0400127 response = main.FALSE
128 return response
129
kelvin8ec71442015-01-15 16:57:00 -0800130 def logout( self ):
131 """
andrewonlab38d2b4a2014-11-13 16:28:47 -0500132 Sends 'logout' command to ONOS cli
Jon Hall61282e32015-03-19 11:34:11 -0700133 Returns main.TRUE if exited CLI and
134 main.FALSE on timeout (not guranteed you are disconnected)
135 None on TypeError
136 Exits test on unknown error or pexpect exits unexpectedly
kelvin8ec71442015-01-15 16:57:00 -0800137 """
andrewonlab38d2b4a2014-11-13 16:28:47 -0500138 try:
Jon Hall61282e32015-03-19 11:34:11 -0700139 if self.handle:
140 self.handle.sendline( "" )
141 i = self.handle.expect( [ "onos>", "\$", pexpect.TIMEOUT ],
142 timeout=10 )
143 if i == 0: # In ONOS CLI
144 self.handle.sendline( "logout" )
145 self.handle.expect( "\$" )
146 return main.TRUE
147 elif i == 1: # not in CLI
148 return main.TRUE
149 elif i == 3: # Timeout
150 return main.FALSE
151 else:
andrewonlab9627f432014-11-14 12:45:10 -0500152 return main.TRUE
Jon Halld4d4b372015-01-28 16:02:41 -0800153 except TypeError:
154 main.log.exception( self.name + ": Object not as expected" )
155 return None
andrewonlab38d2b4a2014-11-13 16:28:47 -0500156 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800157 main.log.error( self.name + ": eof exception found" )
Jon Hall61282e32015-03-19 11:34:11 -0700158 main.log.error( self.name + ": " + self.handle.before )
andrewonlab38d2b4a2014-11-13 16:28:47 -0500159 main.cleanup()
160 main.exit()
Jon Hall61282e32015-03-19 11:34:11 -0700161 except ValueError:
Jon Hall5aa168b2015-03-23 14:23:09 -0700162 main.log.error( self.name +
163 "ValueError exception in logout method" )
Jon Hallfebb1c72015-03-05 13:30:09 -0800164 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800165 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab38d2b4a2014-11-13 16:28:47 -0500166 main.cleanup()
167 main.exit()
168
kelvin-onlabd3b64892015-01-20 13:26:24 -0800169 def setCell( self, cellname ):
kelvin8ec71442015-01-15 16:57:00 -0800170 """
andrewonlab95ce8322014-10-13 14:12:04 -0400171 Calls 'cell <name>' to set the environment variables on ONOSbench
kelvin8ec71442015-01-15 16:57:00 -0800172
andrewonlab95ce8322014-10-13 14:12:04 -0400173 Before issuing any cli commands, set the environment variable first.
kelvin8ec71442015-01-15 16:57:00 -0800174 """
andrewonlab95ce8322014-10-13 14:12:04 -0400175 try:
176 if not cellname:
kelvin8ec71442015-01-15 16:57:00 -0800177 main.log.error( "Must define cellname" )
andrewonlab95ce8322014-10-13 14:12:04 -0400178 main.cleanup()
179 main.exit()
180 else:
kelvin8ec71442015-01-15 16:57:00 -0800181 self.handle.sendline( "cell " + str( cellname ) )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800182 # Expect the cellname in the ONOSCELL variable.
kelvin8ec71442015-01-15 16:57:00 -0800183 # Note that this variable name is subject to change
andrewonlab95ce8322014-10-13 14:12:04 -0400184 # and that this driver will have to change accordingly
Cameron Franke9c94fb02015-01-21 10:20:20 -0800185 self.handle.expect(str(cellname))
andrew@onlab.usc400b112015-01-21 15:33:19 -0800186 handleBefore = self.handle.before
187 handleAfter = self.handle.after
kelvin8ec71442015-01-15 16:57:00 -0800188 # Get the rest of the handle
Cameron Franke9c94fb02015-01-21 10:20:20 -0800189 self.handle.sendline("")
190 self.handle.expect("\$")
andrew@onlab.usc400b112015-01-21 15:33:19 -0800191 handleMore = self.handle.before
andrewonlab95ce8322014-10-13 14:12:04 -0400192
kelvin-onlabd3b64892015-01-20 13:26:24 -0800193 main.log.info( "Cell call returned: " + handleBefore +
194 handleAfter + handleMore )
andrewonlab95ce8322014-10-13 14:12:04 -0400195
196 return main.TRUE
197
Jon Halld4d4b372015-01-28 16:02:41 -0800198 except TypeError:
199 main.log.exception( self.name + ": Object not as expected" )
200 return None
andrewonlab95ce8322014-10-13 14:12:04 -0400201 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800202 main.log.error( self.name + ": eof exception found" )
203 main.log.error( self.name + ": " + self.handle.before )
andrewonlab95ce8322014-10-13 14:12:04 -0400204 main.cleanup()
205 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800206 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800207 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ce8322014-10-13 14:12:04 -0400208 main.cleanup()
209 main.exit()
kelvin8ec71442015-01-15 16:57:00 -0800210
pingping-lin57a56ce2015-05-20 16:43:48 -0700211 def startOnosCli( self, ONOSIp, karafTimeout="",
212 commandlineTimeout=10, onosStartTimeout=60 ):
kelvin8ec71442015-01-15 16:57:00 -0800213 """
Jon Hallefbd9792015-03-05 16:11:36 -0800214 karafTimeout is an optional argument. karafTimeout value passed
kelvin-onlabd3b64892015-01-20 13:26:24 -0800215 by user would be used to set the current karaf shell idle timeout.
216 Note that when ever this property is modified the shell will exit and
Hari Krishnad7b9c202015-01-05 10:38:14 -0800217 the subsequent login would reflect new idle timeout.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800218 Below is an example to start a session with 60 seconds idle timeout
219 ( input value is in milliseconds ):
kelvin8ec71442015-01-15 16:57:00 -0800220
Hari Krishna25d42f72015-01-05 15:08:28 -0800221 tValue = "60000"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800222 main.ONOScli1.startOnosCli( ONOSIp, karafTimeout=tValue )
kelvin8ec71442015-01-15 16:57:00 -0800223
kelvin-onlabd3b64892015-01-20 13:26:24 -0800224 Note: karafTimeout is left as str so that this could be read
225 and passed to startOnosCli from PARAMS file as str.
kelvin8ec71442015-01-15 16:57:00 -0800226 """
andrewonlab95ce8322014-10-13 14:12:04 -0400227 try:
kelvin8ec71442015-01-15 16:57:00 -0800228 self.handle.sendline( "" )
229 x = self.handle.expect( [
pingping-lin57a56ce2015-05-20 16:43:48 -0700230 "\$", "onos>" ], commandlineTimeout)
andrewonlab48829f62014-11-17 13:49:01 -0500231
232 if x == 1:
kelvin8ec71442015-01-15 16:57:00 -0800233 main.log.info( "ONOS cli is already running" )
andrewonlab48829f62014-11-17 13:49:01 -0500234 return main.TRUE
andrewonlab95ce8322014-10-13 14:12:04 -0400235
kelvin8ec71442015-01-15 16:57:00 -0800236 # Wait for onos start ( -w ) and enter onos cli
kelvin-onlabd3b64892015-01-20 13:26:24 -0800237 self.handle.sendline( "onos -w " + str( ONOSIp ) )
kelvin8ec71442015-01-15 16:57:00 -0800238 i = self.handle.expect( [
239 "onos>",
pingping-lin57a56ce2015-05-20 16:43:48 -0700240 pexpect.TIMEOUT ], onosStartTimeout )
andrewonlab2a7ea9b2014-10-24 12:21:05 -0400241
242 if i == 0:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800243 main.log.info( str( ONOSIp ) + " CLI Started successfully" )
Hari Krishnae36ef212015-01-04 14:09:13 -0800244 if karafTimeout:
kelvin8ec71442015-01-15 16:57:00 -0800245 self.handle.sendline(
Hari Krishnaac4e1782015-01-26 12:09:12 -0800246 "config:property-set -p org.apache.karaf.shell\
247 sshIdleTimeout " +
kelvin8ec71442015-01-15 16:57:00 -0800248 karafTimeout )
249 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800250 self.handle.sendline( "onos -w " + str( ONOSIp ) )
kelvin8ec71442015-01-15 16:57:00 -0800251 self.handle.expect( "onos>" )
andrewonlab2a7ea9b2014-10-24 12:21:05 -0400252 return main.TRUE
253 else:
kelvin8ec71442015-01-15 16:57:00 -0800254 # If failed, send ctrl+c to process and try again
255 main.log.info( "Starting CLI failed. Retrying..." )
256 self.handle.send( "\x03" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800257 self.handle.sendline( "onos -w " + str( ONOSIp ) )
kelvin8ec71442015-01-15 16:57:00 -0800258 i = self.handle.expect( [ "onos>", pexpect.TIMEOUT ],
259 timeout=30 )
andrewonlab3a7c3c72014-10-24 17:21:03 -0400260 if i == 0:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800261 main.log.info( str( ONOSIp ) + " CLI Started " +
kelvin8ec71442015-01-15 16:57:00 -0800262 "successfully after retry attempt" )
Hari Krishnae36ef212015-01-04 14:09:13 -0800263 if karafTimeout:
kelvin8ec71442015-01-15 16:57:00 -0800264 self.handle.sendline(
kelvin-onlabd3b64892015-01-20 13:26:24 -0800265 "config:property-set -p org.apache.karaf.shell\
266 sshIdleTimeout " +
kelvin8ec71442015-01-15 16:57:00 -0800267 karafTimeout )
268 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800269 self.handle.sendline( "onos -w " + str( ONOSIp ) )
kelvin8ec71442015-01-15 16:57:00 -0800270 self.handle.expect( "onos>" )
andrewonlab3a7c3c72014-10-24 17:21:03 -0400271 return main.TRUE
272 else:
kelvin8ec71442015-01-15 16:57:00 -0800273 main.log.error( "Connection to CLI " +
kelvin-onlabd3b64892015-01-20 13:26:24 -0800274 str( ONOSIp ) + " timeout" )
andrewonlab3a7c3c72014-10-24 17:21:03 -0400275 return main.FALSE
andrewonlab95ce8322014-10-13 14:12:04 -0400276
Jon Halld4d4b372015-01-28 16:02:41 -0800277 except TypeError:
278 main.log.exception( self.name + ": Object not as expected" )
279 return None
andrewonlab95ce8322014-10-13 14:12:04 -0400280 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800281 main.log.error( self.name + ": EOF exception found" )
282 main.log.error( self.name + ": " + self.handle.before )
andrewonlab95ce8322014-10-13 14:12:04 -0400283 main.cleanup()
284 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800285 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800286 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ce8322014-10-13 14:12:04 -0400287 main.cleanup()
288 main.exit()
289
Jon Hallefbd9792015-03-05 16:11:36 -0800290 def log( self, cmdStr, level="" ):
kelvin-onlab9f541032015-02-04 16:19:53 -0800291 """
292 log the commands in the onos CLI.
kelvin-onlab338f5512015-02-06 10:53:16 -0800293 returns main.TRUE on success
Jon Hallefbd9792015-03-05 16:11:36 -0800294 returns main.FALSE if Error occurred
kelvin-onlab338f5512015-02-06 10:53:16 -0800295 Available level: DEBUG, TRACE, INFO, WARN, ERROR
296 Level defaults to INFO
kelvin-onlab9f541032015-02-04 16:19:53 -0800297 """
298 try:
kelvin-onlab338f5512015-02-06 10:53:16 -0800299 lvlStr = ""
300 if level:
301 lvlStr = "--level=" + level
302
kelvin-onlab9f541032015-02-04 16:19:53 -0800303 self.handle.sendline( "" )
Jon Hallc9eabec2015-06-10 14:33:14 -0700304 i = self.handle.expect( [ "onos>","\$", pexpect.TIMEOUT ] )
Jon Hall80daded2015-05-27 16:07:00 -0700305 if i == 1:
Jon Hallc9eabec2015-06-10 14:33:14 -0700306 main.log.error( self.name + ": onos cli session closed." )
307 main.cleanup()
308 main.exit()
309 if i == 2:
Jon Hall80daded2015-05-27 16:07:00 -0700310 self.handle.sendline( "" )
311 self.handle.expect( "onos>" )
kelvin-onlab338f5512015-02-06 10:53:16 -0800312 self.handle.sendline( "log:log " + lvlStr + " " + cmdStr )
Jon Hall390696c2015-05-05 17:13:41 -0700313 self.handle.expect( "log:log" )
kelvin-onlab9f541032015-02-04 16:19:53 -0800314 self.handle.expect( "onos>" )
kelvin-onlabfb521662015-02-27 09:52:40 -0800315
kelvin-onlab9f541032015-02-04 16:19:53 -0800316 response = self.handle.before
317 if re.search( "Error", response ):
318 return main.FALSE
319 return main.TRUE
Jon Hall80daded2015-05-27 16:07:00 -0700320 except pexpect.TIMEOUT:
321 main.log.exception( self.name + ": TIMEOUT exception found" )
322 main.cleanup()
323 main.exit()
kelvin-onlab9f541032015-02-04 16:19:53 -0800324 except pexpect.EOF:
325 main.log.error( self.name + ": EOF exception found" )
326 main.log.error( self.name + ": " + self.handle.before )
327 main.cleanup()
328 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800329 except Exception:
kelvin-onlabfb521662015-02-27 09:52:40 -0800330 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ce8322014-10-13 14:12:04 -0400331 main.cleanup()
332 main.exit()
333
Jon Hallc6358dd2015-04-10 12:44:28 -0700334 def sendline( self, cmdStr, debug=False ):
kelvin8ec71442015-01-15 16:57:00 -0800335 """
Jon Halle3f39ff2015-01-13 11:50:53 -0800336 Send a completely user specified string to
337 the onos> prompt. Use this function if you have
andrewonlaba18f6bf2014-10-13 19:31:54 -0400338 a very specific command to send.
Jon Halle3f39ff2015-01-13 11:50:53 -0800339
andrewonlaba18f6bf2014-10-13 19:31:54 -0400340 Warning: There are no sanity checking to commands
341 sent using this method.
kelvin8ec71442015-01-15 16:57:00 -0800342 """
andrewonlaba18f6bf2014-10-13 19:31:54 -0400343 try:
kelvin-onlab338f5512015-02-06 10:53:16 -0800344 logStr = "\"Sending CLI command: '" + cmdStr + "'\""
345 self.log( logStr )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800346 self.handle.sendline( cmdStr )
Jon Hall63604932015-02-26 17:09:50 -0800347 i = self.handle.expect( ["onos>", "\$", pexpect.TIMEOUT] )
348 response = self.handle.before
349 if i == 2:
350 self.handle.sendline()
Jon Hallc6358dd2015-04-10 12:44:28 -0700351 self.handle.expect( ["\$", pexpect.TIMEOUT] )
Jon Hall63604932015-02-26 17:09:50 -0800352 response += self.handle.before
353 print response
354 try:
355 print self.handle.after
Jon Hall77ba41c2015-04-06 10:25:40 -0700356 except TypeError:
Jon Hall63604932015-02-26 17:09:50 -0800357 pass
358 # TODO: do something with i
kelvin-onlabd3b64892015-01-20 13:26:24 -0800359 main.log.info( "Command '" + str( cmdStr ) + "' sent to "
kelvin-onlab898a6c62015-01-16 14:13:53 -0800360 + self.name + "." )
Jon Hallc6358dd2015-04-10 12:44:28 -0700361 if debug:
Jon Hall390696c2015-05-05 17:13:41 -0700362 main.log.debug( self.name + ": Raw output" )
363 main.log.debug( self.name + ": " + repr( response ) )
Jon Hallc6358dd2015-04-10 12:44:28 -0700364
365 # Remove ANSI color control strings from output
kelvin-onlabd3b64892015-01-20 13:26:24 -0800366 ansiEscape = re.compile( r'\x1b[^m]*m' )
Jon Hall63604932015-02-26 17:09:50 -0800367 response = ansiEscape.sub( '', response )
Jon Hallc6358dd2015-04-10 12:44:28 -0700368 if debug:
Jon Hall390696c2015-05-05 17:13:41 -0700369 main.log.debug( self.name + ": ansiEscape output" )
370 main.log.debug( self.name + ": " + repr( response ) )
Jon Hallc6358dd2015-04-10 12:44:28 -0700371
kelvin-onlabfb521662015-02-27 09:52:40 -0800372 # Remove extra return chars that get added
Jon Hall63604932015-02-26 17:09:50 -0800373 response = re.sub( r"\s\r", "", response )
Jon Hallc6358dd2015-04-10 12:44:28 -0700374 if debug:
Jon Hall390696c2015-05-05 17:13:41 -0700375 main.log.debug( self.name + ": Removed extra returns " +
376 "from output" )
377 main.log.debug( self.name + ": " + repr( response ) )
Jon Hallc6358dd2015-04-10 12:44:28 -0700378
379 # Strip excess whitespace
Jon Hall63604932015-02-26 17:09:50 -0800380 response = response.strip()
Jon Hallc6358dd2015-04-10 12:44:28 -0700381 if debug:
Jon Hall390696c2015-05-05 17:13:41 -0700382 main.log.debug( self.name + ": parsed and stripped output" )
383 main.log.debug( self.name + ": " + repr( response ) )
Jon Hallc6358dd2015-04-10 12:44:28 -0700384
Jon Hall63604932015-02-26 17:09:50 -0800385 # parse for just the output, remove the cmd from response
Jon Hallc6358dd2015-04-10 12:44:28 -0700386 output = response.split( cmdStr.strip(), 1 )
387 if debug:
Jon Hall390696c2015-05-05 17:13:41 -0700388 main.log.debug( self.name + ": split output" )
Jon Hallc6358dd2015-04-10 12:44:28 -0700389 for r in output:
Jon Hall390696c2015-05-05 17:13:41 -0700390 main.log.debug( self.name + ": " + repr( r ) )
Jon Hallc6358dd2015-04-10 12:44:28 -0700391 return output[1].strip()
392 except IndexError:
393 main.log.exception( self.name + ": Object not as expected" )
394 return None
Jon Halld4d4b372015-01-28 16:02:41 -0800395 except TypeError:
396 main.log.exception( self.name + ": Object not as expected" )
397 return None
andrewonlaba18f6bf2014-10-13 19:31:54 -0400398 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800399 main.log.error( self.name + ": EOF exception found" )
400 main.log.error( self.name + ": " + self.handle.before )
andrewonlaba18f6bf2014-10-13 19:31:54 -0400401 main.cleanup()
402 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800403 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800404 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlaba18f6bf2014-10-13 19:31:54 -0400405 main.cleanup()
406 main.exit()
407
kelvin8ec71442015-01-15 16:57:00 -0800408 # IMPORTANT NOTE:
409 # For all cli commands, naming convention should match
kelvin-onlabd3b64892015-01-20 13:26:24 -0800410 # the cli command changing 'a:b' with 'aB'.
411 # Ex ) onos:topology > onosTopology
412 # onos:links > onosLinks
413 # feature:list > featureList
Jon Halle3f39ff2015-01-13 11:50:53 -0800414
kelvin-onlabd3b64892015-01-20 13:26:24 -0800415 def addNode( self, nodeId, ONOSIp, tcpPort="" ):
kelvin8ec71442015-01-15 16:57:00 -0800416 """
andrewonlabc2d05aa2014-10-13 16:51:10 -0400417 Adds a new cluster node by ID and address information.
418 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800419 * nodeId
420 * ONOSIp
andrewonlabc2d05aa2014-10-13 16:51:10 -0400421 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800422 * tcpPort
kelvin8ec71442015-01-15 16:57:00 -0800423 """
andrewonlabc2d05aa2014-10-13 16:51:10 -0400424 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800425 cmdStr = "add-node " + str( nodeId ) + " " +\
426 str( ONOSIp ) + " " + str( tcpPort )
427 handle = self.sendline( cmdStr )
kelvin-onlab898a6c62015-01-16 14:13:53 -0800428 if re.search( "Error", handle ):
kelvin8ec71442015-01-15 16:57:00 -0800429 main.log.error( "Error in adding node" )
430 main.log.error( handle )
Jon Halle3f39ff2015-01-13 11:50:53 -0800431 return main.FALSE
andrewonlabc2d05aa2014-10-13 16:51:10 -0400432 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800433 main.log.info( "Node " + str( ONOSIp ) + " added" )
andrewonlabc2d05aa2014-10-13 16:51:10 -0400434 return main.TRUE
Jon Halld4d4b372015-01-28 16:02:41 -0800435 except TypeError:
436 main.log.exception( self.name + ": Object not as expected" )
437 return None
andrewonlabc2d05aa2014-10-13 16:51:10 -0400438 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800439 main.log.error( self.name + ": EOF exception found" )
440 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc2d05aa2014-10-13 16:51:10 -0400441 main.cleanup()
442 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800443 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800444 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc2d05aa2014-10-13 16:51:10 -0400445 main.cleanup()
446 main.exit()
447
kelvin-onlabd3b64892015-01-20 13:26:24 -0800448 def removeNode( self, nodeId ):
kelvin8ec71442015-01-15 16:57:00 -0800449 """
andrewonlab86dc3082014-10-13 18:18:38 -0400450 Removes a cluster by ID
451 Issues command: 'remove-node [<node-id>]'
452 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800453 * nodeId
kelvin8ec71442015-01-15 16:57:00 -0800454 """
andrewonlab86dc3082014-10-13 18:18:38 -0400455 try:
andrewonlab86dc3082014-10-13 18:18:38 -0400456
kelvin-onlabd3b64892015-01-20 13:26:24 -0800457 cmdStr = "remove-node " + str( nodeId )
Jon Hall08f61bc2015-04-13 16:00:30 -0700458 handle = self.sendline( cmdStr )
Jon Hallc6358dd2015-04-10 12:44:28 -0700459 if re.search( "Error", handle ):
460 main.log.error( "Error in removing node" )
461 main.log.error( handle )
462 return main.FALSE
463 else:
464 return main.TRUE
Jon Halld4d4b372015-01-28 16:02:41 -0800465 except TypeError:
466 main.log.exception( self.name + ": Object not as expected" )
467 return None
andrewonlab86dc3082014-10-13 18:18:38 -0400468 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800469 main.log.error( self.name + ": EOF exception found" )
470 main.log.error( self.name + ": " + self.handle.before )
andrewonlab86dc3082014-10-13 18:18:38 -0400471 main.cleanup()
472 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800473 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800474 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab86dc3082014-10-13 18:18:38 -0400475 main.cleanup()
476 main.exit()
andrewonlabc2d05aa2014-10-13 16:51:10 -0400477
Jon Hall61282e32015-03-19 11:34:11 -0700478 def nodes( self, jsonFormat=True):
kelvin8ec71442015-01-15 16:57:00 -0800479 """
andrewonlab7c211572014-10-15 16:45:20 -0400480 List the nodes currently visible
481 Issues command: 'nodes'
Jon Hall61282e32015-03-19 11:34:11 -0700482 Optional argument:
483 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -0800484 """
andrewonlab7c211572014-10-15 16:45:20 -0400485 try:
Jon Hallc6358dd2015-04-10 12:44:28 -0700486 cmdStr = "nodes"
Jon Hall61282e32015-03-19 11:34:11 -0700487 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -0700488 cmdStr += " -j"
489 output = self.sendline( cmdStr )
490 return output
Jon Halld4d4b372015-01-28 16:02:41 -0800491 except TypeError:
492 main.log.exception( self.name + ": Object not as expected" )
493 return None
andrewonlab7c211572014-10-15 16:45:20 -0400494 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800495 main.log.error( self.name + ": EOF exception found" )
496 main.log.error( self.name + ": " + self.handle.before )
andrewonlab7c211572014-10-15 16:45:20 -0400497 main.cleanup()
498 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800499 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800500 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab7c211572014-10-15 16:45:20 -0400501 main.cleanup()
502 main.exit()
503
kelvin8ec71442015-01-15 16:57:00 -0800504 def topology( self ):
505 """
Hari Krishnaef1bd4e2015-03-12 16:55:30 -0700506 Definition:
Jon Hall390696c2015-05-05 17:13:41 -0700507 Returns the output of topology command.
Hari Krishnaef1bd4e2015-03-12 16:55:30 -0700508 Return:
509 topology = current ONOS topology
kelvin8ec71442015-01-15 16:57:00 -0800510 """
andrewonlab95ce8322014-10-13 14:12:04 -0400511 try:
Hari Krishnaef1bd4e2015-03-12 16:55:30 -0700512 cmdStr = "topology -j"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800513 handle = self.sendline( cmdStr )
Jon Hallc6358dd2015-04-10 12:44:28 -0700514 main.log.info( cmdStr + " returned: " + str( handle ) )
andrewonlab95ce8322014-10-13 14:12:04 -0400515 return handle
Jon Halld4d4b372015-01-28 16:02:41 -0800516 except TypeError:
517 main.log.exception( self.name + ": Object not as expected" )
518 return None
andrewonlab95ce8322014-10-13 14:12:04 -0400519 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800520 main.log.error( self.name + ": EOF exception found" )
521 main.log.error( self.name + ": " + self.handle.before )
andrewonlab95ce8322014-10-13 14:12:04 -0400522 main.cleanup()
523 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800524 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800525 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ce8322014-10-13 14:12:04 -0400526 main.cleanup()
527 main.exit()
Jon Halle3f39ff2015-01-13 11:50:53 -0800528
kelvin-onlabd3b64892015-01-20 13:26:24 -0800529 def featureInstall( self, featureStr ):
kelvin8ec71442015-01-15 16:57:00 -0800530 """
Jon Hallc6358dd2015-04-10 12:44:28 -0700531 Installs a specified feature by issuing command:
532 'feature:install <feature_str>'
533 NOTE: This is now deprecated, you should use the activateApp method
534 instead
kelvin8ec71442015-01-15 16:57:00 -0800535 """
andrewonlabc2d05aa2014-10-13 16:51:10 -0400536 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800537 cmdStr = "feature:install " + str( featureStr )
Jon Hallc6358dd2015-04-10 12:44:28 -0700538 handle = self.sendline( cmdStr )
539 if re.search( "Error", handle ):
540 main.log.error( "Error in installing feature" )
541 main.log.error( handle )
542 return main.FALSE
543 else:
544 return main.TRUE
Jon Halld4d4b372015-01-28 16:02:41 -0800545 except TypeError:
546 main.log.exception( self.name + ": Object not as expected" )
547 return None
andrewonlabc2d05aa2014-10-13 16:51:10 -0400548 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800549 main.log.error( self.name + ": EOF exception found" )
550 main.log.error( self.name + ": " + self.handle.before )
551 main.log.report( "Failed to install feature" )
552 main.log.report( "Exiting test" )
andrewonlabc2d05aa2014-10-13 16:51:10 -0400553 main.cleanup()
554 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800555 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800556 main.log.exception( self.name + ": Uncaught exception!" )
kelvin8ec71442015-01-15 16:57:00 -0800557 main.log.report( "Failed to install feature" )
558 main.log.report( "Exiting test" )
andrewonlabc2d05aa2014-10-13 16:51:10 -0400559 main.cleanup()
560 main.exit()
Jon Halle3f39ff2015-01-13 11:50:53 -0800561
kelvin-onlabd3b64892015-01-20 13:26:24 -0800562 def featureUninstall( self, featureStr ):
kelvin8ec71442015-01-15 16:57:00 -0800563 """
Jon Hallc6358dd2015-04-10 12:44:28 -0700564 Uninstalls a specified feature by issuing command:
565 'feature:uninstall <feature_str>'
566 NOTE: This is now deprecated, you should use the deactivateApp method
567 instead
kelvin8ec71442015-01-15 16:57:00 -0800568 """
andrewonlabc2d05aa2014-10-13 16:51:10 -0400569 try:
Jon Hall30b82fa2015-03-04 17:15:43 -0800570 cmdStr = 'feature:list -i | grep "' + featureStr + '"'
571 handle = self.sendline( cmdStr )
572 if handle != '':
573 cmdStr = "feature:uninstall " + str( featureStr )
Jon Hallc6358dd2015-04-10 12:44:28 -0700574 output = self.sendline( cmdStr )
Jon Hall30b82fa2015-03-04 17:15:43 -0800575 # TODO: Check for possible error responses from karaf
576 else:
Jon Hallefbd9792015-03-05 16:11:36 -0800577 main.log.info( "Feature needs to be installed before " +
578 "uninstalling it" )
Jon Hallc6358dd2015-04-10 12:44:28 -0700579 return main.TRUE
580 if re.search( "Error", output ):
581 main.log.error( "Error in uninstalling feature" )
582 main.log.error( output )
583 return main.FALSE
584 else:
585 return main.TRUE
Jon Halld4d4b372015-01-28 16:02:41 -0800586 except TypeError:
587 main.log.exception( self.name + ": Object not as expected" )
588 return None
andrewonlabc2d05aa2014-10-13 16:51:10 -0400589 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800590 main.log.error( self.name + ": EOF exception found" )
591 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc2d05aa2014-10-13 16:51:10 -0400592 main.cleanup()
593 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800594 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800595 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc2d05aa2014-10-13 16:51:10 -0400596 main.cleanup()
597 main.exit()
Jon Hallffb386d2014-11-21 13:43:38 -0800598
jenkins7ead5a82015-03-13 10:28:21 -0700599 def deviceRemove( self, deviceId ):
600 """
601 Removes particular device from storage
602
603 TODO: refactor this function
604 """
605 try:
Jon Hallc6358dd2015-04-10 12:44:28 -0700606 cmdStr = "device-remove " + str( deviceId )
607 handle = self.sendline( cmdStr )
608 if re.search( "Error", handle ):
609 main.log.error( "Error in removing device" )
610 main.log.error( handle )
611 return main.FALSE
612 else:
613 return main.TRUE
jenkins7ead5a82015-03-13 10:28:21 -0700614 except TypeError:
615 main.log.exception( self.name + ": Object not as expected" )
616 return None
617 except pexpect.EOF:
618 main.log.error( self.name + ": EOF exception found" )
619 main.log.error( self.name + ": " + self.handle.before )
620 main.cleanup()
621 main.exit()
622 except Exception:
623 main.log.exception( self.name + ": Uncaught exception!" )
624 main.cleanup()
625 main.exit()
jenkins7ead5a82015-03-13 10:28:21 -0700626
kelvin-onlabd3b64892015-01-20 13:26:24 -0800627 def devices( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -0800628 """
Jon Hall7b02d952014-10-17 20:14:54 -0400629 Lists all infrastructure devices or switches
andrewonlab86dc3082014-10-13 18:18:38 -0400630 Optional argument:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800631 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -0800632 """
andrewonlab86dc3082014-10-13 18:18:38 -0400633 try:
Jon Hallc6358dd2015-04-10 12:44:28 -0700634 cmdStr = "devices"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800635 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -0700636 cmdStr += " -j"
637 handle = self.sendline( cmdStr )
638 return handle
Jon Halld4d4b372015-01-28 16:02:41 -0800639 except TypeError:
640 main.log.exception( self.name + ": Object not as expected" )
641 return None
andrewonlab7c211572014-10-15 16:45:20 -0400642 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800643 main.log.error( self.name + ": EOF exception found" )
644 main.log.error( self.name + ": " + self.handle.before )
andrewonlab7c211572014-10-15 16:45:20 -0400645 main.cleanup()
646 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800647 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800648 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab7c211572014-10-15 16:45:20 -0400649 main.cleanup()
650 main.exit()
651
kelvin-onlabd3b64892015-01-20 13:26:24 -0800652 def balanceMasters( self ):
kelvin8ec71442015-01-15 16:57:00 -0800653 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800654 This balances the devices across all controllers
655 by issuing command: 'onos> onos:balance-masters'
656 If required this could be extended to return devices balanced output.
kelvin8ec71442015-01-15 16:57:00 -0800657 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800658 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800659 cmdStr = "onos:balance-masters"
Jon Hallc6358dd2015-04-10 12:44:28 -0700660 handle = self.sendline( cmdStr )
661 if re.search( "Error", handle ):
662 main.log.error( "Error in balancing masters" )
663 main.log.error( handle )
664 return main.FALSE
665 else:
666 return main.TRUE
Jon Halld4d4b372015-01-28 16:02:41 -0800667 except TypeError:
668 main.log.exception( self.name + ": Object not as expected" )
669 return None
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800670 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800671 main.log.error( self.name + ": EOF exception found" )
672 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800673 main.cleanup()
674 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800675 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800676 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800677 main.cleanup()
678 main.exit()
679
acsmars24950022015-07-30 18:00:43 -0700680 def checkMasters( self,jsonFormat=True ):
681 """
682 Returns the output of the masters command.
683 Optional argument:
684 * jsonFormat - boolean indicating if you want output in json
685 """
686 try:
687 cmdStr = "onos:masters"
688 if jsonFormat:
689 cmdStr += " -j"
690 output = self.sendline( cmdStr )
691 return output
692 except TypeError:
693 main.log.exception( self.name + ": Object not as expected" )
694 return None
695 except pexpect.EOF:
696 main.log.error( self.name + ": EOF exception found" )
697 main.log.error( self.name + ": " + self.handle.before )
698 main.cleanup()
699 main.exit()
700 except Exception:
701 main.log.exception( self.name + ": Uncaught exception!" )
702 main.cleanup()
703 main.exit()
704
705 def checkBalanceMasters( self,jsonFormat=True ):
706 """
707 Uses the master command to check that the devices' leadership
708 is evenly divided
709
710 Dependencies: checkMasters() and summary()
711
712 Returns main.True if the devices are balanced
713 Returns main.False if the devices are unbalanced
714 Exits on Exception
715 Returns None on TypeError
716 """
717 try:
718 totalDevices = json.loads( self.summary() )[ "devices" ]
719 totalOwnedDevices = 0
720 masters = json.loads( self.checkMasters() )
721 first = masters[ 0 ][ "size" ]
722 for master in masters:
723 totalOwnedDevices += master[ "size" ]
724 if master[ "size" ] > first + 1 or master[ "size" ] < first - 1:
725 main.log.error( "Mastership not balanced" )
726 main.log.info( "\n" + self.checkMasters( False ) )
727 return main.FALSE
728 main.log.info( "Mastership balanced between " \
729 + str( len(masters) ) + " masters" )
730 return main.TRUE
731 except TypeError:
732 main.log.exception( self.name + ": Object not as expected" )
733 return None
734 except pexpect.EOF:
735 main.log.error( self.name + ": EOF exception found" )
736 main.log.error( self.name + ": " + self.handle.before )
737 main.cleanup()
738 main.exit()
739 except Exception:
740 main.log.exception( self.name + ": Uncaught exception!" )
741 main.cleanup()
742 main.exit()
743
kelvin-onlabd3b64892015-01-20 13:26:24 -0800744 def links( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -0800745 """
Jon Halle8217482014-10-17 13:49:14 -0400746 Lists all core links
747 Optional argument:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800748 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -0800749 """
Jon Halle8217482014-10-17 13:49:14 -0400750 try:
Jon Hallc6358dd2015-04-10 12:44:28 -0700751 cmdStr = "links"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800752 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -0700753 cmdStr += " -j"
754 handle = self.sendline( cmdStr )
755 return handle
Jon Halld4d4b372015-01-28 16:02:41 -0800756 except TypeError:
757 main.log.exception( self.name + ": Object not as expected" )
758 return None
Jon Halle8217482014-10-17 13:49:14 -0400759 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800760 main.log.error( self.name + ": EOF exception found" )
761 main.log.error( self.name + ": " + self.handle.before )
Jon Halle8217482014-10-17 13:49:14 -0400762 main.cleanup()
763 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800764 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800765 main.log.exception( self.name + ": Uncaught exception!" )
Jon Halle8217482014-10-17 13:49:14 -0400766 main.cleanup()
767 main.exit()
768
kelvin-onlabd3b64892015-01-20 13:26:24 -0800769 def ports( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -0800770 """
Jon Halle8217482014-10-17 13:49:14 -0400771 Lists all ports
772 Optional argument:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800773 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -0800774 """
Jon Halle8217482014-10-17 13:49:14 -0400775 try:
Jon Hallc6358dd2015-04-10 12:44:28 -0700776 cmdStr = "ports"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800777 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -0700778 cmdStr += " -j"
779 handle = self.sendline( cmdStr )
780 return handle
Jon Halld4d4b372015-01-28 16:02:41 -0800781 except TypeError:
782 main.log.exception( self.name + ": Object not as expected" )
783 return None
Jon Halle8217482014-10-17 13:49:14 -0400784 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800785 main.log.error( self.name + ": EOF exception found" )
786 main.log.error( self.name + ": " + self.handle.before )
Jon Halle8217482014-10-17 13:49:14 -0400787 main.cleanup()
788 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800789 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800790 main.log.exception( self.name + ": Uncaught exception!" )
Jon Halle8217482014-10-17 13:49:14 -0400791 main.cleanup()
792 main.exit()
793
kelvin-onlabd3b64892015-01-20 13:26:24 -0800794 def roles( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -0800795 """
Jon Hall983a1702014-10-28 18:44:22 -0400796 Lists all devices and the controllers with roles assigned to them
797 Optional argument:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800798 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -0800799 """
andrewonlab7c211572014-10-15 16:45:20 -0400800 try:
Jon Hallc6358dd2015-04-10 12:44:28 -0700801 cmdStr = "roles"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800802 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -0700803 cmdStr += " -j"
804 handle = self.sendline( cmdStr )
805 return handle
Jon Halld4d4b372015-01-28 16:02:41 -0800806 except TypeError:
807 main.log.exception( self.name + ": Object not as expected" )
808 return None
Jon Hall983a1702014-10-28 18:44:22 -0400809 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800810 main.log.error( self.name + ": EOF exception found" )
811 main.log.error( self.name + ": " + self.handle.before )
Jon Hall983a1702014-10-28 18:44:22 -0400812 main.cleanup()
813 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800814 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800815 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall983a1702014-10-28 18:44:22 -0400816 main.cleanup()
817 main.exit()
818
kelvin-onlabd3b64892015-01-20 13:26:24 -0800819 def getRole( self, deviceId ):
kelvin-onlab898a6c62015-01-16 14:13:53 -0800820 """
Jon Halle3f39ff2015-01-13 11:50:53 -0800821 Given the a string containing the json representation of the "roles"
822 cli command and a partial or whole device id, returns a json object
823 containing the roles output for the first device whose id contains
824 "device_id"
Jon Hall983a1702014-10-28 18:44:22 -0400825
826 Returns:
Jon Halle3f39ff2015-01-13 11:50:53 -0800827 A dict of the role assignments for the given device or
828 None if no match
kelvin8ec71442015-01-15 16:57:00 -0800829 """
Jon Hall983a1702014-10-28 18:44:22 -0400830 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800831 if deviceId is None:
Jon Hall983a1702014-10-28 18:44:22 -0400832 return None
833 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800834 rawRoles = self.roles()
835 rolesJson = json.loads( rawRoles )
kelvin8ec71442015-01-15 16:57:00 -0800836 # search json for the device with id then return the device
kelvin-onlabd3b64892015-01-20 13:26:24 -0800837 for device in rolesJson:
kelvin8ec71442015-01-15 16:57:00 -0800838 # print device
kelvin-onlabd3b64892015-01-20 13:26:24 -0800839 if str( deviceId ) in device[ 'id' ]:
Jon Hall983a1702014-10-28 18:44:22 -0400840 return device
841 return None
Jon Halld4d4b372015-01-28 16:02:41 -0800842 except TypeError:
843 main.log.exception( self.name + ": Object not as expected" )
844 return None
andrewonlab86dc3082014-10-13 18:18:38 -0400845 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800846 main.log.error( self.name + ": EOF exception found" )
847 main.log.error( self.name + ": " + self.handle.before )
andrewonlab86dc3082014-10-13 18:18:38 -0400848 main.cleanup()
849 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800850 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800851 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab86dc3082014-10-13 18:18:38 -0400852 main.cleanup()
853 main.exit()
Jon Hall94fd0472014-12-08 11:52:42 -0800854
kelvin-onlabd3b64892015-01-20 13:26:24 -0800855 def rolesNotNull( self ):
kelvin8ec71442015-01-15 16:57:00 -0800856 """
Jon Hall94fd0472014-12-08 11:52:42 -0800857 Iterates through each device and checks if there is a master assigned
858 Returns: main.TRUE if each device has a master
859 main.FALSE any device has no master
kelvin8ec71442015-01-15 16:57:00 -0800860 """
Jon Hall94fd0472014-12-08 11:52:42 -0800861 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800862 rawRoles = self.roles()
863 rolesJson = json.loads( rawRoles )
kelvin8ec71442015-01-15 16:57:00 -0800864 # search json for the device with id then return the device
kelvin-onlabd3b64892015-01-20 13:26:24 -0800865 for device in rolesJson:
kelvin8ec71442015-01-15 16:57:00 -0800866 # print device
867 if device[ 'master' ] == "none":
868 main.log.warn( "Device has no master: " + str( device ) )
Jon Hall94fd0472014-12-08 11:52:42 -0800869 return main.FALSE
870 return main.TRUE
871
Jon Halld4d4b372015-01-28 16:02:41 -0800872 except TypeError:
873 main.log.exception( self.name + ": Object not as expected" )
874 return None
Jon Hall94fd0472014-12-08 11:52:42 -0800875 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800876 main.log.error( self.name + ": EOF exception found" )
877 main.log.error( self.name + ": " + self.handle.before )
Jon Hall94fd0472014-12-08 11:52:42 -0800878 main.cleanup()
879 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800880 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800881 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall94fd0472014-12-08 11:52:42 -0800882 main.cleanup()
883 main.exit()
884
kelvin-onlabd3b64892015-01-20 13:26:24 -0800885 def paths( self, srcId, dstId ):
kelvin8ec71442015-01-15 16:57:00 -0800886 """
andrewonlab3e15ead2014-10-15 14:21:34 -0400887 Returns string of paths, and the cost.
888 Issues command: onos:paths <src> <dst>
kelvin8ec71442015-01-15 16:57:00 -0800889 """
andrewonlab3e15ead2014-10-15 14:21:34 -0400890 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800891 cmdStr = "onos:paths " + str( srcId ) + " " + str( dstId )
892 handle = self.sendline( cmdStr )
Jon Halle3f39ff2015-01-13 11:50:53 -0800893 if re.search( "Error", handle ):
kelvin8ec71442015-01-15 16:57:00 -0800894 main.log.error( "Error in getting paths" )
895 return ( handle, "Error" )
andrewonlab3e15ead2014-10-15 14:21:34 -0400896 else:
kelvin8ec71442015-01-15 16:57:00 -0800897 path = handle.split( ";" )[ 0 ]
898 cost = handle.split( ";" )[ 1 ]
899 return ( path, cost )
Jon Halld4d4b372015-01-28 16:02:41 -0800900 except TypeError:
901 main.log.exception( self.name + ": Object not as expected" )
902 return ( handle, "Error" )
andrewonlab3e15ead2014-10-15 14:21:34 -0400903 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800904 main.log.error( self.name + ": EOF exception found" )
905 main.log.error( self.name + ": " + self.handle.before )
andrewonlab3e15ead2014-10-15 14:21:34 -0400906 main.cleanup()
907 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800908 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800909 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab3e15ead2014-10-15 14:21:34 -0400910 main.cleanup()
911 main.exit()
Jon Hallffb386d2014-11-21 13:43:38 -0800912
kelvin-onlabd3b64892015-01-20 13:26:24 -0800913 def hosts( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -0800914 """
Jon Hallffb386d2014-11-21 13:43:38 -0800915 Lists all discovered hosts
Jon Hall42db6dc2014-10-24 19:03:48 -0400916 Optional argument:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800917 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -0800918 """
Jon Hall42db6dc2014-10-24 19:03:48 -0400919 try:
Jon Hallc6358dd2015-04-10 12:44:28 -0700920 cmdStr = "hosts"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800921 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -0700922 cmdStr += " -j"
923 handle = self.sendline( cmdStr )
924 return handle
Jon Halld4d4b372015-01-28 16:02:41 -0800925 except TypeError:
926 main.log.exception( self.name + ": Object not as expected" )
927 return None
Jon Hall42db6dc2014-10-24 19:03:48 -0400928 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800929 main.log.error( self.name + ": EOF exception found" )
930 main.log.error( self.name + ": " + self.handle.before )
Jon Hall42db6dc2014-10-24 19:03:48 -0400931 main.cleanup()
932 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800933 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800934 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall42db6dc2014-10-24 19:03:48 -0400935 main.cleanup()
936 main.exit()
937
kelvin-onlabd3b64892015-01-20 13:26:24 -0800938 def getHost( self, mac ):
kelvin8ec71442015-01-15 16:57:00 -0800939 """
Jon Hall42db6dc2014-10-24 19:03:48 -0400940 Return the first host from the hosts api whose 'id' contains 'mac'
Jon Halle3f39ff2015-01-13 11:50:53 -0800941
Jon Hallefbd9792015-03-05 16:11:36 -0800942 Note: mac must be a colon separated mac address, but could be a
Jon Halle3f39ff2015-01-13 11:50:53 -0800943 partial mac address
944
Jon Hall42db6dc2014-10-24 19:03:48 -0400945 Return None if there is no match
kelvin8ec71442015-01-15 16:57:00 -0800946 """
Jon Hall42db6dc2014-10-24 19:03:48 -0400947 try:
kelvin8ec71442015-01-15 16:57:00 -0800948 if mac is None:
Jon Hall42db6dc2014-10-24 19:03:48 -0400949 return None
950 else:
951 mac = mac
kelvin-onlabd3b64892015-01-20 13:26:24 -0800952 rawHosts = self.hosts()
953 hostsJson = json.loads( rawHosts )
kelvin8ec71442015-01-15 16:57:00 -0800954 # search json for the host with mac then return the device
kelvin-onlabd3b64892015-01-20 13:26:24 -0800955 for host in hostsJson:
kelvin8ec71442015-01-15 16:57:00 -0800956 # print "%s in %s?" % ( mac, host[ 'id' ] )
Jon Halld4d4b372015-01-28 16:02:41 -0800957 if not host:
958 pass
959 elif mac in host[ 'id' ]:
Jon Hall42db6dc2014-10-24 19:03:48 -0400960 return host
961 return None
Jon Halld4d4b372015-01-28 16:02:41 -0800962 except TypeError:
963 main.log.exception( self.name + ": Object not as expected" )
964 return None
Jon Hall42db6dc2014-10-24 19:03:48 -0400965 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800966 main.log.error( self.name + ": EOF exception found" )
967 main.log.error( self.name + ": " + self.handle.before )
Jon Hall42db6dc2014-10-24 19:03:48 -0400968 main.cleanup()
969 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800970 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -0800971 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall42db6dc2014-10-24 19:03:48 -0400972 main.cleanup()
973 main.exit()
974
kelvin-onlabd3b64892015-01-20 13:26:24 -0800975 def getHostsId( self, hostList ):
kelvin8ec71442015-01-15 16:57:00 -0800976 """
977 Obtain list of hosts
andrewonlab3f0a4af2014-10-17 12:25:14 -0400978 Issues command: 'onos> hosts'
kelvin8ec71442015-01-15 16:57:00 -0800979
andrewonlab3f0a4af2014-10-17 12:25:14 -0400980 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800981 * hostList: List of hosts obtained by Mininet
andrewonlab3f0a4af2014-10-17 12:25:14 -0400982 IMPORTANT:
983 This function assumes that you started your
kelvin8ec71442015-01-15 16:57:00 -0800984 topology with the option '--mac'.
andrewonlab3f0a4af2014-10-17 12:25:14 -0400985 Furthermore, it assumes that value of VLAN is '-1'
986 Description:
kelvin8ec71442015-01-15 16:57:00 -0800987 Converts mininet hosts ( h1, h2, h3... ) into
988 ONOS format ( 00:00:00:00:00:01/-1 , ... )
989 """
andrewonlab3f0a4af2014-10-17 12:25:14 -0400990 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800991 onosHostList = []
andrewonlab3f0a4af2014-10-17 12:25:14 -0400992
kelvin-onlabd3b64892015-01-20 13:26:24 -0800993 for host in hostList:
kelvin8ec71442015-01-15 16:57:00 -0800994 host = host.replace( "h", "" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800995 hostHex = hex( int( host ) ).zfill( 12 )
996 hostHex = str( hostHex ).replace( 'x', '0' )
997 i = iter( str( hostHex ) )
998 hostHex = ":".join( a + b for a, b in zip( i, i ) )
999 hostHex = hostHex + "/-1"
1000 onosHostList.append( hostHex )
andrewonlab3f0a4af2014-10-17 12:25:14 -04001001
kelvin-onlabd3b64892015-01-20 13:26:24 -08001002 return onosHostList
andrewonlab3f0a4af2014-10-17 12:25:14 -04001003
Jon Halld4d4b372015-01-28 16:02:41 -08001004 except TypeError:
1005 main.log.exception( self.name + ": Object not as expected" )
1006 return None
andrewonlab3f0a4af2014-10-17 12:25:14 -04001007 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001008 main.log.error( self.name + ": EOF exception found" )
1009 main.log.error( self.name + ": " + self.handle.before )
andrewonlab3f0a4af2014-10-17 12:25:14 -04001010 main.cleanup()
1011 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001012 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001013 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab3f0a4af2014-10-17 12:25:14 -04001014 main.cleanup()
1015 main.exit()
andrewonlab3e15ead2014-10-15 14:21:34 -04001016
kelvin-onlabd3b64892015-01-20 13:26:24 -08001017 def addHostIntent( self, hostIdOne, hostIdTwo ):
kelvin8ec71442015-01-15 16:57:00 -08001018 """
andrewonlabe6745342014-10-17 14:29:13 -04001019 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001020 * hostIdOne: ONOS host id for host1
1021 * hostIdTwo: ONOS host id for host2
andrewonlabe6745342014-10-17 14:29:13 -04001022 Description:
Jon Hallefbd9792015-03-05 16:11:36 -08001023 Adds a host-to-host intent ( bidirectional ) by
Jon Hallb1290e82014-11-18 16:17:48 -05001024 specifying the two hosts.
kelvin-onlabfb521662015-02-27 09:52:40 -08001025 Returns:
1026 A string of the intent id or None on Error
kelvin8ec71442015-01-15 16:57:00 -08001027 """
andrewonlabe6745342014-10-17 14:29:13 -04001028 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001029 cmdStr = "add-host-intent " + str( hostIdOne ) +\
1030 " " + str( hostIdTwo )
1031 handle = self.sendline( cmdStr )
Hari Krishnaac4e1782015-01-26 12:09:12 -08001032 if re.search( "Error", handle ):
1033 main.log.error( "Error in adding Host intent" )
Jon Hall61282e32015-03-19 11:34:11 -07001034 main.log.debug( "Response from ONOS was: " + repr( handle ) )
kelvin-onlabfb521662015-02-27 09:52:40 -08001035 return None
Hari Krishnaac4e1782015-01-26 12:09:12 -08001036 else:
1037 main.log.info( "Host intent installed between " +
kelvin-onlabfb521662015-02-27 09:52:40 -08001038 str( hostIdOne ) + " and " + str( hostIdTwo ) )
1039 match = re.search('id=0x([\da-f]+),', handle)
1040 if match:
1041 return match.group()[3:-1]
1042 else:
1043 main.log.error( "Error, intent ID not found" )
Jon Hall61282e32015-03-19 11:34:11 -07001044 main.log.debug( "Response from ONOS was: " +
1045 repr( handle ) )
kelvin-onlabfb521662015-02-27 09:52:40 -08001046 return None
Jon Halld4d4b372015-01-28 16:02:41 -08001047 except TypeError:
1048 main.log.exception( self.name + ": Object not as expected" )
1049 return None
andrewonlabe6745342014-10-17 14:29:13 -04001050 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001051 main.log.error( self.name + ": EOF exception found" )
1052 main.log.error( self.name + ": " + self.handle.before )
andrewonlabe6745342014-10-17 14:29:13 -04001053 main.cleanup()
1054 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001055 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001056 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabe6745342014-10-17 14:29:13 -04001057 main.cleanup()
1058 main.exit()
1059
kelvin-onlabd3b64892015-01-20 13:26:24 -08001060 def addOpticalIntent( self, ingressDevice, egressDevice ):
kelvin8ec71442015-01-15 16:57:00 -08001061 """
andrewonlab7b31d232014-10-24 13:31:47 -04001062 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001063 * ingressDevice: device id of ingress device
1064 * egressDevice: device id of egress device
andrewonlab7b31d232014-10-24 13:31:47 -04001065 Optional:
1066 TODO: Still needs to be implemented via dev side
kelvin-onlabfb521662015-02-27 09:52:40 -08001067 Description:
1068 Adds an optical intent by specifying an ingress and egress device
1069 Returns:
1070 A string of the intent id or None on error
kelvin-onlab898a6c62015-01-16 14:13:53 -08001071 """
andrewonlab7b31d232014-10-24 13:31:47 -04001072 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001073 cmdStr = "add-optical-intent " + str( ingressDevice ) +\
1074 " " + str( egressDevice )
1075 handle = self.sendline( cmdStr )
kelvin-onlab898a6c62015-01-16 14:13:53 -08001076 # If error, return error message
Jon Halle3f39ff2015-01-13 11:50:53 -08001077 if re.search( "Error", handle ):
kelvin-onlabfb521662015-02-27 09:52:40 -08001078 main.log.error( "Error in adding Optical intent" )
1079 return None
andrewonlab7b31d232014-10-24 13:31:47 -04001080 else:
kelvin-onlabfb521662015-02-27 09:52:40 -08001081 main.log.info( "Optical intent installed between " +
1082 str( ingressDevice ) + " and " +
1083 str( egressDevice ) )
1084 match = re.search('id=0x([\da-f]+),', handle)
1085 if match:
1086 return match.group()[3:-1]
1087 else:
1088 main.log.error( "Error, intent ID not found" )
1089 return None
Jon Halld4d4b372015-01-28 16:02:41 -08001090 except TypeError:
1091 main.log.exception( self.name + ": Object not as expected" )
1092 return None
andrewonlab7b31d232014-10-24 13:31:47 -04001093 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001094 main.log.error( self.name + ": EOF exception found" )
1095 main.log.error( self.name + ": " + self.handle.before )
andrewonlab7b31d232014-10-24 13:31:47 -04001096 main.cleanup()
1097 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001098 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001099 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab7b31d232014-10-24 13:31:47 -04001100 main.cleanup()
1101 main.exit()
1102
kelvin-onlabd3b64892015-01-20 13:26:24 -08001103 def addPointIntent(
kelvin-onlab898a6c62015-01-16 14:13:53 -08001104 self,
kelvin-onlabd3b64892015-01-20 13:26:24 -08001105 ingressDevice,
1106 egressDevice,
1107 portIngress="",
1108 portEgress="",
kelvin-onlab898a6c62015-01-16 14:13:53 -08001109 ethType="",
1110 ethSrc="",
1111 ethDst="",
1112 bandwidth="",
kelvin-onlabd3b64892015-01-20 13:26:24 -08001113 lambdaAlloc=False,
kelvin-onlab898a6c62015-01-16 14:13:53 -08001114 ipProto="",
1115 ipSrc="",
1116 ipDst="",
1117 tcpSrc="",
1118 tcpDst="" ):
kelvin8ec71442015-01-15 16:57:00 -08001119 """
andrewonlab4dbb4d82014-10-17 18:22:31 -04001120 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001121 * ingressDevice: device id of ingress device
1122 * egressDevice: device id of egress device
andrewonlab289e4b72014-10-21 21:24:18 -04001123 Optional:
1124 * ethType: specify ethType
kelvin8ec71442015-01-15 16:57:00 -08001125 * ethSrc: specify ethSrc ( i.e. src mac addr )
1126 * ethDst: specify ethDst ( i.e. dst mac addr )
andrewonlab0dbb6ec2014-11-06 13:46:55 -05001127 * bandwidth: specify bandwidth capacity of link
kelvin-onlabd3b64892015-01-20 13:26:24 -08001128 * lambdaAlloc: if True, intent will allocate lambda
andrewonlab40ccd8b2014-11-06 16:23:34 -05001129 for the specified intent
Jon Halle3f39ff2015-01-13 11:50:53 -08001130 * ipProto: specify ip protocol
andrewonlabf77e0cb2014-11-11 17:17:59 -05001131 * ipSrc: specify ip source address
1132 * ipDst: specify ip destination address
1133 * tcpSrc: specify tcp source port
1134 * tcpDst: specify tcp destination port
andrewonlab4dbb4d82014-10-17 18:22:31 -04001135 Description:
kelvin8ec71442015-01-15 16:57:00 -08001136 Adds a point-to-point intent ( uni-directional ) by
andrewonlab289e4b72014-10-21 21:24:18 -04001137 specifying device id's and optional fields
kelvin-onlabfb521662015-02-27 09:52:40 -08001138 Returns:
1139 A string of the intent id or None on error
andrewonlab289e4b72014-10-21 21:24:18 -04001140
Jon Halle3f39ff2015-01-13 11:50:53 -08001141 NOTE: This function may change depending on the
andrewonlab4dbb4d82014-10-17 18:22:31 -04001142 options developers provide for point-to-point
1143 intent via cli
kelvin8ec71442015-01-15 16:57:00 -08001144 """
andrewonlab4dbb4d82014-10-17 18:22:31 -04001145 try:
kelvin8ec71442015-01-15 16:57:00 -08001146 # If there are no optional arguments
andrewonlab0dbb6ec2014-11-06 13:46:55 -05001147 if not ethType and not ethSrc and not ethDst\
kelvin-onlabd3b64892015-01-20 13:26:24 -08001148 and not bandwidth and not lambdaAlloc \
andrewonlabfa4ff502014-11-11 16:41:30 -05001149 and not ipProto and not ipSrc and not ipDst \
1150 and not tcpSrc and not tcpDst:
andrewonlab36af3822014-11-18 17:48:18 -05001151 cmd = "add-point-intent"
andrewonlab36af3822014-11-18 17:48:18 -05001152
andrewonlab289e4b72014-10-21 21:24:18 -04001153 else:
andrewonlab36af3822014-11-18 17:48:18 -05001154 cmd = "add-point-intent"
Jon Halle3f39ff2015-01-13 11:50:53 -08001155
andrewonlab0c0a6772014-10-22 12:31:18 -04001156 if ethType:
kelvin8ec71442015-01-15 16:57:00 -08001157 cmd += " --ethType " + str( ethType )
andrewonlab289e4b72014-10-21 21:24:18 -04001158 if ethSrc:
kelvin8ec71442015-01-15 16:57:00 -08001159 cmd += " --ethSrc " + str( ethSrc )
1160 if ethDst:
1161 cmd += " --ethDst " + str( ethDst )
andrewonlab0dbb6ec2014-11-06 13:46:55 -05001162 if bandwidth:
kelvin8ec71442015-01-15 16:57:00 -08001163 cmd += " --bandwidth " + str( bandwidth )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001164 if lambdaAlloc:
andrewonlabfa4ff502014-11-11 16:41:30 -05001165 cmd += " --lambda "
1166 if ipProto:
kelvin8ec71442015-01-15 16:57:00 -08001167 cmd += " --ipProto " + str( ipProto )
andrewonlabfa4ff502014-11-11 16:41:30 -05001168 if ipSrc:
kelvin8ec71442015-01-15 16:57:00 -08001169 cmd += " --ipSrc " + str( ipSrc )
andrewonlabfa4ff502014-11-11 16:41:30 -05001170 if ipDst:
kelvin8ec71442015-01-15 16:57:00 -08001171 cmd += " --ipDst " + str( ipDst )
andrewonlabfa4ff502014-11-11 16:41:30 -05001172 if tcpSrc:
kelvin8ec71442015-01-15 16:57:00 -08001173 cmd += " --tcpSrc " + str( tcpSrc )
andrewonlabfa4ff502014-11-11 16:41:30 -05001174 if tcpDst:
kelvin8ec71442015-01-15 16:57:00 -08001175 cmd += " --tcpDst " + str( tcpDst )
andrewonlab289e4b72014-10-21 21:24:18 -04001176
kelvin8ec71442015-01-15 16:57:00 -08001177 # Check whether the user appended the port
1178 # or provided it as an input
kelvin-onlabd3b64892015-01-20 13:26:24 -08001179 if "/" in ingressDevice:
1180 cmd += " " + str( ingressDevice )
andrewonlab36af3822014-11-18 17:48:18 -05001181 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001182 if not portIngress:
kelvin-onlabfb521662015-02-27 09:52:40 -08001183 main.log.error( "You must specify the ingress port" )
kelvin8ec71442015-01-15 16:57:00 -08001184 # TODO: perhaps more meaningful return
kelvin-onlabfb521662015-02-27 09:52:40 -08001185 # Would it make sense to throw an exception and exit
1186 # the test?
1187 return None
andrewonlab36af3822014-11-18 17:48:18 -05001188
kelvin8ec71442015-01-15 16:57:00 -08001189 cmd += " " + \
kelvin-onlabd3b64892015-01-20 13:26:24 -08001190 str( ingressDevice ) + "/" +\
1191 str( portIngress ) + " "
andrewonlab36af3822014-11-18 17:48:18 -05001192
kelvin-onlabd3b64892015-01-20 13:26:24 -08001193 if "/" in egressDevice:
1194 cmd += " " + str( egressDevice )
andrewonlab36af3822014-11-18 17:48:18 -05001195 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001196 if not portEgress:
kelvin-onlabfb521662015-02-27 09:52:40 -08001197 main.log.error( "You must specify the egress port" )
1198 return None
Jon Halle3f39ff2015-01-13 11:50:53 -08001199
kelvin8ec71442015-01-15 16:57:00 -08001200 cmd += " " +\
kelvin-onlabd3b64892015-01-20 13:26:24 -08001201 str( egressDevice ) + "/" +\
1202 str( portEgress )
kelvin8ec71442015-01-15 16:57:00 -08001203
kelvin-onlab898a6c62015-01-16 14:13:53 -08001204 handle = self.sendline( cmd )
kelvin-onlabfb521662015-02-27 09:52:40 -08001205 # If error, return error message
kelvin-onlab898a6c62015-01-16 14:13:53 -08001206 if re.search( "Error", handle ):
kelvin8ec71442015-01-15 16:57:00 -08001207 main.log.error( "Error in adding point-to-point intent" )
kelvin-onlabfb521662015-02-27 09:52:40 -08001208 return None
andrewonlab4dbb4d82014-10-17 18:22:31 -04001209 else:
kelvin-onlabfb521662015-02-27 09:52:40 -08001210 # TODO: print out all the options in this message?
1211 main.log.info( "Point-to-point intent installed between " +
1212 str( ingressDevice ) + " and " +
1213 str( egressDevice ) )
1214 match = re.search('id=0x([\da-f]+),', handle)
1215 if match:
1216 return match.group()[3:-1]
1217 else:
1218 main.log.error( "Error, intent ID not found" )
1219 return None
Jon Halld4d4b372015-01-28 16:02:41 -08001220 except TypeError:
1221 main.log.exception( self.name + ": Object not as expected" )
1222 return None
andrewonlab4dbb4d82014-10-17 18:22:31 -04001223 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001224 main.log.error( self.name + ": EOF exception found" )
1225 main.log.error( self.name + ": " + self.handle.before )
andrewonlab4dbb4d82014-10-17 18:22:31 -04001226 main.cleanup()
1227 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001228 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001229 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab4dbb4d82014-10-17 18:22:31 -04001230 main.cleanup()
1231 main.exit()
1232
kelvin-onlabd3b64892015-01-20 13:26:24 -08001233 def addMultipointToSinglepointIntent(
kelvin-onlab898a6c62015-01-16 14:13:53 -08001234 self,
shahshreyac2f97072015-03-19 17:04:29 -07001235 ingressDeviceList,
kelvin-onlabd3b64892015-01-20 13:26:24 -08001236 egressDevice,
shahshreyac2f97072015-03-19 17:04:29 -07001237 portIngressList=None,
kelvin-onlabd3b64892015-01-20 13:26:24 -08001238 portEgress="",
kelvin-onlab898a6c62015-01-16 14:13:53 -08001239 ethType="",
1240 ethSrc="",
1241 ethDst="",
1242 bandwidth="",
kelvin-onlabd3b64892015-01-20 13:26:24 -08001243 lambdaAlloc=False,
kelvin-onlab898a6c62015-01-16 14:13:53 -08001244 ipProto="",
1245 ipSrc="",
1246 ipDst="",
1247 tcpSrc="",
1248 tcpDst="",
1249 setEthSrc="",
1250 setEthDst="" ):
kelvin8ec71442015-01-15 16:57:00 -08001251 """
shahshreyad0c80432014-12-04 16:56:05 -08001252 Note:
shahshreya70622b12015-03-19 17:19:00 -07001253 This function assumes the format of all ingress devices
Jon Hallbe379602015-03-24 13:39:32 -07001254 is same. That is, all ingress devices include port numbers
1255 with a "/" or all ingress devices could specify device
1256 ids and port numbers seperately.
shahshreyad0c80432014-12-04 16:56:05 -08001257 Required:
Jon Hallbe379602015-03-24 13:39:32 -07001258 * ingressDeviceList: List of device ids of ingress device
shahshreyac2f97072015-03-19 17:04:29 -07001259 ( Atleast 2 ingress devices required in the list )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001260 * egressDevice: device id of egress device
shahshreyad0c80432014-12-04 16:56:05 -08001261 Optional:
1262 * ethType: specify ethType
kelvin8ec71442015-01-15 16:57:00 -08001263 * ethSrc: specify ethSrc ( i.e. src mac addr )
1264 * ethDst: specify ethDst ( i.e. dst mac addr )
shahshreyad0c80432014-12-04 16:56:05 -08001265 * bandwidth: specify bandwidth capacity of link
kelvin-onlabd3b64892015-01-20 13:26:24 -08001266 * lambdaAlloc: if True, intent will allocate lambda
shahshreyad0c80432014-12-04 16:56:05 -08001267 for the specified intent
Jon Halle3f39ff2015-01-13 11:50:53 -08001268 * ipProto: specify ip protocol
shahshreyad0c80432014-12-04 16:56:05 -08001269 * ipSrc: specify ip source address
1270 * ipDst: specify ip destination address
1271 * tcpSrc: specify tcp source port
1272 * tcpDst: specify tcp destination port
1273 * setEthSrc: action to Rewrite Source MAC Address
1274 * setEthDst: action to Rewrite Destination MAC Address
1275 Description:
kelvin8ec71442015-01-15 16:57:00 -08001276 Adds a multipoint-to-singlepoint intent ( uni-directional ) by
shahshreyad0c80432014-12-04 16:56:05 -08001277 specifying device id's and optional fields
kelvin-onlabfb521662015-02-27 09:52:40 -08001278 Returns:
1279 A string of the intent id or None on error
shahshreyad0c80432014-12-04 16:56:05 -08001280
Jon Halle3f39ff2015-01-13 11:50:53 -08001281 NOTE: This function may change depending on the
Jon Hallefbd9792015-03-05 16:11:36 -08001282 options developers provide for multipoint-to-singlepoint
shahshreyad0c80432014-12-04 16:56:05 -08001283 intent via cli
kelvin8ec71442015-01-15 16:57:00 -08001284 """
shahshreyad0c80432014-12-04 16:56:05 -08001285 try:
kelvin8ec71442015-01-15 16:57:00 -08001286 # If there are no optional arguments
shahshreyad0c80432014-12-04 16:56:05 -08001287 if not ethType and not ethSrc and not ethDst\
kelvin-onlabd3b64892015-01-20 13:26:24 -08001288 and not bandwidth and not lambdaAlloc\
Jon Halle3f39ff2015-01-13 11:50:53 -08001289 and not ipProto and not ipSrc and not ipDst\
1290 and not tcpSrc and not tcpDst and not setEthSrc\
1291 and not setEthDst:
shahshreyad0c80432014-12-04 16:56:05 -08001292 cmd = "add-multi-to-single-intent"
shahshreyad0c80432014-12-04 16:56:05 -08001293
1294 else:
1295 cmd = "add-multi-to-single-intent"
Jon Halle3f39ff2015-01-13 11:50:53 -08001296
shahshreyad0c80432014-12-04 16:56:05 -08001297 if ethType:
kelvin8ec71442015-01-15 16:57:00 -08001298 cmd += " --ethType " + str( ethType )
shahshreyad0c80432014-12-04 16:56:05 -08001299 if ethSrc:
kelvin8ec71442015-01-15 16:57:00 -08001300 cmd += " --ethSrc " + str( ethSrc )
1301 if ethDst:
1302 cmd += " --ethDst " + str( ethDst )
shahshreyad0c80432014-12-04 16:56:05 -08001303 if bandwidth:
kelvin8ec71442015-01-15 16:57:00 -08001304 cmd += " --bandwidth " + str( bandwidth )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001305 if lambdaAlloc:
shahshreyad0c80432014-12-04 16:56:05 -08001306 cmd += " --lambda "
1307 if ipProto:
kelvin8ec71442015-01-15 16:57:00 -08001308 cmd += " --ipProto " + str( ipProto )
shahshreyad0c80432014-12-04 16:56:05 -08001309 if ipSrc:
kelvin8ec71442015-01-15 16:57:00 -08001310 cmd += " --ipSrc " + str( ipSrc )
shahshreyad0c80432014-12-04 16:56:05 -08001311 if ipDst:
kelvin8ec71442015-01-15 16:57:00 -08001312 cmd += " --ipDst " + str( ipDst )
shahshreyad0c80432014-12-04 16:56:05 -08001313 if tcpSrc:
kelvin8ec71442015-01-15 16:57:00 -08001314 cmd += " --tcpSrc " + str( tcpSrc )
shahshreyad0c80432014-12-04 16:56:05 -08001315 if tcpDst:
kelvin8ec71442015-01-15 16:57:00 -08001316 cmd += " --tcpDst " + str( tcpDst )
shahshreyad0c80432014-12-04 16:56:05 -08001317 if setEthSrc:
kelvin8ec71442015-01-15 16:57:00 -08001318 cmd += " --setEthSrc " + str( setEthSrc )
shahshreyad0c80432014-12-04 16:56:05 -08001319 if setEthDst:
kelvin8ec71442015-01-15 16:57:00 -08001320 cmd += " --setEthDst " + str( setEthDst )
shahshreyad0c80432014-12-04 16:56:05 -08001321
kelvin8ec71442015-01-15 16:57:00 -08001322 # Check whether the user appended the port
1323 # or provided it as an input
shahshreyac2f97072015-03-19 17:04:29 -07001324
1325 if portIngressList is None:
1326 for ingressDevice in ingressDeviceList:
1327 if "/" in ingressDevice:
1328 cmd += " " + str( ingressDevice )
1329 else:
1330 main.log.error( "You must specify " +
Jon Hallbe379602015-03-24 13:39:32 -07001331 "the ingress port" )
shahshreyac2f97072015-03-19 17:04:29 -07001332 # TODO: perhaps more meaningful return
1333 return main.FALSE
shahshreyad0c80432014-12-04 16:56:05 -08001334 else:
Jon Hall71ce4e72015-03-23 14:05:58 -07001335 if len( ingressDeviceList ) == len( portIngressList ):
Jon Hall08f61bc2015-04-13 16:00:30 -07001336 for ingressDevice, portIngress in zip( ingressDeviceList,
1337 portIngressList ):
shahshreya70622b12015-03-19 17:19:00 -07001338 cmd += " " + \
1339 str( ingressDevice ) + "/" +\
1340 str( portIngress ) + " "
kelvin-onlab38143812015-04-01 15:03:01 -07001341 else:
Jon Hall08f61bc2015-04-13 16:00:30 -07001342 main.log.error( "Device list and port list does not " +
1343 "have the same length" )
kelvin-onlab38143812015-04-01 15:03:01 -07001344 return main.FALSE
kelvin-onlabd3b64892015-01-20 13:26:24 -08001345 if "/" in egressDevice:
1346 cmd += " " + str( egressDevice )
shahshreyad0c80432014-12-04 16:56:05 -08001347 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001348 if not portEgress:
kelvin8ec71442015-01-15 16:57:00 -08001349 main.log.error( "You must specify " +
1350 "the egress port" )
shahshreyad0c80432014-12-04 16:56:05 -08001351 return main.FALSE
Jon Halle3f39ff2015-01-13 11:50:53 -08001352
kelvin8ec71442015-01-15 16:57:00 -08001353 cmd += " " +\
kelvin-onlabd3b64892015-01-20 13:26:24 -08001354 str( egressDevice ) + "/" +\
1355 str( portEgress )
kelvin-onlab898a6c62015-01-16 14:13:53 -08001356 handle = self.sendline( cmd )
kelvin-onlabfb521662015-02-27 09:52:40 -08001357 # If error, return error message
kelvin-onlab898a6c62015-01-16 14:13:53 -08001358 if re.search( "Error", handle ):
kelvin-onlabfb521662015-02-27 09:52:40 -08001359 main.log.error( "Error in adding multipoint-to-singlepoint " +
1360 "intent" )
1361 return None
shahshreyad0c80432014-12-04 16:56:05 -08001362 else:
kelvin-onlabb9408212015-04-01 13:34:04 -07001363 match = re.search('id=0x([\da-f]+),', handle)
1364 if match:
1365 return match.group()[3:-1]
1366 else:
1367 main.log.error( "Error, intent ID not found" )
1368 return None
1369 except TypeError:
1370 main.log.exception( self.name + ": Object not as expected" )
1371 return None
1372 except pexpect.EOF:
1373 main.log.error( self.name + ": EOF exception found" )
1374 main.log.error( self.name + ": " + self.handle.before )
1375 main.cleanup()
1376 main.exit()
1377 except Exception:
1378 main.log.exception( self.name + ": Uncaught exception!" )
1379 main.cleanup()
1380 main.exit()
1381
1382 def addSinglepointToMultipointIntent(
1383 self,
1384 ingressDevice,
1385 egressDeviceList,
1386 portIngress="",
1387 portEgressList=None,
1388 ethType="",
1389 ethSrc="",
1390 ethDst="",
1391 bandwidth="",
1392 lambdaAlloc=False,
1393 ipProto="",
1394 ipSrc="",
1395 ipDst="",
1396 tcpSrc="",
1397 tcpDst="",
1398 setEthSrc="",
1399 setEthDst="" ):
1400 """
1401 Note:
1402 This function assumes the format of all egress devices
1403 is same. That is, all egress devices include port numbers
1404 with a "/" or all egress devices could specify device
1405 ids and port numbers seperately.
1406 Required:
1407 * EgressDeviceList: List of device ids of egress device
1408 ( Atleast 2 eress devices required in the list )
1409 * ingressDevice: device id of ingress device
1410 Optional:
1411 * ethType: specify ethType
1412 * ethSrc: specify ethSrc ( i.e. src mac addr )
1413 * ethDst: specify ethDst ( i.e. dst mac addr )
1414 * bandwidth: specify bandwidth capacity of link
1415 * lambdaAlloc: if True, intent will allocate lambda
1416 for the specified intent
1417 * ipProto: specify ip protocol
1418 * ipSrc: specify ip source address
1419 * ipDst: specify ip destination address
1420 * tcpSrc: specify tcp source port
1421 * tcpDst: specify tcp destination port
1422 * setEthSrc: action to Rewrite Source MAC Address
1423 * setEthDst: action to Rewrite Destination MAC Address
1424 Description:
1425 Adds a singlepoint-to-multipoint intent ( uni-directional ) by
1426 specifying device id's and optional fields
1427 Returns:
1428 A string of the intent id or None on error
1429
1430 NOTE: This function may change depending on the
1431 options developers provide for singlepoint-to-multipoint
1432 intent via cli
1433 """
1434 try:
1435 # If there are no optional arguments
1436 if not ethType and not ethSrc and not ethDst\
1437 and not bandwidth and not lambdaAlloc\
1438 and not ipProto and not ipSrc and not ipDst\
1439 and not tcpSrc and not tcpDst and not setEthSrc\
1440 and not setEthDst:
1441 cmd = "add-single-to-multi-intent"
1442
1443 else:
1444 cmd = "add-single-to-multi-intent"
1445
1446 if ethType:
1447 cmd += " --ethType " + str( ethType )
1448 if ethSrc:
1449 cmd += " --ethSrc " + str( ethSrc )
1450 if ethDst:
1451 cmd += " --ethDst " + str( ethDst )
1452 if bandwidth:
1453 cmd += " --bandwidth " + str( bandwidth )
1454 if lambdaAlloc:
1455 cmd += " --lambda "
1456 if ipProto:
1457 cmd += " --ipProto " + str( ipProto )
1458 if ipSrc:
1459 cmd += " --ipSrc " + str( ipSrc )
1460 if ipDst:
1461 cmd += " --ipDst " + str( ipDst )
1462 if tcpSrc:
1463 cmd += " --tcpSrc " + str( tcpSrc )
1464 if tcpDst:
1465 cmd += " --tcpDst " + str( tcpDst )
1466 if setEthSrc:
1467 cmd += " --setEthSrc " + str( setEthSrc )
1468 if setEthDst:
1469 cmd += " --setEthDst " + str( setEthDst )
1470
1471 # Check whether the user appended the port
1472 # or provided it as an input
Jon Hall08f61bc2015-04-13 16:00:30 -07001473
kelvin-onlabb9408212015-04-01 13:34:04 -07001474 if "/" in ingressDevice:
1475 cmd += " " + str( ingressDevice )
1476 else:
1477 if not portIngress:
1478 main.log.error( "You must specify " +
1479 "the Ingress port" )
1480 return main.FALSE
1481
1482 cmd += " " +\
1483 str( ingressDevice ) + "/" +\
1484 str( portIngress )
1485
1486 if portEgressList is None:
1487 for egressDevice in egressDeviceList:
1488 if "/" in egressDevice:
1489 cmd += " " + str( egressDevice )
1490 else:
1491 main.log.error( "You must specify " +
1492 "the egress port" )
1493 # TODO: perhaps more meaningful return
1494 return main.FALSE
1495 else:
1496 if len( egressDeviceList ) == len( portEgressList ):
Jon Hall08f61bc2015-04-13 16:00:30 -07001497 for egressDevice, portEgress in zip( egressDeviceList,
1498 portEgressList ):
kelvin-onlabb9408212015-04-01 13:34:04 -07001499 cmd += " " + \
1500 str( egressDevice ) + "/" +\
1501 str( portEgress )
kelvin-onlab38143812015-04-01 15:03:01 -07001502 else:
Jon Hall08f61bc2015-04-13 16:00:30 -07001503 main.log.error( "Device list and port list does not " +
1504 "have the same length" )
kelvin-onlab38143812015-04-01 15:03:01 -07001505 return main.FALSE
kelvin-onlabb9408212015-04-01 13:34:04 -07001506 handle = self.sendline( cmd )
1507 # If error, return error message
1508 if re.search( "Error", handle ):
1509 main.log.error( "Error in adding singlepoint-to-multipoint " +
1510 "intent" )
shahshreyac2f97072015-03-19 17:04:29 -07001511 return None
kelvin-onlabb9408212015-04-01 13:34:04 -07001512 else:
1513 match = re.search('id=0x([\da-f]+),', handle)
1514 if match:
1515 return match.group()[3:-1]
1516 else:
1517 main.log.error( "Error, intent ID not found" )
1518 return None
Jon Halld4d4b372015-01-28 16:02:41 -08001519 except TypeError:
1520 main.log.exception( self.name + ": Object not as expected" )
1521 return None
shahshreyad0c80432014-12-04 16:56:05 -08001522 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001523 main.log.error( self.name + ": EOF exception found" )
1524 main.log.error( self.name + ": " + self.handle.before )
shahshreyad0c80432014-12-04 16:56:05 -08001525 main.cleanup()
1526 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001527 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001528 main.log.exception( self.name + ": Uncaught exception!" )
shahshreyad0c80432014-12-04 16:56:05 -08001529 main.cleanup()
1530 main.exit()
1531
Hari Krishna9e232602015-04-13 17:29:08 -07001532 def addMplsIntent(
1533 self,
1534 ingressDevice,
1535 egressDevice,
Hari Krishna87a17f12015-04-13 17:42:23 -07001536 ingressPort="",
1537 egressPort="",
Hari Krishna9e232602015-04-13 17:29:08 -07001538 ethType="",
1539 ethSrc="",
1540 ethDst="",
1541 bandwidth="",
1542 lambdaAlloc=False,
1543 ipProto="",
1544 ipSrc="",
1545 ipDst="",
1546 tcpSrc="",
1547 tcpDst="",
Hari Krishna87a17f12015-04-13 17:42:23 -07001548 ingressLabel="",
Hari Krishnadfff6672015-04-13 17:53:27 -07001549 egressLabel="",
Hari Krishna9e232602015-04-13 17:29:08 -07001550 priority=""):
1551 """
1552 Required:
1553 * ingressDevice: device id of ingress device
1554 * egressDevice: device id of egress device
1555 Optional:
1556 * ethType: specify ethType
1557 * ethSrc: specify ethSrc ( i.e. src mac addr )
1558 * ethDst: specify ethDst ( i.e. dst mac addr )
1559 * bandwidth: specify bandwidth capacity of link
1560 * lambdaAlloc: if True, intent will allocate lambda
1561 for the specified intent
1562 * ipProto: specify ip protocol
1563 * ipSrc: specify ip source address
1564 * ipDst: specify ip destination address
1565 * tcpSrc: specify tcp source port
1566 * tcpDst: specify tcp destination port
1567 * ingressLabel: Ingress MPLS label
1568 * egressLabel: Egress MPLS label
1569 Description:
1570 Adds MPLS intent by
1571 specifying device id's and optional fields
1572 Returns:
1573 A string of the intent id or None on error
1574
1575 NOTE: This function may change depending on the
1576 options developers provide for MPLS
1577 intent via cli
1578 """
1579 try:
1580 # If there are no optional arguments
1581 if not ethType and not ethSrc and not ethDst\
1582 and not bandwidth and not lambdaAlloc \
1583 and not ipProto and not ipSrc and not ipDst \
1584 and not tcpSrc and not tcpDst and not ingressLabel \
1585 and not egressLabel:
1586 cmd = "add-mpls-intent"
1587
1588 else:
1589 cmd = "add-mpls-intent"
1590
1591 if ethType:
1592 cmd += " --ethType " + str( ethType )
1593 if ethSrc:
1594 cmd += " --ethSrc " + str( ethSrc )
1595 if ethDst:
1596 cmd += " --ethDst " + str( ethDst )
1597 if bandwidth:
1598 cmd += " --bandwidth " + str( bandwidth )
1599 if lambdaAlloc:
1600 cmd += " --lambda "
1601 if ipProto:
1602 cmd += " --ipProto " + str( ipProto )
1603 if ipSrc:
1604 cmd += " --ipSrc " + str( ipSrc )
1605 if ipDst:
1606 cmd += " --ipDst " + str( ipDst )
1607 if tcpSrc:
1608 cmd += " --tcpSrc " + str( tcpSrc )
1609 if tcpDst:
1610 cmd += " --tcpDst " + str( tcpDst )
1611 if ingressLabel:
1612 cmd += " --ingressLabel " + str( ingressLabel )
1613 if egressLabel:
1614 cmd += " --egressLabel " + str( egressLabel )
1615 if priority:
1616 cmd += " --priority " + str( priority )
1617
1618 # Check whether the user appended the port
1619 # or provided it as an input
1620 if "/" in ingressDevice:
1621 cmd += " " + str( ingressDevice )
1622 else:
Hari Krishna87a17f12015-04-13 17:42:23 -07001623 if not ingressPort:
Hari Krishna9e232602015-04-13 17:29:08 -07001624 main.log.error( "You must specify the ingress port" )
1625 return None
1626
1627 cmd += " " + \
1628 str( ingressDevice ) + "/" +\
Hari Krishna87a17f12015-04-13 17:42:23 -07001629 str( ingressPort ) + " "
Hari Krishna9e232602015-04-13 17:29:08 -07001630
1631 if "/" in egressDevice:
1632 cmd += " " + str( egressDevice )
1633 else:
Hari Krishna87a17f12015-04-13 17:42:23 -07001634 if not egressPort:
Hari Krishna9e232602015-04-13 17:29:08 -07001635 main.log.error( "You must specify the egress port" )
1636 return None
1637
1638 cmd += " " +\
1639 str( egressDevice ) + "/" +\
Hari Krishna87a17f12015-04-13 17:42:23 -07001640 str( egressPort )
Hari Krishna9e232602015-04-13 17:29:08 -07001641
1642 handle = self.sendline( cmd )
1643 # If error, return error message
1644 if re.search( "Error", handle ):
1645 main.log.error( "Error in adding mpls intent" )
1646 return None
1647 else:
1648 # TODO: print out all the options in this message?
1649 main.log.info( "MPLS intent installed between " +
1650 str( ingressDevice ) + " and " +
1651 str( egressDevice ) )
1652 match = re.search('id=0x([\da-f]+),', handle)
1653 if match:
1654 return match.group()[3:-1]
1655 else:
1656 main.log.error( "Error, intent ID not found" )
1657 return None
1658 except TypeError:
1659 main.log.exception( self.name + ": Object not as expected" )
1660 return None
1661 except pexpect.EOF:
1662 main.log.error( self.name + ": EOF exception found" )
1663 main.log.error( self.name + ": " + self.handle.before )
1664 main.cleanup()
1665 main.exit()
1666 except Exception:
1667 main.log.exception( self.name + ": Uncaught exception!" )
1668 main.cleanup()
1669 main.exit()
1670
Jon Hallefbd9792015-03-05 16:11:36 -08001671 def removeIntent( self, intentId, app='org.onosproject.cli',
1672 purge=False, sync=False ):
kelvin-onlab898a6c62015-01-16 14:13:53 -08001673 """
shahshreya1c818fc2015-02-26 13:44:08 -08001674 Remove intent for specified application id and intent id
Jon Hall61282e32015-03-19 11:34:11 -07001675 Optional args:-
shahshreya1c818fc2015-02-26 13:44:08 -08001676 -s or --sync: Waits for the removal before returning
Jon Hall61282e32015-03-19 11:34:11 -07001677 -p or --purge: Purge the intent from the store after removal
1678
Jon Halle3f39ff2015-01-13 11:50:53 -08001679 Returns:
1680 main.False on error and
1681 cli output otherwise
kelvin-onlab898a6c62015-01-16 14:13:53 -08001682 """
andrewonlab9a50dfe2014-10-17 17:22:31 -04001683 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07001684 cmdStr = "remove-intent"
shahshreya1c818fc2015-02-26 13:44:08 -08001685 if purge:
1686 cmdStr += " -p"
1687 if sync:
1688 cmdStr += " -s"
1689
1690 cmdStr += " " + app + " " + str( intentId )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001691 handle = self.sendline( cmdStr )
Jon Halle3f39ff2015-01-13 11:50:53 -08001692 if re.search( "Error", handle ):
kelvin-onlab898a6c62015-01-16 14:13:53 -08001693 main.log.error( "Error in removing intent" )
Jon Halle3f39ff2015-01-13 11:50:53 -08001694 return main.FALSE
andrewonlab9a50dfe2014-10-17 17:22:31 -04001695 else:
Jon Halle3f39ff2015-01-13 11:50:53 -08001696 # TODO: Should this be main.TRUE
1697 return handle
Jon Halld4d4b372015-01-28 16:02:41 -08001698 except TypeError:
1699 main.log.exception( self.name + ": Object not as expected" )
1700 return None
andrewonlab9a50dfe2014-10-17 17:22:31 -04001701 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001702 main.log.error( self.name + ": EOF exception found" )
1703 main.log.error( self.name + ": " + self.handle.before )
andrewonlab9a50dfe2014-10-17 17:22:31 -04001704 main.cleanup()
1705 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001706 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001707 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab9a50dfe2014-10-17 17:22:31 -04001708 main.cleanup()
1709 main.exit()
1710
Hari Krishnaacabd5a2015-07-01 17:10:19 -07001711 def purgeWithdrawnIntents( self ):
Hari Krishna0ce0e152015-06-23 09:55:29 -07001712 """
1713 Purges all WITHDRAWN Intents
1714 """
1715 try:
1716 cmdStr = "purge-intents"
1717 handle = self.sendline( cmdStr )
1718 if re.search( "Error", handle ):
1719 main.log.error( "Error in purging intents" )
1720 return main.FALSE
1721 else:
1722 return main.TRUE
1723 except TypeError:
1724 main.log.exception( self.name + ": Object not as expected" )
1725 return None
1726 except pexpect.EOF:
1727 main.log.error( self.name + ": EOF exception found" )
1728 main.log.error( self.name + ": " + self.handle.before )
1729 main.cleanup()
1730 main.exit()
1731 except Exception:
1732 main.log.exception( self.name + ": Uncaught exception!" )
1733 main.cleanup()
1734 main.exit()
1735
kelvin-onlabd3b64892015-01-20 13:26:24 -08001736 def routes( self, jsonFormat=False ):
kelvin8ec71442015-01-15 16:57:00 -08001737 """
kelvin-onlab898a6c62015-01-16 14:13:53 -08001738 NOTE: This method should be used after installing application:
1739 onos-app-sdnip
pingping-lin8b306ac2014-11-17 18:13:51 -08001740 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001741 * jsonFormat: enable output formatting in json
pingping-lin8b306ac2014-11-17 18:13:51 -08001742 Description:
1743 Obtain all routes in the system
kelvin8ec71442015-01-15 16:57:00 -08001744 """
pingping-lin8b306ac2014-11-17 18:13:51 -08001745 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07001746 cmdStr = "routes"
kelvin-onlabd3b64892015-01-20 13:26:24 -08001747 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07001748 cmdStr += " -j"
1749 handle = self.sendline( cmdStr )
pingping-lin8b306ac2014-11-17 18:13:51 -08001750 return handle
Jon Halld4d4b372015-01-28 16:02:41 -08001751 except TypeError:
1752 main.log.exception( self.name + ": Object not as expected" )
1753 return None
pingping-lin8b306ac2014-11-17 18:13:51 -08001754 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001755 main.log.error( self.name + ": EOF exception found" )
1756 main.log.error( self.name + ": " + self.handle.before )
pingping-lin8b306ac2014-11-17 18:13:51 -08001757 main.cleanup()
1758 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001759 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001760 main.log.exception( self.name + ": Uncaught exception!" )
pingping-lin8b306ac2014-11-17 18:13:51 -08001761 main.cleanup()
1762 main.exit()
1763
pingping-lin54b03372015-08-13 14:43:10 -07001764 def ipv4RouteNumber( self ):
1765 """
1766 NOTE: This method should be used after installing application:
1767 onos-app-sdnip
1768 Description:
1769 Obtain the total IPv4 routes number in the system
1770 """
1771 try:
1772 cmdStr = "routes -s -j"
1773 handle = self.sendline( cmdStr )
1774 jsonResult = json.loads( handle )
1775 return jsonResult['totalRoutes4']
1776
1777 except TypeError:
1778 main.log.exception( self.name + ": Object not as expected" )
1779 return None
1780 except pexpect.EOF:
1781 main.log.error( self.name + ": EOF exception found" )
1782 main.log.error( self.name + ": " + self.handle.before )
1783 main.cleanup()
1784 main.exit()
1785 except Exception:
1786 main.log.exception( self.name + ": Uncaught exception!" )
1787 main.cleanup()
1788 main.exit()
1789
kelvin-onlabd3b64892015-01-20 13:26:24 -08001790 def intents( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -08001791 """
andrewonlab377693f2014-10-21 16:00:30 -04001792 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001793 * jsonFormat: enable output formatting in json
andrewonlabe6745342014-10-17 14:29:13 -04001794 Description:
Jon Halle3f39ff2015-01-13 11:50:53 -08001795 Obtain intents currently installed
kelvin-onlab898a6c62015-01-16 14:13:53 -08001796 """
andrewonlabe6745342014-10-17 14:29:13 -04001797 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07001798 cmdStr = "intents"
kelvin-onlabd3b64892015-01-20 13:26:24 -08001799 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07001800 cmdStr += " -j"
1801 handle = self.sendline( cmdStr )
andrewonlabe6745342014-10-17 14:29:13 -04001802 return handle
Jon Halld4d4b372015-01-28 16:02:41 -08001803 except TypeError:
1804 main.log.exception( self.name + ": Object not as expected" )
1805 return None
andrewonlabe6745342014-10-17 14:29:13 -04001806 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001807 main.log.error( self.name + ": EOF exception found" )
1808 main.log.error( self.name + ": " + self.handle.before )
andrewonlabe6745342014-10-17 14:29:13 -04001809 main.cleanup()
1810 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001811 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001812 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabe6745342014-10-17 14:29:13 -04001813 main.cleanup()
1814 main.exit()
1815
pingping-lin54b03372015-08-13 14:43:10 -07001816 def m2SIntentInstalledNumber( self ):
1817 """
1818 Description:
1819 Obtain the number of multiple point to single point intents
1820 installed
1821 """
1822 try:
1823 cmdStr = "intents -s -j"
1824 handle = self.sendline( cmdStr )
1825 jsonResult = json.loads( handle )
1826 return jsonResult['multiPointToSinglePoint']['installed']
1827
1828 except TypeError:
1829 main.log.exception( self.name + ": Object not as expected" )
1830 return None
1831 except pexpect.EOF:
1832 main.log.error( self.name + ": EOF exception found" )
1833 main.log.error( self.name + ": " + self.handle.before )
1834 main.cleanup()
1835 main.exit()
1836 except Exception:
1837 main.log.exception( self.name + ": Uncaught exception!" )
1838 main.cleanup()
1839 main.exit()
1840
kelvin-onlab54400a92015-02-26 18:05:51 -08001841 def getIntentState(self, intentsId, intentsJson=None):
1842 """
kelvin-onlab54400a92015-02-26 18:05:51 -08001843 Check intent state.
1844 Accepts a single intent ID (string type) or a list of intent IDs.
1845 Returns the state(string type) of the id if a single intent ID is
1846 accepted.
Jon Hallefbd9792015-03-05 16:11:36 -08001847 Returns a dictionary with intent IDs as the key and its
1848 corresponding states as the values
kelvin-onlabfb521662015-02-27 09:52:40 -08001849 Parameters:
kelvin-onlab54400a92015-02-26 18:05:51 -08001850 intentId: intent ID (string type)
1851 intentsJson: parsed json object from the onos:intents api
1852 Returns:
1853 state = An intent's state- INSTALL,WITHDRAWN etc.
1854 stateDict = Dictionary of intent's state. intent ID as the keys and
1855 state as the values.
1856 """
kelvin-onlab54400a92015-02-26 18:05:51 -08001857 try:
1858 state = "State is Undefined"
1859 if not intentsJson:
Jon Hallefbd9792015-03-05 16:11:36 -08001860 intentsJsonTemp = json.loads( self.intents() )
kelvin-onlab54400a92015-02-26 18:05:51 -08001861 else:
Jon Hallefbd9792015-03-05 16:11:36 -08001862 intentsJsonTemp = json.loads( intentsJson )
1863 if isinstance( intentsId, types.StringType ):
kelvin-onlab54400a92015-02-26 18:05:51 -08001864 for intent in intentsJsonTemp:
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07001865 if intentsId == intent[ 'id' ]:
1866 state = intent[ 'state' ]
kelvin-onlab54400a92015-02-26 18:05:51 -08001867 return state
Jon Hallefbd9792015-03-05 16:11:36 -08001868 main.log.info( "Cannot find intent ID" + str( intentsId ) +
1869 " on the list" )
kelvin-onlab54400a92015-02-26 18:05:51 -08001870 return state
Jon Hallefbd9792015-03-05 16:11:36 -08001871 elif isinstance( intentsId, types.ListType ):
kelvin-onlab07dbd012015-03-04 16:29:39 -08001872 dictList = []
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07001873 for i in xrange( len( intentsId ) ):
kelvin-onlab07dbd012015-03-04 16:29:39 -08001874 stateDict = {}
kelvin-onlab54400a92015-02-26 18:05:51 -08001875 for intents in intentsJsonTemp:
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07001876 if intentsId[ i ] == intents[ 'id' ]:
1877 stateDict[ 'state' ] = intents[ 'state' ]
1878 stateDict[ 'id' ] = intentsId[ i ]
Jon Hallefbd9792015-03-05 16:11:36 -08001879 dictList.append( stateDict )
kelvin-onlab54400a92015-02-26 18:05:51 -08001880 break
Jon Hallefbd9792015-03-05 16:11:36 -08001881 if len( intentsId ) != len( dictList ):
1882 main.log.info( "Cannot find some of the intent ID state" )
kelvin-onlab07dbd012015-03-04 16:29:39 -08001883 return dictList
kelvin-onlab54400a92015-02-26 18:05:51 -08001884 else:
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07001885 main.log.info( "Invalid intents ID entry" )
kelvin-onlab54400a92015-02-26 18:05:51 -08001886 return None
kelvin-onlab54400a92015-02-26 18:05:51 -08001887 except TypeError:
1888 main.log.exception( self.name + ": Object not as expected" )
1889 return None
1890 except pexpect.EOF:
1891 main.log.error( self.name + ": EOF exception found" )
1892 main.log.error( self.name + ": " + self.handle.before )
1893 main.cleanup()
1894 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001895 except Exception:
kelvin-onlab54400a92015-02-26 18:05:51 -08001896 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab7e4d2d32014-10-15 13:23:21 -04001897 main.cleanup()
1898 main.exit()
Jon Hall390696c2015-05-05 17:13:41 -07001899
kelvin-onlabf512e942015-06-08 19:42:59 -07001900 def checkIntentState( self, intentsId, expectedState='INSTALLED' ):
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07001901 """
1902 Description:
1903 Check intents state
1904 Required:
1905 intentsId - List of intents ID to be checked
1906 Optional:
kelvin-onlabf512e942015-06-08 19:42:59 -07001907 expectedState - Check the expected state(s) of each intents
1908 state in the list.
1909 *NOTE: You can pass in a list of expected state,
1910 Eg: expectedState = [ 'INSTALLED' , 'INSTALLING' ]
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07001911 Return:
kelvin-onlabf512e942015-06-08 19:42:59 -07001912 Returns main.TRUE only if all intent are the same as expected states
1913 , otherwise, returns main.FALSE.
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07001914 """
1915 try:
1916 # Generating a dictionary: intent id as a key and state as value
kelvin-onlabf512e942015-06-08 19:42:59 -07001917 returnValue = main.TRUE
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07001918 intentsDict = self.getIntentState( intentsId )
kelvin-onlabf512e942015-06-08 19:42:59 -07001919
Jon Hall390696c2015-05-05 17:13:41 -07001920 #print "len of intentsDict ", str( len( intentsDict ) )
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07001921 if len( intentsId ) != len( intentsDict ):
1922 main.log.info( self.name + "There is something wrong " +
1923 "getting intents state" )
1924 return main.FALSE
kelvin-onlabf512e942015-06-08 19:42:59 -07001925
1926 if isinstance( expectedState, types.StringType ):
1927 for intents in intentsDict:
1928 if intents.get( 'state' ) != expectedState:
kelvin-onlaba297c4d2015-06-01 13:53:55 -07001929 main.log.debug( self.name + " : Intent ID - " +
1930 intents.get( 'id' ) +
kelvin-onlabf512e942015-06-08 19:42:59 -07001931 " actual state = " +
1932 intents.get( 'state' )
1933 + " does not equal expected state = "
1934 + expectedState )
kelvin-onlaba297c4d2015-06-01 13:53:55 -07001935 returnValue = main.FALSE
kelvin-onlabf512e942015-06-08 19:42:59 -07001936
1937 elif isinstance( expectedState, types.ListType ):
1938 for intents in intentsDict:
1939 if not any( state == intents.get( 'state' ) for state in
1940 expectedState ):
1941 main.log.debug( self.name + " : Intent ID - " +
1942 intents.get( 'id' ) +
1943 " actual state = " +
1944 intents.get( 'state' ) +
1945 " does not equal expected states = "
1946 + str( expectedState ) )
1947 returnValue = main.FALSE
1948
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07001949 if returnValue == main.TRUE:
1950 main.log.info( self.name + ": All " +
1951 str( len( intentsDict ) ) +
kelvin-onlabf512e942015-06-08 19:42:59 -07001952 " intents are in " + str( expectedState ) +
1953 " state" )
kelvin-onlabc2dcd3f2015-04-09 16:40:02 -07001954 return returnValue
1955 except TypeError:
1956 main.log.exception( self.name + ": Object not as expected" )
1957 return None
1958 except pexpect.EOF:
1959 main.log.error( self.name + ": EOF exception found" )
1960 main.log.error( self.name + ": " + self.handle.before )
1961 main.cleanup()
1962 main.exit()
1963 except Exception:
1964 main.log.exception( self.name + ": Uncaught exception!" )
1965 main.cleanup()
1966 main.exit()
andrewonlab7e4d2d32014-10-15 13:23:21 -04001967
kelvin-onlabd3b64892015-01-20 13:26:24 -08001968 def flows( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -08001969 """
Shreya Shah0f01c812014-10-26 20:15:28 -04001970 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001971 * jsonFormat: enable output formatting in json
Shreya Shah0f01c812014-10-26 20:15:28 -04001972 Description:
Jon Halle3f39ff2015-01-13 11:50:53 -08001973 Obtain flows currently installed
kelvin-onlab898a6c62015-01-16 14:13:53 -08001974 """
Shreya Shah0f01c812014-10-26 20:15:28 -04001975 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07001976 cmdStr = "flows"
kelvin-onlabd3b64892015-01-20 13:26:24 -08001977 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07001978 cmdStr += " -j"
1979 handle = self.sendline( cmdStr )
Jon Hall61282e32015-03-19 11:34:11 -07001980 if re.search( "Error:", handle ):
kelvin-onlaba297c4d2015-06-01 13:53:55 -07001981 main.log.error( self.name + ": flows() response: " +
kelvin-onlab898a6c62015-01-16 14:13:53 -08001982 str( handle ) )
Shreya Shah0f01c812014-10-26 20:15:28 -04001983 return handle
Jon Halld4d4b372015-01-28 16:02:41 -08001984 except TypeError:
1985 main.log.exception( self.name + ": Object not as expected" )
1986 return None
Shreya Shah0f01c812014-10-26 20:15:28 -04001987 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001988 main.log.error( self.name + ": EOF exception found" )
1989 main.log.error( self.name + ": " + self.handle.before )
Shreya Shah0f01c812014-10-26 20:15:28 -04001990 main.cleanup()
1991 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001992 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08001993 main.log.exception( self.name + ": Uncaught exception!" )
Shreya Shah0f01c812014-10-26 20:15:28 -04001994 main.cleanup()
1995 main.exit()
1996
kelvin-onlab4df89f22015-04-13 18:10:23 -07001997 def checkFlowsState( self ):
1998 """
1999 Description:
2000 Check the if all the current flows are in ADDED state or
2001 PENDING_ADD state
2002 Return:
2003 returnValue - Returns main.TRUE only if all flows are in
2004 ADDED state or PENDING_ADD, return main.FALSE
2005 otherwise.
2006 """
2007 try:
2008 tempFlows = json.loads( self.flows() )
kelvin-onlabf0594d72015-05-19 17:25:12 -07002009 #print tempFlows[0]
kelvin-onlab4df89f22015-04-13 18:10:23 -07002010 returnValue = main.TRUE
kelvin-onlabf0594d72015-05-19 17:25:12 -07002011
kelvin-onlab4df89f22015-04-13 18:10:23 -07002012 for device in tempFlows:
2013 for flow in device.get( 'flows' ):
2014 if flow.get( 'state' ) != 'ADDED' and flow.get( 'state' ) != \
2015 'PENDING_ADD':
kelvin-onlabf2ec6e02015-05-27 14:15:28 -07002016
kelvin-onlab4df89f22015-04-13 18:10:23 -07002017 main.log.info( self.name + ": flow Id: " +
kelvin-onlabf2ec6e02015-05-27 14:15:28 -07002018 str( flow.get( 'groupId' ) ) +
2019 " | state:" +
2020 str( flow.get( 'state' ) ) )
kelvin-onlab4df89f22015-04-13 18:10:23 -07002021 returnValue = main.FALSE
kelvin-onlabf0594d72015-05-19 17:25:12 -07002022
kelvin-onlab4df89f22015-04-13 18:10:23 -07002023 return returnValue
2024 except TypeError:
2025 main.log.exception( self.name + ": Object not as expected" )
2026 return None
2027 except pexpect.EOF:
2028 main.log.error( self.name + ": EOF exception found" )
2029 main.log.error( self.name + ": " + self.handle.before )
2030 main.cleanup()
2031 main.exit()
2032 except Exception:
2033 main.log.exception( self.name + ": Uncaught exception!" )
2034 main.cleanup()
2035 main.exit()
2036
kelvin-onlabd3b64892015-01-20 13:26:24 -08002037 def pushTestIntents( self, dpidSrc, dpidDst, numIntents,
Jon Hallefbd9792015-03-05 16:11:36 -08002038 numMult="", appId="", report=True ):
kelvin8ec71442015-01-15 16:57:00 -08002039 """
andrewonlab87852b02014-11-19 18:44:19 -05002040 Description:
Jon Halle3f39ff2015-01-13 11:50:53 -08002041 Push a number of intents in a batch format to
andrewonlab87852b02014-11-19 18:44:19 -05002042 a specific point-to-point intent definition
2043 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002044 * dpidSrc: specify source dpid
2045 * dpidDst: specify destination dpid
2046 * numIntents: specify number of intents to push
andrewonlab87852b02014-11-19 18:44:19 -05002047 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002048 * numMult: number multiplier for multiplying
andrewonlabb66dfa12014-12-02 15:51:10 -05002049 the number of intents specified
kelvin-onlabd3b64892015-01-20 13:26:24 -08002050 * appId: specify the application id init to further
andrewonlabb66dfa12014-12-02 15:51:10 -05002051 modularize the intents
andrewonlab87852b02014-11-19 18:44:19 -05002052 * report: default True, returns latency information
kelvin8ec71442015-01-15 16:57:00 -08002053 """
andrewonlab87852b02014-11-19 18:44:19 -05002054 try:
kelvin8ec71442015-01-15 16:57:00 -08002055 cmd = "push-test-intents " +\
kelvin-onlabd3b64892015-01-20 13:26:24 -08002056 str( dpidSrc ) + " " + str( dpidDst ) + " " +\
2057 str( numIntents )
2058 if numMult:
2059 cmd += " " + str( numMult )
2060 # If app id is specified, then numMult
kelvin8ec71442015-01-15 16:57:00 -08002061 # must exist because of the way this command
kelvin-onlabd3b64892015-01-20 13:26:24 -08002062 if appId:
2063 cmd += " " + str( appId )
kelvin-onlab898a6c62015-01-16 14:13:53 -08002064 handle = self.sendline( cmd )
andrewonlab87852b02014-11-19 18:44:19 -05002065 if report:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002066 latResult = []
kelvin8ec71442015-01-15 16:57:00 -08002067 main.log.info( handle )
2068 # Split result by newline
2069 newline = handle.split( "\r\r\n" )
2070 # Ignore the first object of list, which is empty
2071 newline = newline[ 1: ]
2072 # Some sloppy parsing method to get the latency
andrewonlabb66dfa12014-12-02 15:51:10 -05002073 for result in newline:
kelvin8ec71442015-01-15 16:57:00 -08002074 result = result.split( ": " )
2075 # Append the first result of second parse
kelvin-onlabd3b64892015-01-20 13:26:24 -08002076 latResult.append( result[ 1 ].split( " " )[ 0 ] )
2077 main.log.info( latResult )
2078 return latResult
andrewonlab87852b02014-11-19 18:44:19 -05002079 else:
2080 return main.TRUE
Jon Halld4d4b372015-01-28 16:02:41 -08002081 except TypeError:
2082 main.log.exception( self.name + ": Object not as expected" )
2083 return None
andrewonlab87852b02014-11-19 18:44:19 -05002084 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002085 main.log.error( self.name + ": EOF exception found" )
2086 main.log.error( self.name + ": " + self.handle.before )
andrewonlab87852b02014-11-19 18:44:19 -05002087 main.cleanup()
2088 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002089 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002090 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab87852b02014-11-19 18:44:19 -05002091 main.cleanup()
2092 main.exit()
2093
kelvin-onlabd3b64892015-01-20 13:26:24 -08002094 def intentsEventsMetrics( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -08002095 """
Jon Halle3f39ff2015-01-13 11:50:53 -08002096 Description:Returns topology metrics
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002097 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002098 * jsonFormat: enable json formatting of output
kelvin8ec71442015-01-15 16:57:00 -08002099 """
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002100 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002101 cmdStr = "intents-events-metrics"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002102 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002103 cmdStr += " -j"
2104 handle = self.sendline( cmdStr )
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002105 return handle
Jon Halld4d4b372015-01-28 16:02:41 -08002106 except TypeError:
2107 main.log.exception( self.name + ": Object not as expected" )
2108 return None
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002109 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002110 main.log.error( self.name + ": EOF exception found" )
2111 main.log.error( self.name + ": " + self.handle.before )
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002112 main.cleanup()
2113 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002114 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002115 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab0dbb6ec2014-11-06 13:46:55 -05002116 main.cleanup()
2117 main.exit()
Shreya Shah0f01c812014-10-26 20:15:28 -04002118
kelvin-onlabd3b64892015-01-20 13:26:24 -08002119 def topologyEventsMetrics( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -08002120 """
2121 Description:Returns topology metrics
andrewonlab867212a2014-10-22 20:13:38 -04002122 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002123 * jsonFormat: enable json formatting of output
kelvin8ec71442015-01-15 16:57:00 -08002124 """
andrewonlab867212a2014-10-22 20:13:38 -04002125 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002126 cmdStr = "topology-events-metrics"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002127 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002128 cmdStr += " -j"
2129 handle = self.sendline( cmdStr )
jenkins7ead5a82015-03-13 10:28:21 -07002130 if handle:
2131 return handle
Jon Hallc6358dd2015-04-10 12:44:28 -07002132 elif jsonFormat:
Jon Hallbe379602015-03-24 13:39:32 -07002133 # Return empty json
jenkins7ead5a82015-03-13 10:28:21 -07002134 return '{}'
Jon Hallc6358dd2015-04-10 12:44:28 -07002135 else:
2136 return handle
Jon Halld4d4b372015-01-28 16:02:41 -08002137 except TypeError:
2138 main.log.exception( self.name + ": Object not as expected" )
2139 return None
andrewonlab867212a2014-10-22 20:13:38 -04002140 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002141 main.log.error( self.name + ": EOF exception found" )
2142 main.log.error( self.name + ": " + self.handle.before )
andrewonlab867212a2014-10-22 20:13:38 -04002143 main.cleanup()
2144 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002145 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002146 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab867212a2014-10-22 20:13:38 -04002147 main.cleanup()
2148 main.exit()
2149
kelvin8ec71442015-01-15 16:57:00 -08002150 # Wrapper functions ****************
2151 # Wrapper functions use existing driver
2152 # functions and extends their use case.
2153 # For example, we may use the output of
2154 # a normal driver function, and parse it
2155 # using a wrapper function
andrewonlab7e4d2d32014-10-15 13:23:21 -04002156
kelvin-onlabd3b64892015-01-20 13:26:24 -08002157 def getAllIntentsId( self ):
kelvin8ec71442015-01-15 16:57:00 -08002158 """
andrewonlab9a50dfe2014-10-17 17:22:31 -04002159 Description:
2160 Obtain all intent id's in a list
kelvin8ec71442015-01-15 16:57:00 -08002161 """
andrewonlab9a50dfe2014-10-17 17:22:31 -04002162 try:
kelvin8ec71442015-01-15 16:57:00 -08002163 # Obtain output of intents function
kelvin-onlabfb521662015-02-27 09:52:40 -08002164 intentsStr = self.intents(jsonFormat=False)
kelvin-onlabd3b64892015-01-20 13:26:24 -08002165 intentIdList = []
andrewonlab9a50dfe2014-10-17 17:22:31 -04002166
kelvin8ec71442015-01-15 16:57:00 -08002167 # Parse the intents output for ID's
kelvin-onlabd3b64892015-01-20 13:26:24 -08002168 intentsList = [ s.strip() for s in intentsStr.splitlines() ]
2169 for intents in intentsList:
kelvin-onlabfb521662015-02-27 09:52:40 -08002170 match = re.search('id=0x([\da-f]+),', intents)
2171 if match:
2172 tmpId = match.group()[3:-1]
2173 intentIdList.append( tmpId )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002174 return intentIdList
andrewonlab9a50dfe2014-10-17 17:22:31 -04002175
Jon Halld4d4b372015-01-28 16:02:41 -08002176 except TypeError:
2177 main.log.exception( self.name + ": Object not as expected" )
2178 return None
andrewonlab9a50dfe2014-10-17 17:22:31 -04002179 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002180 main.log.error( self.name + ": EOF exception found" )
2181 main.log.error( self.name + ": " + self.handle.before )
andrewonlab9a50dfe2014-10-17 17:22:31 -04002182 main.cleanup()
2183 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002184 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002185 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab9a50dfe2014-10-17 17:22:31 -04002186 main.cleanup()
2187 main.exit()
2188
Jon Hall30b82fa2015-03-04 17:15:43 -08002189 def FlowAddedCount( self, deviceId ):
2190 """
2191 Determine the number of flow rules for the given device id that are
2192 in the added state
2193 """
2194 try:
2195 cmdStr = "flows any " + str( deviceId ) + " | " +\
2196 "grep 'state=ADDED' | wc -l"
2197 handle = self.sendline( cmdStr )
2198 return handle
2199 except pexpect.EOF:
2200 main.log.error( self.name + ": EOF exception found" )
2201 main.log.error( self.name + ": " + self.handle.before )
2202 main.cleanup()
2203 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002204 except Exception:
Jon Hall30b82fa2015-03-04 17:15:43 -08002205 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab7e4d2d32014-10-15 13:23:21 -04002206 main.cleanup()
2207 main.exit()
2208
kelvin-onlabd3b64892015-01-20 13:26:24 -08002209 def getAllDevicesId( self ):
kelvin8ec71442015-01-15 16:57:00 -08002210 """
andrewonlab95ce8322014-10-13 14:12:04 -04002211 Use 'devices' function to obtain list of all devices
2212 and parse the result to obtain a list of all device
2213 id's. Returns this list. Returns empty list if no
2214 devices exist
kelvin8ec71442015-01-15 16:57:00 -08002215 List is ordered sequentially
2216
andrewonlab95ce8322014-10-13 14:12:04 -04002217 This function may be useful if you are not sure of the
kelvin8ec71442015-01-15 16:57:00 -08002218 device id, and wish to execute other commands using
andrewonlab95ce8322014-10-13 14:12:04 -04002219 the ids. By obtaining the list of device ids on the fly,
2220 you can iterate through the list to get mastership, etc.
kelvin8ec71442015-01-15 16:57:00 -08002221 """
andrewonlab95ce8322014-10-13 14:12:04 -04002222 try:
kelvin8ec71442015-01-15 16:57:00 -08002223 # Call devices and store result string
kelvin-onlabd3b64892015-01-20 13:26:24 -08002224 devicesStr = self.devices( jsonFormat=False )
2225 idList = []
kelvin8ec71442015-01-15 16:57:00 -08002226
kelvin-onlabd3b64892015-01-20 13:26:24 -08002227 if not devicesStr:
kelvin8ec71442015-01-15 16:57:00 -08002228 main.log.info( "There are no devices to get id from" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002229 return idList
kelvin8ec71442015-01-15 16:57:00 -08002230
2231 # Split the string into list by comma
kelvin-onlabd3b64892015-01-20 13:26:24 -08002232 deviceList = devicesStr.split( "," )
kelvin8ec71442015-01-15 16:57:00 -08002233 # Get temporary list of all arguments with string 'id='
kelvin-onlabd3b64892015-01-20 13:26:24 -08002234 tempList = [ dev for dev in deviceList if "id=" in dev ]
kelvin8ec71442015-01-15 16:57:00 -08002235 # Split list further into arguments before and after string
2236 # 'id='. Get the latter portion ( the actual device id ) and
kelvin-onlabd3b64892015-01-20 13:26:24 -08002237 # append to idList
2238 for arg in tempList:
2239 idList.append( arg.split( "id=" )[ 1 ] )
2240 return idList
andrewonlab95ce8322014-10-13 14:12:04 -04002241
Jon Halld4d4b372015-01-28 16:02:41 -08002242 except TypeError:
2243 main.log.exception( self.name + ": Object not as expected" )
2244 return None
andrewonlab95ce8322014-10-13 14:12:04 -04002245 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002246 main.log.error( self.name + ": EOF exception found" )
2247 main.log.error( self.name + ": " + self.handle.before )
andrewonlab95ce8322014-10-13 14:12:04 -04002248 main.cleanup()
2249 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002250 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002251 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ce8322014-10-13 14:12:04 -04002252 main.cleanup()
2253 main.exit()
2254
kelvin-onlabd3b64892015-01-20 13:26:24 -08002255 def getAllNodesId( self ):
kelvin8ec71442015-01-15 16:57:00 -08002256 """
andrewonlab7c211572014-10-15 16:45:20 -04002257 Uses 'nodes' function to obtain list of all nodes
2258 and parse the result of nodes to obtain just the
kelvin8ec71442015-01-15 16:57:00 -08002259 node id's.
andrewonlab7c211572014-10-15 16:45:20 -04002260 Returns:
2261 list of node id's
kelvin8ec71442015-01-15 16:57:00 -08002262 """
andrewonlab7c211572014-10-15 16:45:20 -04002263 try:
Jon Hall5aa168b2015-03-23 14:23:09 -07002264 nodesStr = self.nodes( jsonFormat=True )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002265 idList = []
Jon Hall5aa168b2015-03-23 14:23:09 -07002266 # Sample nodesStr output
2267 # id=local, address=127.0.0.1:9876, state=ACTIVE *
kelvin-onlabd3b64892015-01-20 13:26:24 -08002268 if not nodesStr:
kelvin8ec71442015-01-15 16:57:00 -08002269 main.log.info( "There are no nodes to get id from" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002270 return idList
Jon Hall5aa168b2015-03-23 14:23:09 -07002271 nodesJson = json.loads( nodesStr )
2272 idList = [ node.get('id') for node in nodesJson ]
kelvin-onlabd3b64892015-01-20 13:26:24 -08002273 return idList
kelvin8ec71442015-01-15 16:57:00 -08002274
Jon Halld4d4b372015-01-28 16:02:41 -08002275 except TypeError:
2276 main.log.exception( self.name + ": Object not as expected" )
2277 return None
andrewonlab7c211572014-10-15 16:45:20 -04002278 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002279 main.log.error( self.name + ": EOF exception found" )
2280 main.log.error( self.name + ": " + self.handle.before )
andrewonlab7c211572014-10-15 16:45:20 -04002281 main.cleanup()
2282 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002283 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002284 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab7c211572014-10-15 16:45:20 -04002285 main.cleanup()
2286 main.exit()
andrewonlab95ce8322014-10-13 14:12:04 -04002287
kelvin-onlabd3b64892015-01-20 13:26:24 -08002288 def getDevice( self, dpid=None ):
kelvin8ec71442015-01-15 16:57:00 -08002289 """
Jon Halla91c4dc2014-10-22 12:57:04 -04002290 Return the first device from the devices api whose 'id' contains 'dpid'
2291 Return None if there is no match
kelvin8ec71442015-01-15 16:57:00 -08002292 """
Jon Halla91c4dc2014-10-22 12:57:04 -04002293 try:
kelvin8ec71442015-01-15 16:57:00 -08002294 if dpid is None:
Jon Halla91c4dc2014-10-22 12:57:04 -04002295 return None
2296 else:
kelvin8ec71442015-01-15 16:57:00 -08002297 dpid = dpid.replace( ':', '' )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002298 rawDevices = self.devices()
2299 devicesJson = json.loads( rawDevices )
kelvin8ec71442015-01-15 16:57:00 -08002300 # search json for the device with dpid then return the device
kelvin-onlabd3b64892015-01-20 13:26:24 -08002301 for device in devicesJson:
kelvin8ec71442015-01-15 16:57:00 -08002302 # print "%s in %s?" % ( dpid, device[ 'id' ] )
2303 if dpid in device[ 'id' ]:
Jon Halla91c4dc2014-10-22 12:57:04 -04002304 return device
2305 return None
Jon Halld4d4b372015-01-28 16:02:41 -08002306 except TypeError:
2307 main.log.exception( self.name + ": Object not as expected" )
2308 return None
Jon Halla91c4dc2014-10-22 12:57:04 -04002309 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002310 main.log.error( self.name + ": EOF exception found" )
2311 main.log.error( self.name + ": " + self.handle.before )
Jon Halla91c4dc2014-10-22 12:57:04 -04002312 main.cleanup()
2313 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002314 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002315 main.log.exception( self.name + ": Uncaught exception!" )
Jon Halla91c4dc2014-10-22 12:57:04 -04002316 main.cleanup()
2317 main.exit()
2318
kelvin-onlabd3b64892015-01-20 13:26:24 -08002319 def checkStatus( self, ip, numoswitch, numolink, logLevel="info" ):
kelvin8ec71442015-01-15 16:57:00 -08002320 """
Jon Hallefbd9792015-03-05 16:11:36 -08002321 Checks the number of switches & links that ONOS sees against the
kelvin8ec71442015-01-15 16:57:00 -08002322 supplied values. By default this will report to main.log, but the
Jon Hallefbd9792015-03-05 16:11:36 -08002323 log level can be specified.
kelvin8ec71442015-01-15 16:57:00 -08002324
Jon Hall42db6dc2014-10-24 19:03:48 -04002325 Params: ip = ip used for the onos cli
2326 numoswitch = expected number of switches
Jon Hallefbd9792015-03-05 16:11:36 -08002327 numolink = expected number of links
kelvin-onlabd3b64892015-01-20 13:26:24 -08002328 logLevel = level to log to. Currently accepts
2329 'info', 'warn' and 'report'
Jon Hall42db6dc2014-10-24 19:03:48 -04002330
2331
kelvin-onlabd3b64892015-01-20 13:26:24 -08002332 logLevel can
Jon Hall42db6dc2014-10-24 19:03:48 -04002333
Jon Hallefbd9792015-03-05 16:11:36 -08002334 Returns: main.TRUE if the number of switches and links are correct,
2335 main.FALSE if the number of switches and links is incorrect,
Jon Hall42db6dc2014-10-24 19:03:48 -04002336 and main.ERROR otherwise
kelvin8ec71442015-01-15 16:57:00 -08002337 """
Jon Hall42db6dc2014-10-24 19:03:48 -04002338 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002339 topology = self.getTopology( ip )
Jon Hall42db6dc2014-10-24 19:03:48 -04002340 if topology == {}:
2341 return main.ERROR
2342 output = ""
kelvin8ec71442015-01-15 16:57:00 -08002343 # Is the number of switches is what we expected
2344 devices = topology.get( 'devices', False )
2345 links = topology.get( 'links', False )
kelvin-onlabfb521662015-02-27 09:52:40 -08002346 if devices is False or links is False:
Jon Hall42db6dc2014-10-24 19:03:48 -04002347 return main.ERROR
kelvin-onlabd3b64892015-01-20 13:26:24 -08002348 switchCheck = ( int( devices ) == int( numoswitch ) )
kelvin8ec71442015-01-15 16:57:00 -08002349 # Is the number of links is what we expected
kelvin-onlabd3b64892015-01-20 13:26:24 -08002350 linkCheck = ( int( links ) == int( numolink ) )
2351 if ( switchCheck and linkCheck ):
kelvin8ec71442015-01-15 16:57:00 -08002352 # We expected the correct numbers
Jon Hallefbd9792015-03-05 16:11:36 -08002353 output += "The number of links and switches match " +\
2354 "what was expected"
Jon Hall42db6dc2014-10-24 19:03:48 -04002355 result = main.TRUE
2356 else:
Jon Hallefbd9792015-03-05 16:11:36 -08002357 output += "The number of links and switches does not match " +\
2358 "what was expected"
Jon Hall42db6dc2014-10-24 19:03:48 -04002359 result = main.FALSE
kelvin-onlabd3b64892015-01-20 13:26:24 -08002360 output = output + "\n ONOS sees %i devices (%i expected) \
2361 and %i links (%i expected)" % (
2362 int( devices ), int( numoswitch ), int( links ),
2363 int( numolink ) )
2364 if logLevel == "report":
kelvin8ec71442015-01-15 16:57:00 -08002365 main.log.report( output )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002366 elif logLevel == "warn":
kelvin8ec71442015-01-15 16:57:00 -08002367 main.log.warn( output )
Jon Hall42db6dc2014-10-24 19:03:48 -04002368 else:
Jon Hall390696c2015-05-05 17:13:41 -07002369 main.log.info( self.name + ": " + output )
kelvin8ec71442015-01-15 16:57:00 -08002370 return result
Jon Halld4d4b372015-01-28 16:02:41 -08002371 except TypeError:
2372 main.log.exception( self.name + ": Object not as expected" )
2373 return None
Jon Hall42db6dc2014-10-24 19:03:48 -04002374 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002375 main.log.error( self.name + ": EOF exception found" )
2376 main.log.error( self.name + ": " + self.handle.before )
Jon Hall42db6dc2014-10-24 19:03:48 -04002377 main.cleanup()
2378 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002379 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002380 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall42db6dc2014-10-24 19:03:48 -04002381 main.cleanup()
2382 main.exit()
Jon Hall1c9e8732014-10-27 19:29:27 -04002383
kelvin-onlabd3b64892015-01-20 13:26:24 -08002384 def deviceRole( self, deviceId, onosNode, role="master" ):
kelvin8ec71442015-01-15 16:57:00 -08002385 """
Jon Hall1c9e8732014-10-27 19:29:27 -04002386 Calls the device-role cli command.
kelvin-onlabd3b64892015-01-20 13:26:24 -08002387 deviceId must be the id of a device as seen in the onos devices command
2388 onosNode is the ip of one of the onos nodes in the cluster
Jon Hall1c9e8732014-10-27 19:29:27 -04002389 role must be either master, standby, or none
2390
Jon Halle3f39ff2015-01-13 11:50:53 -08002391 Returns:
2392 main.TRUE or main.FALSE based on argument verification and
2393 main.ERROR if command returns and error
kelvin-onlab898a6c62015-01-16 14:13:53 -08002394 """
Jon Hall1c9e8732014-10-27 19:29:27 -04002395 try:
Jon Halle3f39ff2015-01-13 11:50:53 -08002396 if role.lower() == "master" or role.lower() == "standby" or\
Jon Hall1c9e8732014-10-27 19:29:27 -04002397 role.lower() == "none":
kelvin-onlabd3b64892015-01-20 13:26:24 -08002398 cmdStr = "device-role " +\
2399 str( deviceId ) + " " +\
2400 str( onosNode ) + " " +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08002401 str( role )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002402 handle = self.sendline( cmdStr )
kelvin-onlab898a6c62015-01-16 14:13:53 -08002403 if re.search( "Error", handle ):
2404 # end color output to escape any colours
2405 # from the cli
kelvin8ec71442015-01-15 16:57:00 -08002406 main.log.error( self.name + ": " +
kelvin-onlab898a6c62015-01-16 14:13:53 -08002407 handle + '\033[0m' )
kelvin8ec71442015-01-15 16:57:00 -08002408 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -08002409 return main.TRUE
Jon Hall1c9e8732014-10-27 19:29:27 -04002410 else:
kelvin-onlab898a6c62015-01-16 14:13:53 -08002411 main.log.error( "Invalid 'role' given to device_role(). " +
2412 "Value was '" + str(role) + "'." )
Jon Hall1c9e8732014-10-27 19:29:27 -04002413 return main.FALSE
Jon Halld4d4b372015-01-28 16:02:41 -08002414 except TypeError:
2415 main.log.exception( self.name + ": Object not as expected" )
2416 return None
Jon Hall1c9e8732014-10-27 19:29:27 -04002417 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002418 main.log.error( self.name + ": EOF exception found" )
2419 main.log.error( self.name + ": " + self.handle.before )
Jon Hall1c9e8732014-10-27 19:29:27 -04002420 main.cleanup()
2421 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002422 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002423 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall1c9e8732014-10-27 19:29:27 -04002424 main.cleanup()
2425 main.exit()
2426
kelvin-onlabd3b64892015-01-20 13:26:24 -08002427 def clusters( self, jsonFormat=True ):
kelvin8ec71442015-01-15 16:57:00 -08002428 """
Jon Hall73cf9cc2014-11-20 22:28:38 -08002429 Lists all clusters
Jon Hallffb386d2014-11-21 13:43:38 -08002430 Optional argument:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002431 * jsonFormat - boolean indicating if you want output in json
kelvin8ec71442015-01-15 16:57:00 -08002432 """
Jon Hall73cf9cc2014-11-20 22:28:38 -08002433 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002434 cmdStr = "clusters"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002435 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002436 cmdStr += " -j"
2437 handle = self.sendline( cmdStr )
2438 return handle
Jon Halld4d4b372015-01-28 16:02:41 -08002439 except TypeError:
2440 main.log.exception( self.name + ": Object not as expected" )
2441 return None
Jon Hall73cf9cc2014-11-20 22:28:38 -08002442 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002443 main.log.error( self.name + ": EOF exception found" )
2444 main.log.error( self.name + ": " + self.handle.before )
Jon Hall73cf9cc2014-11-20 22:28:38 -08002445 main.cleanup()
2446 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002447 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002448 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall73cf9cc2014-11-20 22:28:38 -08002449 main.cleanup()
2450 main.exit()
2451
kelvin-onlabd3b64892015-01-20 13:26:24 -08002452 def electionTestLeader( self ):
kelvin-onlab898a6c62015-01-16 14:13:53 -08002453 """
Jon Halle3f39ff2015-01-13 11:50:53 -08002454 CLI command to get the current leader for the Election test application
2455 NOTE: Requires installation of the onos-app-election feature
2456 Returns: Node IP of the leader if one exists
2457 None if none exists
2458 Main.FALSE on error
kelvin-onlab898a6c62015-01-16 14:13:53 -08002459 """
Jon Hall94fd0472014-12-08 11:52:42 -08002460 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002461 cmdStr = "election-test-leader"
2462 response = self.sendline( cmdStr )
Jon Halle3f39ff2015-01-13 11:50:53 -08002463 # Leader
2464 leaderPattern = "The\scurrent\sleader\sfor\sthe\sElection\s" +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08002465 "app\sis\s(?P<node>.+)\."
kelvin-onlabd3b64892015-01-20 13:26:24 -08002466 nodeSearch = re.search( leaderPattern, response )
2467 if nodeSearch:
2468 node = nodeSearch.group( 'node' )
Jon Halle3f39ff2015-01-13 11:50:53 -08002469 main.log.info( "Election-test-leader on " + str( self.name ) +
kelvin-onlab898a6c62015-01-16 14:13:53 -08002470 " found " + node + " as the leader" )
Jon Hall94fd0472014-12-08 11:52:42 -08002471 return node
Jon Halle3f39ff2015-01-13 11:50:53 -08002472 # no leader
2473 nullPattern = "There\sis\scurrently\sno\sleader\selected\sfor\s" +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08002474 "the\sElection\sapp"
kelvin-onlabd3b64892015-01-20 13:26:24 -08002475 nullSearch = re.search( nullPattern, response )
2476 if nullSearch:
Jon Halle3f39ff2015-01-13 11:50:53 -08002477 main.log.info( "Election-test-leader found no leader on " +
kelvin-onlab898a6c62015-01-16 14:13:53 -08002478 self.name )
Jon Hall94fd0472014-12-08 11:52:42 -08002479 return None
kelvin-onlab898a6c62015-01-16 14:13:53 -08002480 # error
Jon Halle3f39ff2015-01-13 11:50:53 -08002481 errorPattern = "Command\snot\sfound"
kelvin-onlab898a6c62015-01-16 14:13:53 -08002482 if re.search( errorPattern, response ):
2483 main.log.error( "Election app is not loaded on " + self.name )
Jon Halle3f39ff2015-01-13 11:50:53 -08002484 # TODO: Should this be main.ERROR?
Jon Hall669173b2014-12-17 11:36:30 -08002485 return main.FALSE
2486 else:
Jon Hall390696c2015-05-05 17:13:41 -07002487 main.log.error( "Error in electionTestLeader on " + self.name +
2488 ": " + "unexpected response" )
kelvin8ec71442015-01-15 16:57:00 -08002489 main.log.error( repr( response ) )
Jon Hall669173b2014-12-17 11:36:30 -08002490 return main.FALSE
Jon Halld4d4b372015-01-28 16:02:41 -08002491 except TypeError:
2492 main.log.exception( self.name + ": Object not as expected" )
2493 return main.FALSE
Jon Hall94fd0472014-12-08 11:52:42 -08002494 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002495 main.log.error( self.name + ": EOF exception found" )
2496 main.log.error( self.name + ": " + self.handle.before )
Jon Hall94fd0472014-12-08 11:52:42 -08002497 main.cleanup()
2498 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002499 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002500 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall94fd0472014-12-08 11:52:42 -08002501 main.cleanup()
2502 main.exit()
2503
kelvin-onlabd3b64892015-01-20 13:26:24 -08002504 def electionTestRun( self ):
kelvin-onlab898a6c62015-01-16 14:13:53 -08002505 """
Jon Halle3f39ff2015-01-13 11:50:53 -08002506 CLI command to run for leadership of the Election test application.
2507 NOTE: Requires installation of the onos-app-election feature
2508 Returns: Main.TRUE on success
2509 Main.FALSE on error
kelvin-onlab898a6c62015-01-16 14:13:53 -08002510 """
Jon Hall94fd0472014-12-08 11:52:42 -08002511 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002512 cmdStr = "election-test-run"
2513 response = self.sendline( cmdStr )
kelvin-onlab898a6c62015-01-16 14:13:53 -08002514 # success
Jon Halle3f39ff2015-01-13 11:50:53 -08002515 successPattern = "Entering\sleadership\selections\sfor\sthe\s" +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08002516 "Election\sapp."
Jon Halle3f39ff2015-01-13 11:50:53 -08002517 search = re.search( successPattern, response )
Jon Hall94fd0472014-12-08 11:52:42 -08002518 if search:
Jon Halle3f39ff2015-01-13 11:50:53 -08002519 main.log.info( self.name + " entering leadership elections " +
kelvin-onlab898a6c62015-01-16 14:13:53 -08002520 "for the Election app." )
Jon Hall94fd0472014-12-08 11:52:42 -08002521 return main.TRUE
kelvin-onlab898a6c62015-01-16 14:13:53 -08002522 # error
Jon Halle3f39ff2015-01-13 11:50:53 -08002523 errorPattern = "Command\snot\sfound"
2524 if re.search( errorPattern, response ):
2525 main.log.error( "Election app is not loaded on " + self.name )
Jon Hall669173b2014-12-17 11:36:30 -08002526 return main.FALSE
2527 else:
Jon Hall390696c2015-05-05 17:13:41 -07002528 main.log.error( "Error in electionTestRun on " + self.name +
2529 ": " + "unexpected response" )
Jon Halle3f39ff2015-01-13 11:50:53 -08002530 main.log.error( repr( response ) )
Jon Hall669173b2014-12-17 11:36:30 -08002531 return main.FALSE
Jon Halld4d4b372015-01-28 16:02:41 -08002532 except TypeError:
2533 main.log.exception( self.name + ": Object not as expected" )
2534 return main.FALSE
Jon Hall94fd0472014-12-08 11:52:42 -08002535 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002536 main.log.error( self.name + ": EOF exception found" )
2537 main.log.error( self.name + ": " + self.handle.before )
Jon Hall94fd0472014-12-08 11:52:42 -08002538 main.cleanup()
2539 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002540 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002541 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall94fd0472014-12-08 11:52:42 -08002542 main.cleanup()
2543 main.exit()
2544
kelvin-onlabd3b64892015-01-20 13:26:24 -08002545 def electionTestWithdraw( self ):
kelvin8ec71442015-01-15 16:57:00 -08002546 """
Jon Hall94fd0472014-12-08 11:52:42 -08002547 * CLI command to withdraw the local node from leadership election for
2548 * the Election test application.
2549 #NOTE: Requires installation of the onos-app-election feature
2550 Returns: Main.TRUE on success
2551 Main.FALSE on error
kelvin8ec71442015-01-15 16:57:00 -08002552 """
Jon Hall94fd0472014-12-08 11:52:42 -08002553 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002554 cmdStr = "election-test-withdraw"
2555 response = self.sendline( cmdStr )
kelvin-onlab898a6c62015-01-16 14:13:53 -08002556 # success
Jon Halle3f39ff2015-01-13 11:50:53 -08002557 successPattern = "Withdrawing\sfrom\sleadership\selections\sfor" +\
kelvin-onlab898a6c62015-01-16 14:13:53 -08002558 "\sthe\sElection\sapp."
Jon Halle3f39ff2015-01-13 11:50:53 -08002559 if re.search( successPattern, response ):
2560 main.log.info( self.name + " withdrawing from leadership " +
kelvin-onlab898a6c62015-01-16 14:13:53 -08002561 "elections for the Election app." )
Jon Hall94fd0472014-12-08 11:52:42 -08002562 return main.TRUE
kelvin-onlab898a6c62015-01-16 14:13:53 -08002563 # error
Jon Halle3f39ff2015-01-13 11:50:53 -08002564 errorPattern = "Command\snot\sfound"
2565 if re.search( errorPattern, response ):
2566 main.log.error( "Election app is not loaded on " + self.name )
Jon Hall669173b2014-12-17 11:36:30 -08002567 return main.FALSE
2568 else:
Jon Hall390696c2015-05-05 17:13:41 -07002569 main.log.error( "Error in electionTestWithdraw on " +
2570 self.name + ": " + "unexpected response" )
Jon Halle3f39ff2015-01-13 11:50:53 -08002571 main.log.error( repr( response ) )
Jon Hall669173b2014-12-17 11:36:30 -08002572 return main.FALSE
Jon Halld4d4b372015-01-28 16:02:41 -08002573 except TypeError:
2574 main.log.exception( self.name + ": Object not as expected" )
2575 return main.FALSE
Jon Hall94fd0472014-12-08 11:52:42 -08002576 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002577 main.log.error( self.name + ": EOF exception found" )
2578 main.log.error( self.name + ": " + self.handle.before )
Jon Hall94fd0472014-12-08 11:52:42 -08002579 main.cleanup()
2580 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002581 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002582 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall94fd0472014-12-08 11:52:42 -08002583 main.cleanup()
2584 main.exit()
Jon Hall1c9e8732014-10-27 19:29:27 -04002585
kelvin8ec71442015-01-15 16:57:00 -08002586 def getDevicePortsEnabledCount( self, dpid ):
2587 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002588 Get the count of all enabled ports on a particular device/switch
kelvin8ec71442015-01-15 16:57:00 -08002589 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002590 try:
Jon Halle3f39ff2015-01-13 11:50:53 -08002591 dpid = str( dpid )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002592 cmdStr = "onos:ports -e " + dpid + " | wc -l"
2593 output = self.sendline( cmdStr )
Jon Halle3f39ff2015-01-13 11:50:53 -08002594 if re.search( "No such device", output ):
2595 main.log.error( "Error in getting ports" )
2596 return ( output, "Error" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002597 else:
Jon Halle3f39ff2015-01-13 11:50:53 -08002598 return output
Jon Halld4d4b372015-01-28 16:02:41 -08002599 except TypeError:
2600 main.log.exception( self.name + ": Object not as expected" )
2601 return ( output, "Error" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002602 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002603 main.log.error( self.name + ": EOF exception found" )
2604 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002605 main.cleanup()
2606 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002607 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002608 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002609 main.cleanup()
2610 main.exit()
2611
kelvin8ec71442015-01-15 16:57:00 -08002612 def getDeviceLinksActiveCount( self, dpid ):
2613 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002614 Get the count of all enabled ports on a particular device/switch
kelvin8ec71442015-01-15 16:57:00 -08002615 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002616 try:
kelvin-onlab898a6c62015-01-16 14:13:53 -08002617 dpid = str( dpid )
kelvin-onlabd3b64892015-01-20 13:26:24 -08002618 cmdStr = "onos:links " + dpid + " | grep ACTIVE | wc -l"
2619 output = self.sendline( cmdStr )
Jon Halle3f39ff2015-01-13 11:50:53 -08002620 if re.search( "No such device", output ):
kelvin-onlab898a6c62015-01-16 14:13:53 -08002621 main.log.error( "Error in getting ports " )
2622 return ( output, "Error " )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002623 else:
Jon Halle3f39ff2015-01-13 11:50:53 -08002624 return output
Jon Halld4d4b372015-01-28 16:02:41 -08002625 except TypeError:
2626 main.log.exception( self.name + ": Object not as expected" )
2627 return ( output, "Error " )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002628 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002629 main.log.error( self.name + ": EOF exception found" )
2630 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002631 main.cleanup()
2632 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002633 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002634 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002635 main.cleanup()
2636 main.exit()
2637
kelvin8ec71442015-01-15 16:57:00 -08002638 def getAllIntentIds( self ):
2639 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002640 Return a list of all Intent IDs
kelvin8ec71442015-01-15 16:57:00 -08002641 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002642 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08002643 cmdStr = "onos:intents | grep id="
2644 output = self.sendline( cmdStr )
Jon Halle3f39ff2015-01-13 11:50:53 -08002645 if re.search( "Error", output ):
2646 main.log.error( "Error in getting ports" )
2647 return ( output, "Error" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002648 else:
Jon Halle3f39ff2015-01-13 11:50:53 -08002649 return output
Jon Halld4d4b372015-01-28 16:02:41 -08002650 except TypeError:
2651 main.log.exception( self.name + ": Object not as expected" )
2652 return ( output, "Error" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002653 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08002654 main.log.error( self.name + ": EOF exception found" )
2655 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002656 main.cleanup()
2657 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002658 except Exception:
Jon Halld4d4b372015-01-28 16:02:41 -08002659 main.log.exception( self.name + ": Uncaught exception!" )
2660 main.cleanup()
2661 main.exit()
2662
Jon Hall73509952015-02-24 16:42:56 -08002663 def intentSummary( self ):
2664 """
Jon Hallefbd9792015-03-05 16:11:36 -08002665 Returns a dictionary containing the current intent states and the count
Jon Hall73509952015-02-24 16:42:56 -08002666 """
2667 try:
2668 intents = self.intents( )
Jon Hall08f61bc2015-04-13 16:00:30 -07002669 states = []
Jon Hall5aa168b2015-03-23 14:23:09 -07002670 for intent in json.loads( intents ):
Jon Hall08f61bc2015-04-13 16:00:30 -07002671 states.append( intent.get( 'state', None ) )
2672 out = [ ( i, states.count( i ) ) for i in set( states ) ]
Jon Hall63604932015-02-26 17:09:50 -08002673 main.log.info( dict( out ) )
Jon Hall73509952015-02-24 16:42:56 -08002674 return dict( out )
2675 except TypeError:
2676 main.log.exception( self.name + ": Object not as expected" )
2677 return None
2678 except pexpect.EOF:
2679 main.log.error( self.name + ": EOF exception found" )
2680 main.log.error( self.name + ": " + self.handle.before )
2681 main.cleanup()
2682 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08002683 except Exception:
Jon Hall73509952015-02-24 16:42:56 -08002684 main.log.exception( self.name + ": Uncaught exception!" )
2685 main.cleanup()
2686 main.exit()
Jon Hall63604932015-02-26 17:09:50 -08002687
Jon Hall61282e32015-03-19 11:34:11 -07002688 def leaders( self, jsonFormat=True ):
Jon Hall63604932015-02-26 17:09:50 -08002689 """
2690 Returns the output of the leaders command.
Jon Hall61282e32015-03-19 11:34:11 -07002691 Optional argument:
2692 * jsonFormat - boolean indicating if you want output in json
Jon Hall63604932015-02-26 17:09:50 -08002693 """
Jon Hall63604932015-02-26 17:09:50 -08002694 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002695 cmdStr = "onos:leaders"
Jon Hall61282e32015-03-19 11:34:11 -07002696 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002697 cmdStr += " -j"
2698 output = self.sendline( cmdStr )
2699 return output
Jon Hall63604932015-02-26 17:09:50 -08002700 except TypeError:
2701 main.log.exception( self.name + ": Object not as expected" )
2702 return None
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002703 except pexpect.EOF:
2704 main.log.error( self.name + ": EOF exception found" )
2705 main.log.error( self.name + ": " + self.handle.before )
2706 main.cleanup()
2707 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07002708 except Exception:
Jon Hall63604932015-02-26 17:09:50 -08002709 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08002710 main.cleanup()
2711 main.exit()
Jon Hall63604932015-02-26 17:09:50 -08002712
acsmarsa4a4d1e2015-07-10 16:01:24 -07002713 def leaderCandidates( self, jsonFormat=True ):
2714 """
2715 Returns the output of the leaders -c command.
2716 Optional argument:
2717 * jsonFormat - boolean indicating if you want output in json
2718 """
2719 try:
2720 cmdStr = "onos:leaders -c"
2721 if jsonFormat:
2722 cmdStr += " -j"
2723 output = self.sendline( cmdStr )
2724 return output
2725 except TypeError:
2726 main.log.exception( self.name + ": Object not as expected" )
2727 return None
2728 except pexpect.EOF:
2729 main.log.error( self.name + ": EOF exception found" )
2730 main.log.error( self.name + ": " + self.handle.before )
2731 main.cleanup()
2732 main.exit()
2733 except Exception:
2734 main.log.exception( self.name + ": Uncaught exception!" )
2735 main.cleanup()
2736 main.exit()
2737
2738 def specificLeaderCandidate(self,topic):
2739 """
2740 Returns a list in format [leader,candidate1,candidate2,...] for a given
2741 topic parameter and an empty list if the topic doesn't exist
2742 If no leader is elected leader in the returned list will be "none"
2743 Returns None if there is a type error processing the json object
2744 """
2745 try:
2746 cmdStr = "onos:leaders -c -j"
2747 output = self.sendline( cmdStr )
2748 output = json.loads(output)
2749 results = []
2750 for dict in output:
2751 if dict["topic"] == topic:
2752 leader = dict["leader"]
2753 candidates = re.split(", ",dict["candidates"][1:-1])
2754 results.append(leader)
2755 results.extend(candidates)
2756 return results
2757 except TypeError:
2758 main.log.exception( self.name + ": Object not as expected" )
2759 return None
2760 except pexpect.EOF:
2761 main.log.error( self.name + ": EOF exception found" )
2762 main.log.error( self.name + ": " + self.handle.before )
2763 main.cleanup()
2764 main.exit()
2765 except Exception:
2766 main.log.exception( self.name + ": Uncaught exception!" )
2767 main.cleanup()
2768 main.exit()
2769
Jon Hall61282e32015-03-19 11:34:11 -07002770 def pendingMap( self, jsonFormat=True ):
Jon Hall63604932015-02-26 17:09:50 -08002771 """
2772 Returns the output of the intent Pending map.
2773 """
Jon Hall63604932015-02-26 17:09:50 -08002774 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002775 cmdStr = "onos:intents -p"
Jon Hall61282e32015-03-19 11:34:11 -07002776 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002777 cmdStr += " -j"
2778 output = self.sendline( cmdStr )
2779 return output
Jon Hall63604932015-02-26 17:09:50 -08002780 except TypeError:
2781 main.log.exception( self.name + ": Object not as expected" )
2782 return None
2783 except pexpect.EOF:
2784 main.log.error( self.name + ": EOF exception found" )
2785 main.log.error( self.name + ": " + self.handle.before )
2786 main.cleanup()
2787 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07002788 except Exception:
Jon Hall63604932015-02-26 17:09:50 -08002789 main.log.exception( self.name + ": Uncaught exception!" )
2790 main.cleanup()
2791 main.exit()
2792
Jon Hall61282e32015-03-19 11:34:11 -07002793 def partitions( self, jsonFormat=True ):
Jon Hall63604932015-02-26 17:09:50 -08002794 """
2795 Returns the output of the raft partitions command for ONOS.
2796 """
Jon Hall61282e32015-03-19 11:34:11 -07002797 # Sample JSON
2798 # {
2799 # "leader": "tcp://10.128.30.11:7238",
2800 # "members": [
2801 # "tcp://10.128.30.11:7238",
2802 # "tcp://10.128.30.17:7238",
2803 # "tcp://10.128.30.13:7238",
2804 # ],
2805 # "name": "p1",
2806 # "term": 3
2807 # },
Jon Hall63604932015-02-26 17:09:50 -08002808 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002809 cmdStr = "onos:partitions"
Jon Hall61282e32015-03-19 11:34:11 -07002810 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002811 cmdStr += " -j"
2812 output = self.sendline( cmdStr )
2813 return output
Jon Hall63604932015-02-26 17:09:50 -08002814 except TypeError:
2815 main.log.exception( self.name + ": Object not as expected" )
2816 return None
2817 except pexpect.EOF:
2818 main.log.error( self.name + ": EOF exception found" )
2819 main.log.error( self.name + ": " + self.handle.before )
2820 main.cleanup()
2821 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07002822 except Exception:
Jon Hall63604932015-02-26 17:09:50 -08002823 main.log.exception( self.name + ": Uncaught exception!" )
2824 main.cleanup()
2825 main.exit()
2826
Jon Hallbe379602015-03-24 13:39:32 -07002827 def apps( self, jsonFormat=True ):
2828 """
2829 Returns the output of the apps command for ONOS. This command lists
2830 information about installed ONOS applications
2831 """
2832 # Sample JSON object
2833 # [{"name":"org.onosproject.openflow","id":0,"version":"1.2.0",
2834 # "description":"ONOS OpenFlow protocol southbound providers",
2835 # "origin":"ON.Lab","permissions":"[]","featuresRepo":"",
2836 # "features":"[onos-openflow]","state":"ACTIVE"}]
2837 try:
Jon Hallc6358dd2015-04-10 12:44:28 -07002838 cmdStr = "onos:apps"
Jon Hallbe379602015-03-24 13:39:32 -07002839 if jsonFormat:
Jon Hallc6358dd2015-04-10 12:44:28 -07002840 cmdStr += " -j"
2841 output = self.sendline( cmdStr )
2842 assert "Error executing command" not in output
2843 return output
Jon Hallbe379602015-03-24 13:39:32 -07002844 # FIXME: look at specific exceptions/Errors
2845 except AssertionError:
2846 main.log.error( "Error in processing onos:app command: " +
2847 str( output ) )
2848 return None
2849 except TypeError:
2850 main.log.exception( self.name + ": Object not as expected" )
2851 return None
2852 except pexpect.EOF:
2853 main.log.error( self.name + ": EOF exception found" )
2854 main.log.error( self.name + ": " + self.handle.before )
2855 main.cleanup()
2856 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07002857 except Exception:
Jon Hallbe379602015-03-24 13:39:32 -07002858 main.log.exception( self.name + ": Uncaught exception!" )
2859 main.cleanup()
2860 main.exit()
2861
Jon Hall146f1522015-03-24 15:33:24 -07002862 def appStatus( self, appName ):
2863 """
2864 Uses the onos:apps cli command to return the status of an application.
2865 Returns:
2866 "ACTIVE" - If app is installed and activated
2867 "INSTALLED" - If app is installed and deactivated
2868 "UNINSTALLED" - If app is not installed
2869 None - on error
2870 """
Jon Hall146f1522015-03-24 15:33:24 -07002871 try:
2872 if not isinstance( appName, types.StringType ):
2873 main.log.error( self.name + ".appStatus(): appName must be" +
2874 " a string" )
2875 return None
2876 output = self.apps( jsonFormat=True )
2877 appsJson = json.loads( output )
2878 state = None
2879 for app in appsJson:
2880 if appName == app.get('name'):
2881 state = app.get('state')
2882 break
2883 if state == "ACTIVE" or state == "INSTALLED":
2884 return state
2885 elif state is None:
2886 return "UNINSTALLED"
2887 elif state:
2888 main.log.error( "Unexpected state from 'onos:apps': " +
2889 str( state ) )
2890 return state
2891 except TypeError:
2892 main.log.exception( self.name + ": Object not as expected" )
2893 return None
2894 except pexpect.EOF:
2895 main.log.error( self.name + ": EOF exception found" )
2896 main.log.error( self.name + ": " + self.handle.before )
2897 main.cleanup()
2898 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07002899 except Exception:
Jon Hall146f1522015-03-24 15:33:24 -07002900 main.log.exception( self.name + ": Uncaught exception!" )
2901 main.cleanup()
2902 main.exit()
2903
Jon Hallbe379602015-03-24 13:39:32 -07002904 def app( self, appName, option ):
2905 """
2906 Interacts with the app command for ONOS. This command manages
2907 application inventory.
2908 """
Jon Hallbe379602015-03-24 13:39:32 -07002909 try:
Jon Hallbd16b922015-03-26 17:53:15 -07002910 # Validate argument types
2911 valid = True
2912 if not isinstance( appName, types.StringType ):
2913 main.log.error( self.name + ".app(): appName must be a " +
2914 "string" )
2915 valid = False
2916 if not isinstance( option, types.StringType ):
2917 main.log.error( self.name + ".app(): option must be a string" )
2918 valid = False
2919 if not valid:
2920 return main.FALSE
2921 # Validate Option
2922 option = option.lower()
2923 # NOTE: Install may become a valid option
2924 if option == "activate":
2925 pass
2926 elif option == "deactivate":
2927 pass
2928 elif option == "uninstall":
2929 pass
2930 else:
2931 # Invalid option
2932 main.log.error( "The ONOS app command argument only takes " +
2933 "the values: (activate|deactivate|uninstall)" +
2934 "; was given '" + option + "'")
2935 return main.FALSE
Jon Hall146f1522015-03-24 15:33:24 -07002936 cmdStr = "onos:app " + option + " " + appName
Jon Hallbe379602015-03-24 13:39:32 -07002937 output = self.sendline( cmdStr )
Jon Hallbe379602015-03-24 13:39:32 -07002938 if "Error executing command" in output:
2939 main.log.error( "Error in processing onos:app command: " +
2940 str( output ) )
Jon Hall146f1522015-03-24 15:33:24 -07002941 return main.FALSE
Jon Hallbe379602015-03-24 13:39:32 -07002942 elif "No such application" in output:
2943 main.log.error( "The application '" + appName +
2944 "' is not installed in ONOS" )
Jon Hall146f1522015-03-24 15:33:24 -07002945 return main.FALSE
2946 elif "Command not found:" in output:
2947 main.log.error( "Error in processing onos:app command: " +
2948 str( output ) )
2949 return main.FALSE
Jon Hallbd16b922015-03-26 17:53:15 -07002950 elif "Unsupported command:" in output:
2951 main.log.error( "Incorrect command given to 'app': " +
2952 str( output ) )
Jon Hallbe379602015-03-24 13:39:32 -07002953 # NOTE: we may need to add more checks here
Jon Hallbd16b922015-03-26 17:53:15 -07002954 # else: Command was successful
Jon Hall08f61bc2015-04-13 16:00:30 -07002955 # main.log.debug( "app response: " + repr( output ) )
Jon Hallbe379602015-03-24 13:39:32 -07002956 return main.TRUE
2957 except TypeError:
2958 main.log.exception( self.name + ": Object not as expected" )
2959 return main.ERROR
2960 except pexpect.EOF:
2961 main.log.error( self.name + ": EOF exception found" )
2962 main.log.error( self.name + ": " + self.handle.before )
2963 main.cleanup()
2964 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07002965 except Exception:
Jon Hallbe379602015-03-24 13:39:32 -07002966 main.log.exception( self.name + ": Uncaught exception!" )
2967 main.cleanup()
2968 main.exit()
Jon Hall146f1522015-03-24 15:33:24 -07002969
Jon Hallbd16b922015-03-26 17:53:15 -07002970 def activateApp( self, appName, check=True ):
Jon Hall146f1522015-03-24 15:33:24 -07002971 """
2972 Activate an app that is already installed in ONOS
Jon Hallbd16b922015-03-26 17:53:15 -07002973 appName is the hierarchical app name, not the feature name
2974 If check is True, method will check the status of the app after the
2975 command is issued
Jon Hall146f1522015-03-24 15:33:24 -07002976 Returns main.TRUE if the command was successfully sent
2977 main.FALSE if the cli responded with an error or given
2978 incorrect input
2979 """
2980 try:
2981 if not isinstance( appName, types.StringType ):
2982 main.log.error( self.name + ".activateApp(): appName must be" +
2983 " a string" )
2984 return main.FALSE
2985 status = self.appStatus( appName )
2986 if status == "INSTALLED":
2987 response = self.app( appName, "activate" )
Jon Hallbd16b922015-03-26 17:53:15 -07002988 if check and response == main.TRUE:
2989 for i in range(10): # try 10 times then give up
2990 # TODO: Check with Thomas about this delay
2991 status = self.appStatus( appName )
2992 if status == "ACTIVE":
2993 return main.TRUE
2994 else:
Jon Hall050e1bd2015-03-30 13:33:02 -07002995 main.log.debug( "The state of application " +
2996 appName + " is " + status )
Jon Hallbd16b922015-03-26 17:53:15 -07002997 time.sleep( 1 )
2998 return main.FALSE
2999 else: # not 'check' or command didn't succeed
3000 return response
Jon Hall146f1522015-03-24 15:33:24 -07003001 elif status == "ACTIVE":
3002 return main.TRUE
3003 elif status == "UNINSTALLED":
3004 main.log.error( self.name + ": Tried to activate the " +
3005 "application '" + appName + "' which is not " +
3006 "installed." )
3007 else:
3008 main.log.error( "Unexpected return value from appStatus: " +
3009 str( status ) )
3010 return main.ERROR
3011 except TypeError:
3012 main.log.exception( self.name + ": Object not as expected" )
3013 return main.ERROR
3014 except pexpect.EOF:
3015 main.log.error( self.name + ": EOF exception found" )
3016 main.log.error( self.name + ": " + self.handle.before )
3017 main.cleanup()
3018 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003019 except Exception:
Jon Hall146f1522015-03-24 15:33:24 -07003020 main.log.exception( self.name + ": Uncaught exception!" )
3021 main.cleanup()
3022 main.exit()
3023
Jon Hallbd16b922015-03-26 17:53:15 -07003024 def deactivateApp( self, appName, check=True ):
Jon Hall146f1522015-03-24 15:33:24 -07003025 """
3026 Deactivate an app that is already activated in ONOS
Jon Hallbd16b922015-03-26 17:53:15 -07003027 appName is the hierarchical app name, not the feature name
3028 If check is True, method will check the status of the app after the
3029 command is issued
Jon Hall146f1522015-03-24 15:33:24 -07003030 Returns main.TRUE if the command was successfully sent
3031 main.FALSE if the cli responded with an error or given
3032 incorrect input
3033 """
3034 try:
3035 if not isinstance( appName, types.StringType ):
3036 main.log.error( self.name + ".deactivateApp(): appName must " +
3037 "be a string" )
3038 return main.FALSE
3039 status = self.appStatus( appName )
3040 if status == "INSTALLED":
3041 return main.TRUE
3042 elif status == "ACTIVE":
3043 response = self.app( appName, "deactivate" )
Jon Hallbd16b922015-03-26 17:53:15 -07003044 if check and response == main.TRUE:
3045 for i in range(10): # try 10 times then give up
3046 status = self.appStatus( appName )
3047 if status == "INSTALLED":
3048 return main.TRUE
3049 else:
3050 time.sleep( 1 )
3051 return main.FALSE
3052 else: # not check or command didn't succeed
3053 return response
Jon Hall146f1522015-03-24 15:33:24 -07003054 elif status == "UNINSTALLED":
3055 main.log.warn( self.name + ": Tried to deactivate the " +
3056 "application '" + appName + "' which is not " +
3057 "installed." )
3058 return main.TRUE
3059 else:
3060 main.log.error( "Unexpected return value from appStatus: " +
3061 str( status ) )
3062 return main.ERROR
3063 except TypeError:
3064 main.log.exception( self.name + ": Object not as expected" )
3065 return main.ERROR
3066 except pexpect.EOF:
3067 main.log.error( self.name + ": EOF exception found" )
3068 main.log.error( self.name + ": " + self.handle.before )
3069 main.cleanup()
3070 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003071 except Exception:
Jon Hall146f1522015-03-24 15:33:24 -07003072 main.log.exception( self.name + ": Uncaught exception!" )
3073 main.cleanup()
3074 main.exit()
3075
Jon Hallbd16b922015-03-26 17:53:15 -07003076 def uninstallApp( self, appName, check=True ):
Jon Hall146f1522015-03-24 15:33:24 -07003077 """
3078 Uninstall an app that is already installed in ONOS
Jon Hallbd16b922015-03-26 17:53:15 -07003079 appName is the hierarchical app name, not the feature name
3080 If check is True, method will check the status of the app after the
3081 command is issued
Jon Hall146f1522015-03-24 15:33:24 -07003082 Returns main.TRUE if the command was successfully sent
3083 main.FALSE if the cli responded with an error or given
3084 incorrect input
3085 """
3086 # TODO: check with Thomas about the state machine for apps
3087 try:
3088 if not isinstance( appName, types.StringType ):
3089 main.log.error( self.name + ".uninstallApp(): appName must " +
3090 "be a string" )
3091 return main.FALSE
3092 status = self.appStatus( appName )
3093 if status == "INSTALLED":
3094 response = self.app( appName, "uninstall" )
Jon Hallbd16b922015-03-26 17:53:15 -07003095 if check and response == main.TRUE:
3096 for i in range(10): # try 10 times then give up
3097 status = self.appStatus( appName )
3098 if status == "UNINSTALLED":
3099 return main.TRUE
3100 else:
3101 time.sleep( 1 )
3102 return main.FALSE
3103 else: # not check or command didn't succeed
3104 return response
Jon Hall146f1522015-03-24 15:33:24 -07003105 elif status == "ACTIVE":
3106 main.log.warn( self.name + ": Tried to uninstall the " +
3107 "application '" + appName + "' which is " +
3108 "currently active." )
3109 response = self.app( appName, "uninstall" )
Jon Hallbd16b922015-03-26 17:53:15 -07003110 if check and response == main.TRUE:
3111 for i in range(10): # try 10 times then give up
3112 status = self.appStatus( appName )
3113 if status == "UNINSTALLED":
3114 return main.TRUE
3115 else:
3116 time.sleep( 1 )
3117 return main.FALSE
3118 else: # not check or command didn't succeed
3119 return response
Jon Hall146f1522015-03-24 15:33:24 -07003120 elif status == "UNINSTALLED":
3121 return main.TRUE
3122 else:
3123 main.log.error( "Unexpected return value from appStatus: " +
3124 str( status ) )
3125 return main.ERROR
3126 except TypeError:
3127 main.log.exception( self.name + ": Object not as expected" )
3128 return main.ERROR
3129 except pexpect.EOF:
3130 main.log.error( self.name + ": EOF exception found" )
3131 main.log.error( self.name + ": " + self.handle.before )
3132 main.cleanup()
3133 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003134 except Exception:
Jon Hall146f1522015-03-24 15:33:24 -07003135 main.log.exception( self.name + ": Uncaught exception!" )
3136 main.cleanup()
3137 main.exit()
Jon Hallbd16b922015-03-26 17:53:15 -07003138
3139 def appIDs( self, jsonFormat=True ):
3140 """
3141 Show the mappings between app id and app names given by the 'app-ids'
3142 cli command
3143 """
3144 try:
3145 cmdStr = "app-ids"
3146 if jsonFormat:
3147 cmdStr += " -j"
Jon Hallc6358dd2015-04-10 12:44:28 -07003148 output = self.sendline( cmdStr )
3149 assert "Error executing command" not in output
3150 return output
Jon Hallbd16b922015-03-26 17:53:15 -07003151 except AssertionError:
3152 main.log.error( "Error in processing onos:app-ids command: " +
3153 str( output ) )
3154 return None
3155 except TypeError:
3156 main.log.exception( self.name + ": Object not as expected" )
3157 return None
3158 except pexpect.EOF:
3159 main.log.error( self.name + ": EOF exception found" )
3160 main.log.error( self.name + ": " + self.handle.before )
3161 main.cleanup()
3162 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003163 except Exception:
Jon Hallbd16b922015-03-26 17:53:15 -07003164 main.log.exception( self.name + ": Uncaught exception!" )
3165 main.cleanup()
3166 main.exit()
3167
3168 def appToIDCheck( self ):
3169 """
3170 This method will check that each application's ID listed in 'apps' is
3171 the same as the ID listed in 'app-ids'. The check will also check that
3172 there are no duplicate IDs issued. Note that an app ID should be
3173 a globaly unique numerical identifier for app/app-like features. Once
3174 an ID is registered, the ID is never freed up so that if an app is
3175 reinstalled it will have the same ID.
3176
3177 Returns: main.TRUE if the check passes and
3178 main.FALSE if the check fails or
3179 main.ERROR if there is some error in processing the test
3180 """
3181 try:
Jon Hall390696c2015-05-05 17:13:41 -07003182 bail = False
3183 ids = self.appIDs( jsonFormat=True )
3184 if ids:
3185 ids = json.loads( ids )
3186 else:
3187 main.log.error( "app-ids returned nothing:" + repr( ids ) )
3188 bail = True
3189 apps = self.apps( jsonFormat=True )
3190 if apps:
3191 apps = json.loads( apps )
3192 else:
3193 main.log.error( "apps returned nothing:" + repr( apps ) )
3194 bail = True
3195 if bail:
3196 return main.FALSE
Jon Hallbd16b922015-03-26 17:53:15 -07003197 result = main.TRUE
3198 for app in apps:
3199 appID = app.get( 'id' )
3200 if appID is None:
3201 main.log.error( "Error parsing app: " + str( app ) )
3202 result = main.FALSE
3203 appName = app.get( 'name' )
3204 if appName is None:
3205 main.log.error( "Error parsing app: " + str( app ) )
3206 result = main.FALSE
3207 # get the entry in ids that has the same appID
Jon Hall390696c2015-05-05 17:13:41 -07003208 current = filter( lambda item: item[ 'id' ] == appID, ids )
Jon Hall050e1bd2015-03-30 13:33:02 -07003209 # main.log.debug( "Comparing " + str( app ) + " to " +
3210 # str( current ) )
Jon Hallbd16b922015-03-26 17:53:15 -07003211 if not current: # if ids doesn't have this id
3212 result = main.FALSE
3213 main.log.error( "'app-ids' does not have the ID for " +
3214 str( appName ) + " that apps does." )
3215 elif len( current ) > 1:
3216 # there is more than one app with this ID
3217 result = main.FALSE
3218 # We will log this later in the method
3219 elif not current[0][ 'name' ] == appName:
3220 currentName = current[0][ 'name' ]
3221 result = main.FALSE
3222 main.log.error( "'app-ids' has " + str( currentName ) +
3223 " registered under id:" + str( appID ) +
3224 " but 'apps' has " + str( appName ) )
3225 else:
3226 pass # id and name match!
3227 # now make sure that app-ids has no duplicates
3228 idsList = []
3229 namesList = []
3230 for item in ids:
3231 idsList.append( item[ 'id' ] )
3232 namesList.append( item[ 'name' ] )
3233 if len( idsList ) != len( set( idsList ) ) or\
3234 len( namesList ) != len( set( namesList ) ):
3235 main.log.error( "'app-ids' has some duplicate entries: \n"
3236 + json.dumps( ids,
3237 sort_keys=True,
3238 indent=4,
3239 separators=( ',', ': ' ) ) )
3240 result = main.FALSE
3241 return result
3242 except ( ValueError, TypeError ):
3243 main.log.exception( self.name + ": Object not as expected" )
3244 return main.ERROR
3245 except pexpect.EOF:
3246 main.log.error( self.name + ": EOF exception found" )
3247 main.log.error( self.name + ": " + self.handle.before )
3248 main.cleanup()
3249 main.exit()
Jon Hall77ba41c2015-04-06 10:25:40 -07003250 except Exception:
Jon Hallbd16b922015-03-26 17:53:15 -07003251 main.log.exception( self.name + ": Uncaught exception!" )
3252 main.cleanup()
3253 main.exit()
3254
Jon Hallfb760a02015-04-13 15:35:03 -07003255 def getCfg( self, component=None, propName=None, short=False,
3256 jsonFormat=True ):
3257 """
3258 Get configuration settings from onos cli
3259 Optional arguments:
3260 component - Optionally only list configurations for a specific
3261 component. If None, all components with configurations
3262 are displayed. Case Sensitive string.
3263 propName - If component is specified, propName option will show
3264 only this specific configuration from that component.
3265 Case Sensitive string.
3266 jsonFormat - Returns output as json. Note that this will override
3267 the short option
3268 short - Short, less verbose, version of configurations.
3269 This is overridden by the json option
3270 returns:
3271 Output from cli as a string or None on error
3272 """
3273 try:
3274 baseStr = "cfg"
3275 cmdStr = " get"
3276 componentStr = ""
3277 if component:
3278 componentStr += " " + component
3279 if propName:
3280 componentStr += " " + propName
3281 if jsonFormat:
3282 baseStr += " -j"
3283 elif short:
3284 baseStr += " -s"
3285 output = self.sendline( baseStr + cmdStr + componentStr )
3286 assert "Error executing command" not in output
3287 return output
3288 except AssertionError:
3289 main.log.error( "Error in processing 'cfg get' command: " +
3290 str( output ) )
3291 return None
3292 except TypeError:
3293 main.log.exception( self.name + ": Object not as expected" )
3294 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
3305 def setCfg( self, component, propName, value=None, check=True ):
3306 """
3307 Set/Unset configuration settings from ONOS cli
Jon Hall390696c2015-05-05 17:13:41 -07003308 Required arguments:
Jon Hallfb760a02015-04-13 15:35:03 -07003309 component - The case sensitive name of the component whose
3310 property is to be set
3311 propName - The case sensitive name of the property to be set/unset
Jon Hall390696c2015-05-05 17:13:41 -07003312 Optional arguments:
Jon Hallfb760a02015-04-13 15:35:03 -07003313 value - The value to set the property to. If None, will unset the
3314 property and revert it to it's default value(if applicable)
3315 check - Boolean, Check whether the option was successfully set this
3316 only applies when a value is given.
3317 returns:
3318 main.TRUE on success or main.FALSE on failure. If check is False,
3319 will return main.TRUE unless there is an error
3320 """
3321 try:
3322 baseStr = "cfg"
3323 cmdStr = " set " + str( component ) + " " + str( propName )
3324 if value is not None:
3325 cmdStr += " " + str( value )
3326 output = self.sendline( baseStr + cmdStr )
3327 assert "Error executing command" not in output
3328 if value and check:
3329 results = self.getCfg( component=str( component ),
3330 propName=str( propName ),
3331 jsonFormat=True )
3332 # Check if current value is what we just set
3333 try:
3334 jsonOutput = json.loads( results )
3335 current = jsonOutput[ 'value' ]
3336 except ( ValueError, TypeError ):
3337 main.log.exception( "Error parsing cfg output" )
3338 main.log.error( "output:" + repr( results ) )
3339 return main.FALSE
3340 if current == str( value ):
3341 return main.TRUE
3342 return main.FALSE
3343 return main.TRUE
3344 except AssertionError:
3345 main.log.error( "Error in processing 'cfg set' command: " +
3346 str( output ) )
3347 return main.FALSE
3348 except TypeError:
3349 main.log.exception( self.name + ": Object not as expected" )
3350 return main.FALSE
3351 except pexpect.EOF:
3352 main.log.error( self.name + ": EOF exception found" )
3353 main.log.error( self.name + ": " + self.handle.before )
3354 main.cleanup()
3355 main.exit()
3356 except Exception:
3357 main.log.exception( self.name + ": Uncaught exception!" )
3358 main.cleanup()
3359 main.exit()
3360
Jon Hall390696c2015-05-05 17:13:41 -07003361 def setTestAdd( self, setName, values ):
3362 """
3363 CLI command to add elements to a distributed set.
3364 Arguments:
3365 setName - The name of the set to add to.
3366 values - The value(s) to add to the set, space seperated.
3367 Example usages:
3368 setTestAdd( "set1", "a b c" )
3369 setTestAdd( "set2", "1" )
3370 returns:
3371 main.TRUE on success OR
3372 main.FALSE if elements were already in the set OR
3373 main.ERROR on error
3374 """
3375 try:
3376 cmdStr = "set-test-add " + str( setName ) + " " + str( values )
3377 output = self.sendline( cmdStr )
Jon Hallfeff3082015-05-19 10:23:26 -07003378 try:
3379 # TODO: Maybe make this less hardcoded
3380 # ConsistentMap Exceptions
3381 assert "org.onosproject.store.service" not in output
3382 # Node not leader
3383 assert "java.lang.IllegalStateException" not in output
3384 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07003385 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07003386 "command: " + str( output ) )
3387 retryTime = 30 # Conservative time, given by Madan
3388 main.log.info( "Waiting " + str( retryTime ) +
3389 "seconds before retrying." )
3390 time.sleep( retryTime ) # Due to change in mastership
3391 output = self.sendline( cmdStr )
Jon Hall390696c2015-05-05 17:13:41 -07003392 assert "Error executing command" not in output
3393 positiveMatch = "\[(.*)\] was added to the set " + str( setName )
3394 negativeMatch = "\[(.*)\] was already in set " + str( setName )
3395 main.log.info( self.name + ": " + output )
3396 if re.search( positiveMatch, output):
3397 return main.TRUE
3398 elif re.search( negativeMatch, output):
3399 return main.FALSE
3400 else:
3401 main.log.error( self.name + ": setTestAdd did not" +
3402 " match expected output" )
Jon Hall390696c2015-05-05 17:13:41 -07003403 main.log.debug( self.name + " actual: " + repr( output ) )
3404 return main.ERROR
3405 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07003406 main.log.error( "Error in processing '" + cmdStr + "' command: " +
Jon Hall390696c2015-05-05 17:13:41 -07003407 str( output ) )
3408 return main.ERROR
3409 except TypeError:
3410 main.log.exception( self.name + ": Object not as expected" )
3411 return main.ERROR
3412 except pexpect.EOF:
3413 main.log.error( self.name + ": EOF exception found" )
3414 main.log.error( self.name + ": " + self.handle.before )
3415 main.cleanup()
3416 main.exit()
3417 except Exception:
3418 main.log.exception( self.name + ": Uncaught exception!" )
3419 main.cleanup()
3420 main.exit()
3421
3422 def setTestRemove( self, setName, values, clear=False, retain=False ):
3423 """
3424 CLI command to remove elements from a distributed set.
3425 Required arguments:
3426 setName - The name of the set to remove from.
3427 values - The value(s) to remove from the set, space seperated.
3428 Optional arguments:
3429 clear - Clear all elements from the set
3430 retain - Retain only the given values. (intersection of the
3431 original set and the given set)
3432 returns:
3433 main.TRUE on success OR
3434 main.FALSE if the set was not changed OR
3435 main.ERROR on error
3436 """
3437 try:
3438 cmdStr = "set-test-remove "
3439 if clear:
3440 cmdStr += "-c " + str( setName )
3441 elif retain:
3442 cmdStr += "-r " + str( setName ) + " " + str( values )
3443 else:
3444 cmdStr += str( setName ) + " " + str( values )
3445 output = self.sendline( cmdStr )
Jon Hallfeff3082015-05-19 10:23:26 -07003446 try:
3447 # TODO: Maybe make this less hardcoded
3448 # ConsistentMap Exceptions
3449 assert "org.onosproject.store.service" not in output
3450 # Node not leader
3451 assert "java.lang.IllegalStateException" not in output
3452 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07003453 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07003454 "command: " + str( output ) )
3455 retryTime = 30 # Conservative time, given by Madan
3456 main.log.info( "Waiting " + str( retryTime ) +
3457 "seconds before retrying." )
3458 time.sleep( retryTime ) # Due to change in mastership
3459 output = self.sendline( cmdStr )
Jon Hall390696c2015-05-05 17:13:41 -07003460 assert "Error executing command" not in output
3461 main.log.info( self.name + ": " + output )
3462 if clear:
3463 pattern = "Set " + str( setName ) + " cleared"
3464 if re.search( pattern, output ):
3465 return main.TRUE
3466 elif retain:
3467 positivePattern = str( setName ) + " was pruned to contain " +\
3468 "only elements of set \[(.*)\]"
3469 negativePattern = str( setName ) + " was not changed by " +\
3470 "retaining only elements of the set " +\
3471 "\[(.*)\]"
3472 if re.search( positivePattern, output ):
3473 return main.TRUE
3474 elif re.search( negativePattern, output ):
3475 return main.FALSE
3476 else:
3477 positivePattern = "\[(.*)\] was removed from the set " +\
3478 str( setName )
3479 if ( len( values.split() ) == 1 ):
3480 negativePattern = "\[(.*)\] was not in set " +\
3481 str( setName )
3482 else:
3483 negativePattern = "No element of \[(.*)\] was in set " +\
3484 str( setName )
3485 if re.search( positivePattern, output ):
3486 return main.TRUE
3487 elif re.search( negativePattern, output ):
3488 return main.FALSE
3489 main.log.error( self.name + ": setTestRemove did not" +
3490 " match expected output" )
3491 main.log.debug( self.name + " expected: " + pattern )
3492 main.log.debug( self.name + " actual: " + repr( output ) )
3493 return main.ERROR
3494 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07003495 main.log.error( "Error in processing '" + cmdStr + "' command: " +
Jon Hall390696c2015-05-05 17:13:41 -07003496 str( output ) )
3497 return main.ERROR
3498 except TypeError:
3499 main.log.exception( self.name + ": Object not as expected" )
3500 return main.ERROR
3501 except pexpect.EOF:
3502 main.log.error( self.name + ": EOF exception found" )
3503 main.log.error( self.name + ": " + self.handle.before )
3504 main.cleanup()
3505 main.exit()
3506 except Exception:
3507 main.log.exception( self.name + ": Uncaught exception!" )
3508 main.cleanup()
3509 main.exit()
3510
3511 def setTestGet( self, setName, values="" ):
3512 """
3513 CLI command to get the elements in a distributed set.
3514 Required arguments:
3515 setName - The name of the set to remove from.
3516 Optional arguments:
3517 values - The value(s) to check if in the set, space seperated.
3518 returns:
3519 main.ERROR on error OR
3520 A list of elements in the set if no optional arguments are
3521 supplied OR
3522 A tuple containing the list then:
3523 main.FALSE if the given values are not in the set OR
3524 main.TRUE if the given values are in the set OR
3525 """
3526 try:
3527 values = str( values ).strip()
3528 setName = str( setName ).strip()
3529 length = len( values.split() )
3530 containsCheck = None
3531 # Patterns to match
3532 setPattern = "\[(.*)\]"
3533 pattern = "Items in set " + setName + ":\n" + setPattern
3534 containsTrue = "Set " + setName + " contains the value " + values
3535 containsFalse = "Set " + setName + " did not contain the value " +\
3536 values
3537 containsAllTrue = "Set " + setName + " contains the the subset " +\
3538 setPattern
3539 containsAllFalse = "Set " + setName + " did not contain the the" +\
3540 " subset " + setPattern
3541
3542 cmdStr = "set-test-get "
3543 cmdStr += setName + " " + values
3544 output = self.sendline( cmdStr )
Jon Hallfeff3082015-05-19 10:23:26 -07003545 try:
3546 # TODO: Maybe make this less hardcoded
3547 # ConsistentMap Exceptions
3548 assert "org.onosproject.store.service" not in output
3549 # Node not leader
3550 assert "java.lang.IllegalStateException" not in output
3551 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07003552 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07003553 "command: " + str( output ) )
3554 retryTime = 30 # Conservative time, given by Madan
3555 main.log.info( "Waiting " + str( retryTime ) +
3556 "seconds before retrying." )
3557 time.sleep( retryTime ) # Due to change in mastership
3558 output = self.sendline( cmdStr )
Jon Hall390696c2015-05-05 17:13:41 -07003559 assert "Error executing command" not in output
3560 main.log.info( self.name + ": " + output )
3561
3562 if length == 0:
3563 match = re.search( pattern, output )
3564 else: # if given values
3565 if length == 1: # Contains output
3566 patternTrue = pattern + "\n" + containsTrue
3567 patternFalse = pattern + "\n" + containsFalse
3568 else: # ContainsAll output
3569 patternTrue = pattern + "\n" + containsAllTrue
3570 patternFalse = pattern + "\n" + containsAllFalse
3571 matchTrue = re.search( patternTrue, output )
3572 matchFalse = re.search( patternFalse, output )
3573 if matchTrue:
3574 containsCheck = main.TRUE
3575 match = matchTrue
3576 elif matchFalse:
3577 containsCheck = main.FALSE
3578 match = matchFalse
3579 else:
3580 main.log.error( self.name + " setTestGet did not match " +\
3581 "expected output" )
3582 main.log.debug( self.name + " expected: " + pattern )
3583 main.log.debug( self.name + " actual: " + repr( output ) )
3584 match = None
3585 if match:
3586 setMatch = match.group( 1 )
3587 if setMatch == '':
3588 setList = []
3589 else:
3590 setList = setMatch.split( ", " )
3591 if length > 0:
3592 return ( setList, containsCheck )
3593 else:
3594 return setList
3595 else: # no match
3596 main.log.error( self.name + ": setTestGet did not" +
3597 " match expected output" )
3598 main.log.debug( self.name + " expected: " + pattern )
3599 main.log.debug( self.name + " actual: " + repr( output ) )
3600 return main.ERROR
3601 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07003602 main.log.error( "Error in processing '" + cmdStr + "' command: " +
Jon Hall390696c2015-05-05 17:13:41 -07003603 str( output ) )
3604 return main.ERROR
3605 except TypeError:
3606 main.log.exception( self.name + ": Object not as expected" )
3607 return main.ERROR
3608 except pexpect.EOF:
3609 main.log.error( self.name + ": EOF exception found" )
3610 main.log.error( self.name + ": " + self.handle.before )
3611 main.cleanup()
3612 main.exit()
3613 except Exception:
3614 main.log.exception( self.name + ": Uncaught exception!" )
3615 main.cleanup()
3616 main.exit()
3617
3618 def setTestSize( self, setName ):
3619 """
3620 CLI command to get the elements in a distributed set.
3621 Required arguments:
3622 setName - The name of the set to remove from.
3623 returns:
Jon Hallfeff3082015-05-19 10:23:26 -07003624 The integer value of the size returned or
Jon Hall390696c2015-05-05 17:13:41 -07003625 None on error
3626 """
3627 try:
3628 # TODO: Should this check against the number of elements returned
3629 # and then return true/false based on that?
3630 setName = str( setName ).strip()
3631 # Patterns to match
3632 setPattern = "\[(.*)\]"
3633 pattern = "There are (\d+) items in set " + setName + ":\n" +\
3634 setPattern
3635 cmdStr = "set-test-get -s "
3636 cmdStr += setName
3637 output = self.sendline( cmdStr )
Jon Hallfeff3082015-05-19 10:23:26 -07003638 try:
3639 # TODO: Maybe make this less hardcoded
3640 # ConsistentMap Exceptions
3641 assert "org.onosproject.store.service" not in output
3642 # Node not leader
3643 assert "java.lang.IllegalStateException" not in output
3644 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07003645 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07003646 "command: " + str( output ) )
3647 retryTime = 30 # Conservative time, given by Madan
3648 main.log.info( "Waiting " + str( retryTime ) +
3649 "seconds before retrying." )
3650 time.sleep( retryTime ) # Due to change in mastership
3651 output = self.sendline( cmdStr )
Jon Hall390696c2015-05-05 17:13:41 -07003652 assert "Error executing command" not in output
3653 main.log.info( self.name + ": " + output )
3654 match = re.search( pattern, output )
3655 if match:
3656 setSize = int( match.group( 1 ) )
3657 setMatch = match.group( 2 )
3658 if len( setMatch.split() ) == setSize:
3659 main.log.info( "The size returned by " + self.name +
3660 " matches the number of elements in " +
3661 "the returned set" )
3662 else:
3663 main.log.error( "The size returned by " + self.name +
3664 " does not match the number of " +
3665 "elements in the returned set." )
3666 return setSize
3667 else: # no match
3668 main.log.error( self.name + ": setTestGet did not" +
3669 " match expected output" )
3670 main.log.debug( self.name + " expected: " + pattern )
3671 main.log.debug( self.name + " actual: " + repr( output ) )
3672 return None
3673 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07003674 main.log.error( "Error in processing '" + cmdStr + "' command: " +
Jon Hall390696c2015-05-05 17:13:41 -07003675 str( output ) )
acsmarsa4a4d1e2015-07-10 16:01:24 -07003676 return None
Jon Hall390696c2015-05-05 17:13:41 -07003677 except TypeError:
3678 main.log.exception( self.name + ": Object not as expected" )
3679 return None
3680 except pexpect.EOF:
3681 main.log.error( self.name + ": EOF exception found" )
3682 main.log.error( self.name + ": " + self.handle.before )
3683 main.cleanup()
3684 main.exit()
3685 except Exception:
3686 main.log.exception( self.name + ": Uncaught exception!" )
3687 main.cleanup()
3688 main.exit()
3689
Jon Hall80daded2015-05-27 16:07:00 -07003690 def counters( self, jsonFormat=True ):
Jon Hall390696c2015-05-05 17:13:41 -07003691 """
3692 Command to list the various counters in the system.
3693 returns:
Jon Hall80daded2015-05-27 16:07:00 -07003694 if jsonFormat, a string of the json object returned by the cli
3695 command
3696 if not jsonFormat, the normal string output of the cli command
Jon Hall390696c2015-05-05 17:13:41 -07003697 None on error
3698 """
Jon Hall390696c2015-05-05 17:13:41 -07003699 try:
3700 counters = {}
3701 cmdStr = "counters"
Jon Hall80daded2015-05-27 16:07:00 -07003702 if jsonFormat:
3703 cmdStr += " -j"
Jon Hall390696c2015-05-05 17:13:41 -07003704 output = self.sendline( cmdStr )
3705 assert "Error executing command" not in output
3706 main.log.info( self.name + ": " + output )
Jon Hall80daded2015-05-27 16:07:00 -07003707 return output
Jon Hall390696c2015-05-05 17:13:41 -07003708 except AssertionError:
3709 main.log.error( "Error in processing 'counters' command: " +
3710 str( output ) )
Jon Hall80daded2015-05-27 16:07:00 -07003711 return None
Jon Hall390696c2015-05-05 17:13:41 -07003712 except TypeError:
3713 main.log.exception( self.name + ": Object not as expected" )
Jon Hall80daded2015-05-27 16:07:00 -07003714 return None
Jon Hall390696c2015-05-05 17:13:41 -07003715 except pexpect.EOF:
3716 main.log.error( self.name + ": EOF exception found" )
3717 main.log.error( self.name + ": " + self.handle.before )
3718 main.cleanup()
3719 main.exit()
3720 except Exception:
3721 main.log.exception( self.name + ": Uncaught exception!" )
3722 main.cleanup()
3723 main.exit()
3724
Jon Halle1a3b752015-07-22 13:02:46 -07003725 def counterTestAddAndGet( self, counter, delta=1, inMemory=False ):
Jon Hall390696c2015-05-05 17:13:41 -07003726 """
Jon Halle1a3b752015-07-22 13:02:46 -07003727 CLI command to add a delta to then get a distributed counter.
Jon Hall390696c2015-05-05 17:13:41 -07003728 Required arguments:
3729 counter - The name of the counter to increment.
3730 Optional arguments:
Jon Halle1a3b752015-07-22 13:02:46 -07003731 delta - The long to add to the counter
Jon Hall390696c2015-05-05 17:13:41 -07003732 inMemory - use in memory map for the counter
3733 returns:
3734 integer value of the counter or
3735 None on Error
3736 """
3737 try:
3738 counter = str( counter )
Jon Halle1a3b752015-07-22 13:02:46 -07003739 delta = int( delta )
Jon Hall390696c2015-05-05 17:13:41 -07003740 cmdStr = "counter-test-increment "
3741 if inMemory:
3742 cmdStr += "-i "
3743 cmdStr += counter
Jon Halle1a3b752015-07-22 13:02:46 -07003744 if delta != 1:
3745 cmdStr += " " + str( delta )
Jon Hall390696c2015-05-05 17:13:41 -07003746 output = self.sendline( cmdStr )
Jon Hallfeff3082015-05-19 10:23:26 -07003747 try:
3748 # TODO: Maybe make this less hardcoded
3749 # ConsistentMap Exceptions
3750 assert "org.onosproject.store.service" not in output
3751 # Node not leader
3752 assert "java.lang.IllegalStateException" not in output
3753 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07003754 main.log.error( "Error in processing '" + cmdStr + "' " +
Jon Hallfeff3082015-05-19 10:23:26 -07003755 "command: " + str( output ) )
3756 retryTime = 30 # Conservative time, given by Madan
3757 main.log.info( "Waiting " + str( retryTime ) +
3758 "seconds before retrying." )
3759 time.sleep( retryTime ) # Due to change in mastership
3760 output = self.sendline( cmdStr )
Jon Hall390696c2015-05-05 17:13:41 -07003761 assert "Error executing command" not in output
3762 main.log.info( self.name + ": " + output )
Jon Halle1a3b752015-07-22 13:02:46 -07003763 pattern = counter + " was updated to (-?\d+)"
Jon Hall390696c2015-05-05 17:13:41 -07003764 match = re.search( pattern, output )
3765 if match:
3766 return int( match.group( 1 ) )
3767 else:
Jon Halle1a3b752015-07-22 13:02:46 -07003768 main.log.error( self.name + ": counterTestAddAndGet did not" +
Jon Hall390696c2015-05-05 17:13:41 -07003769 " match expected output." )
3770 main.log.debug( self.name + " expected: " + pattern )
3771 main.log.debug( self.name + " actual: " + repr( output ) )
3772 return None
3773 except AssertionError:
Jon Halle1a3b752015-07-22 13:02:46 -07003774 main.log.error( "Error in processing '" + cmdStr + "'" +
Jon Hall390696c2015-05-05 17:13:41 -07003775 " command: " + str( output ) )
3776 return None
3777 except TypeError:
3778 main.log.exception( self.name + ": Object not as expected" )
3779 return None
3780 except pexpect.EOF:
3781 main.log.error( self.name + ": EOF exception found" )
3782 main.log.error( self.name + ": " + self.handle.before )
3783 main.cleanup()
3784 main.exit()
3785 except Exception:
3786 main.log.exception( self.name + ": Uncaught exception!" )
3787 main.cleanup()
3788 main.exit()
3789
Jon Halle1a3b752015-07-22 13:02:46 -07003790 def counterTestGetAndAdd( self, counter, delta=1, inMemory=False ):
3791 """
3792 CLI command to get a distributed counter then add a delta to it.
3793 Required arguments:
3794 counter - The name of the counter to increment.
3795 Optional arguments:
3796 delta - The long to add to the counter
3797 inMemory - use in memory map for the counter
3798 returns:
3799 integer value of the counter or
3800 None on Error
3801 """
3802 try:
3803 counter = str( counter )
3804 delta = int( delta )
3805 cmdStr = "counter-test-increment -g "
3806 if inMemory:
3807 cmdStr += "-i "
3808 cmdStr += counter
3809 if delta != 1:
3810 cmdStr += " " + str( delta )
3811 output = self.sendline( cmdStr )
3812 try:
3813 # TODO: Maybe make this less hardcoded
3814 # ConsistentMap Exceptions
3815 assert "org.onosproject.store.service" not in output
3816 # Node not leader
3817 assert "java.lang.IllegalStateException" not in output
3818 except AssertionError:
3819 main.log.error( "Error in processing '" + cmdStr + "' " +
3820 "command: " + str( output ) )
3821 retryTime = 30 # Conservative time, given by Madan
3822 main.log.info( "Waiting " + str( retryTime ) +
3823 "seconds before retrying." )
3824 time.sleep( retryTime ) # Due to change in mastership
3825 output = self.sendline( cmdStr )
3826 assert "Error executing command" not in output
3827 main.log.info( self.name + ": " + output )
3828 pattern = counter + " was updated to (-?\d+)"
3829 match = re.search( pattern, output )
3830 if match:
3831 return int( match.group( 1 ) )
3832 else:
3833 main.log.error( self.name + ": counterTestGetAndAdd did not" +
3834 " match expected output." )
3835 main.log.debug( self.name + " expected: " + pattern )
3836 main.log.debug( self.name + " actual: " + repr( output ) )
3837 return None
3838 except AssertionError:
3839 main.log.error( "Error in processing '" + cmdStr + "'" +
3840 " command: " + str( output ) )
3841 return None
3842 except TypeError:
3843 main.log.exception( self.name + ": Object not as expected" )
3844 return None
3845 except pexpect.EOF:
3846 main.log.error( self.name + ": EOF exception found" )
3847 main.log.error( self.name + ": " + self.handle.before )
3848 main.cleanup()
3849 main.exit()
3850 except Exception:
3851 main.log.exception( self.name + ": Uncaught exception!" )
3852 main.cleanup()
3853 main.exit()
3854
kelvin-onlaba297c4d2015-06-01 13:53:55 -07003855 def summary( self, jsonFormat=True ):
3856 """
3857 Description: Execute summary command in onos
3858 Returns: json object ( summary -j ), returns main.FALSE if there is
3859 no output
3860
3861 """
3862 try:
3863 cmdStr = "summary"
3864 if jsonFormat:
3865 cmdStr += " -j"
3866 handle = self.sendline( cmdStr )
3867
3868 if re.search( "Error:", handle ):
3869 main.log.error( self.name + ": summary() response: " +
3870 str( handle ) )
3871 if not handle:
3872 main.log.error( self.name + ": There is no output in " +
3873 "summary command" )
3874 return main.FALSE
3875 return handle
3876 except TypeError:
3877 main.log.exception( self.name + ": Object not as expected" )
3878 return None
3879 except pexpect.EOF:
3880 main.log.error( self.name + ": EOF exception found" )
3881 main.log.error( self.name + ": " + self.handle.before )
3882 main.cleanup()
3883 main.exit()
3884 except Exception:
3885 main.log.exception( self.name + ": Uncaught exception!" )
3886 main.cleanup()
3887 main.exit()
Jon Hall2a5002c2015-08-21 16:49:11 -07003888
3889 def transactionalMapGet( self, keyName, inMemory=False ):
3890 """
3891 CLI command to get the value of a key in a consistent map using
3892 transactions. This a test function and can only get keys from the
3893 test map hard coded into the cli command
3894 Required arguments:
3895 keyName - The name of the key to get
3896 Optional arguments:
3897 inMemory - use in memory map for the counter
3898 returns:
3899 The string value of the key or
3900 None on Error
3901 """
3902 try:
3903 keyName = str( keyName )
3904 cmdStr = "transactional-map-test-get "
3905 if inMemory:
3906 cmdStr += "-i "
3907 cmdStr += keyName
3908 output = self.sendline( cmdStr )
3909 try:
3910 # TODO: Maybe make this less hardcoded
3911 # ConsistentMap Exceptions
3912 assert "org.onosproject.store.service" not in output
3913 # Node not leader
3914 assert "java.lang.IllegalStateException" not in output
3915 except AssertionError:
3916 main.log.error( "Error in processing '" + cmdStr + "' " +
3917 "command: " + str( output ) )
3918 return None
3919 pattern = "Key-value pair \(" + keyName + ", (?P<value>.+)\) found."
3920 if "Key " + keyName + " not found." in output:
3921 return None
3922 else:
3923 match = re.search( pattern, output )
3924 if match:
3925 return match.groupdict()[ 'value' ]
3926 else:
3927 main.log.error( self.name + ": transactionlMapGet did not" +
3928 " match expected output." )
3929 main.log.debug( self.name + " expected: " + pattern )
3930 main.log.debug( self.name + " actual: " + repr( output ) )
3931 return None
3932 except TypeError:
3933 main.log.exception( self.name + ": Object not as expected" )
3934 return None
3935 except pexpect.EOF:
3936 main.log.error( self.name + ": EOF exception found" )
3937 main.log.error( self.name + ": " + self.handle.before )
3938 main.cleanup()
3939 main.exit()
3940 except Exception:
3941 main.log.exception( self.name + ": Uncaught exception!" )
3942 main.cleanup()
3943 main.exit()
3944
3945 def transactionalMapPut( self, numKeys, value, inMemory=False ):
3946 """
3947 CLI command to put a value into 'numKeys' number of keys in a
3948 consistent map using transactions. This a test function and can only
3949 put into keys named 'Key#' of the test map hard coded into the cli command
3950 Required arguments:
3951 numKeys - Number of keys to add the value to
3952 value - The string value to put into the keys
3953 Optional arguments:
3954 inMemory - use in memory map for the counter
3955 returns:
3956 A dictionary whose keys are the name of the keys put into the map
3957 and the values of the keys are dictionaries whose key-values are
3958 'value': value put into map and optionaly
3959 'oldValue': Previous value in the key or
3960 None on Error
3961
3962 Example output
3963 { 'Key1': {'oldValue': 'oldTestValue', 'value': 'Testing'},
3964 'Key2': {'value': 'Testing'} }
3965 """
3966 try:
3967 numKeys = str( numKeys )
3968 value = str( value )
3969 cmdStr = "transactional-map-test-put "
3970 if inMemory:
3971 cmdStr += "-i "
3972 cmdStr += numKeys + " " + value
3973 output = self.sendline( cmdStr )
3974 try:
3975 # TODO: Maybe make this less hardcoded
3976 # ConsistentMap Exceptions
3977 assert "org.onosproject.store.service" not in output
3978 # Node not leader
3979 assert "java.lang.IllegalStateException" not in output
3980 except AssertionError:
3981 main.log.error( "Error in processing '" + cmdStr + "' " +
3982 "command: " + str( output ) )
3983 return None
3984 newPattern = 'Created Key (?P<key>(\w)+) with value (?P<value>(.)+)\.'
3985 updatedPattern = "Put (?P<value>(.)+) into key (?P<key>(\w)+)\. The old value was (?P<oldValue>(.)+)\."
3986 results = {}
3987 for line in output.splitlines():
3988 new = re.search( newPattern, line )
3989 updated = re.search( updatedPattern, line )
3990 if new:
3991 results[ new.groupdict()[ 'key' ] ] = { 'value': new.groupdict()[ 'value' ] }
3992 elif updated:
3993 results[ updated.groupdict()[ 'key' ] ] = { 'value': updated.groupdict()[ 'value' ],
3994 'oldValue': updated.groupdict()[ 'oldValue' ] }
3995 else:
3996 main.log.error( self.name + ": transactionlMapGet did not" +
3997 " match expected output." )
3998 main.log.debug( self.name + " expected: " + pattern )
3999 main.log.debug( self.name + " actual: " + repr( output ) )
4000 return results
4001 except TypeError:
4002 main.log.exception( self.name + ": Object not as expected" )
4003 return None
4004 except pexpect.EOF:
4005 main.log.error( self.name + ": EOF exception found" )
4006 main.log.error( self.name + ": " + self.handle.before )
4007 main.cleanup()
4008 main.exit()
4009 except Exception:
4010 main.log.exception( self.name + ": Uncaught exception!" )
4011 main.cleanup()
4012 main.exit()
acsmarsdaea66c2015-09-03 11:44:06 -07004013 def maps( self, jsonFormat=True ):
4014 """
4015 Description: Returns result of onos:maps
4016 Optional:
4017 * jsonFormat: enable json formatting of output
4018 """
4019 try:
4020 cmdStr = "maps"
4021 if jsonFormat:
4022 cmdStr += " -j"
4023 handle = self.sendline( cmdStr )
4024 return handle
4025 except TypeError:
4026 main.log.exception( self.name + ": Object not as expected" )
4027 return None
4028 except pexpect.EOF:
4029 main.log.error( self.name + ": EOF exception found" )
4030 main.log.error( self.name + ": " + self.handle.before )
4031 main.cleanup()
4032 main.exit()
4033 except Exception:
4034 main.log.exception( self.name + ": Uncaught exception!" )
4035 main.cleanup()
4036 main.exit()