blob: c261872c78a83fec68a61e4d95674844ebbbc934 [file] [log] [blame]
Jon Hall05b2b432014-10-08 19:53:25 -04001#!/usr/bin/env python
andrewonlabe8e56fd2014-10-09 17:12:44 -04002
kelvin8ec71442015-01-15 16:57:00 -08003"""
4This driver interacts with ONOS bench, the OSGi platform
5that configures the ONOS nodes. ( aka ONOS-next )
andrewonlabe8e56fd2014-10-09 17:12:44 -04006
kelvin8ec71442015-01-15 16:57:00 -08007Please follow the coding style demonstrated by existing
andrewonlabe8e56fd2014-10-09 17:12:44 -04008functions and document properly.
9
10If you are a contributor to the driver, please
11list your email here for future contact:
12
13jhall@onlab.us
14andrew@onlab.us
15
16OCT 9 2014
17
kelvin8ec71442015-01-15 16:57:00 -080018"""
Jon Hall05b2b432014-10-08 19:53:25 -040019import time
Jon Hall6801cda2015-07-15 14:13:45 -070020import types
Jon Hall05b2b432014-10-08 19:53:25 -040021import pexpect
kelvin-onlaba4074292015-07-09 15:19:49 -070022import os
andrewonlab7735d852014-10-09 13:02:47 -040023import os.path
pingping-lin6d23d9e2015-02-02 16:54:24 -080024from requests.models import Response
Jon Hall05b2b432014-10-08 19:53:25 -040025from drivers.common.clidriver import CLI
26
Jon Hall05b2b432014-10-08 19:53:25 -040027
kelvin8ec71442015-01-15 16:57:00 -080028class OnosDriver( CLI ):
Jon Hall05b2b432014-10-08 19:53:25 -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 """
Jon Hall05b2b432014-10-08 19:53:25 -040041 Creates ssh handle for ONOS "bench".
kelvin-onlaba4074292015-07-09 15:19:49 -070042 NOTE:
43 The ip_address would come from the topo file using the host tag, the
44 value can be an environment variable as well as a "localhost" to get
45 the ip address needed to ssh to the "bench"
kelvin8ec71442015-01-15 16:57:00 -080046 """
Jon Hall05b2b432014-10-08 19:53:25 -040047 try:
48 for key in connectargs:
kelvin8ec71442015-01-15 16:57:00 -080049 vars( self )[ key ] = connectargs[ key ]
andrew@onlab.us3b087132015-03-11 15:00:08 -070050 self.home = "~/onos"
Jon Hall05b2b432014-10-08 19:53:25 -040051 for key in self.options:
52 if key == "home":
kelvin8ec71442015-01-15 16:57:00 -080053 self.home = self.options[ 'home' ]
Jon Hall05b2b432014-10-08 19:53:25 -040054 break
Jon Hall274b6642015-02-17 11:57:17 -080055 if self.home is None or self.home == "":
Jon Halle94919c2015-03-23 11:42:57 -070056 self.home = "~/onos"
Jon Hall21270ac2015-02-16 17:59:55 -080057
kelvin8ec71442015-01-15 16:57:00 -080058 self.name = self.options[ 'name' ]
kelvin-onlaba4074292015-07-09 15:19:49 -070059
kelvin-onlabc2b79102015-07-14 11:41:20 -070060 # The 'nodes' tag is optional and it is not required in .topo file
kelvin-onlaba4074292015-07-09 15:19:49 -070061 for key in self.options:
62 if key == "nodes":
kelvin-onlabc2b79102015-07-14 11:41:20 -070063 # Maximum number of ONOS nodes to run, if there is any
kelvin-onlaba4074292015-07-09 15:19:49 -070064 self.maxNodes = int( self.options[ 'nodes' ] )
65 break
66 self.maxNodes = None
67
kelvin-onlabc2b79102015-07-14 11:41:20 -070068 if self.maxNodes == None or self.maxNodes == "":
69 self.maxNodes = 100
kelvin-onlaba4074292015-07-09 15:19:49 -070070
kelvin-onlabc2b79102015-07-14 11:41:20 -070071
72 # Grabs all OC environment variables based on max number of nodes
kelvin-onlaba4074292015-07-09 15:19:49 -070073 self.onosIps = {} # Dictionary of all possible ONOS ip
74
75 try:
76 if self.maxNodes:
kelvin-onlaba4074292015-07-09 15:19:49 -070077 for i in range( self.maxNodes ):
78 envString = "OC" + str( i + 1 )
kelvin-onlabc2b79102015-07-14 11:41:20 -070079 # If there is no more OC# then break the loop
80 if os.getenv( envString ):
81 self.onosIps[ envString ] = os.getenv( envString )
82 else:
83 self.maxNodes = len( self.onosIps )
84 main.log.info( self.name +
85 ": Created cluster data with " +
86 str( self.maxNodes ) +
87 " maximum number" +
88 " of nodes" )
89 break
kelvin-onlaba4074292015-07-09 15:19:49 -070090
91 if not self.onosIps:
92 main.log.info( "Could not read any environment variable"
93 + " please load a cell file with all" +
94 " onos IP" )
Jon Hall5cf14d52015-07-16 12:15:19 -070095 self.maxNodes = None
kelvin-onlaba4074292015-07-09 15:19:49 -070096 else:
97 main.log.info( self.name + ": Found " +
98 str( self.onosIps.values() ) +
99 " ONOS IPs" )
kelvin-onlaba4074292015-07-09 15:19:49 -0700100 except KeyError:
101 main.log.info( "Invalid environment variable" )
102 except Exception as inst:
103 main.log.error( "Uncaught exception: " + str( inst ) )
104
105 try:
106 if os.getenv( str( self.ip_address ) ) != None:
107 self.ip_address = os.getenv( str( self.ip_address ) )
108 else:
109 main.log.info( self.name +
110 ": Trying to connect to " +
111 self.ip_address )
kelvin-onlaba4074292015-07-09 15:19:49 -0700112 except KeyError:
113 main.log.info( "Invalid host name," +
114 " connecting to local host instead" )
115 self.ip_address = 'localhost'
116 except Exception as inst:
117 main.log.error( "Uncaught exception: " + str( inst ) )
118
kelvin8ec71442015-01-15 16:57:00 -0800119 self.handle = super( OnosDriver, self ).connect(
120 user_name=self.user_name,
kelvin-onlab08679eb2015-01-21 16:11:48 -0800121 ip_address=self.ip_address,
kelvin-onlabd3b64892015-01-20 13:26:24 -0800122 port=self.port,
123 pwd=self.pwd,
124 home=self.home )
Jon Hall05b2b432014-10-08 19:53:25 -0400125
Jon Hall05b2b432014-10-08 19:53:25 -0400126 if self.handle:
Jon Hall0fc0d452015-07-14 09:49:58 -0700127 self.handle.sendline( "cd " + self.home )
128 self.handle.expect( "\$" )
Jon Hall05b2b432014-10-08 19:53:25 -0400129 return self.handle
kelvin8ec71442015-01-15 16:57:00 -0800130 else:
Jon Hall0fc0d452015-07-14 09:49:58 -0700131 main.log.info( "Failed to create ONOS handle" )
Jon Hall05b2b432014-10-08 19:53:25 -0400132 return main.FALSE
133 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800134 main.log.error( self.name + ": EOF exception found" )
135 main.log.error( self.name + ": " + self.handle.before )
Jon Hall05b2b432014-10-08 19:53:25 -0400136 main.cleanup()
137 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800138 except Exception:
139 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall05b2b432014-10-08 19:53:25 -0400140 main.cleanup()
141 main.exit()
142
kelvin8ec71442015-01-15 16:57:00 -0800143 def disconnect( self ):
144 """
Jon Hall05b2b432014-10-08 19:53:25 -0400145 Called when Test is complete to disconnect the ONOS handle.
kelvin8ec71442015-01-15 16:57:00 -0800146 """
Jon Halld61331b2015-02-17 16:35:47 -0800147 response = main.TRUE
Jon Hall05b2b432014-10-08 19:53:25 -0400148 try:
Jon Hall61282e32015-03-19 11:34:11 -0700149 if self.handle:
150 self.handle.sendline( "" )
151 self.handle.expect( "\$" )
152 self.handle.sendline( "exit" )
153 self.handle.expect( "closed" )
Jon Hall05b2b432014-10-08 19:53:25 -0400154 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800155 main.log.error( self.name + ": EOF exception found" )
156 main.log.error( self.name + ": " + self.handle.before )
Jon Hall61282e32015-03-19 11:34:11 -0700157 except ValueError:
Jon Hall1a77a1e2015-04-06 10:41:13 -0700158 main.log.exception( "Exception in disconnect of " + self.name )
Jon Hall61282e32015-03-19 11:34:11 -0700159 response = main.TRUE
Jon Hallfebb1c72015-03-05 13:30:09 -0800160 except Exception:
161 main.log.exception( self.name + ": Connection failed to the host" )
Jon Hall05b2b432014-10-08 19:53:25 -0400162 response = main.FALSE
163 return response
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400164
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400165 def getEpochMs( self ):
166 """
167 Returns milliseconds since epoch
Jon Hall4ba53f02015-07-29 13:07:41 -0700168
169 When checking multiple nodes in a for loop,
170 around a hundred milliseconds of difference (ascending) is
171 generally acceptable due to calltime of the function.
172 Few seconds, however, is not and it means clocks
173 are off sync.
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400174 """
175 try:
176 self.handle.sendline( 'date +%s.%N' )
177 self.handle.expect( 'date \+\%s\.\%N' )
178 self.handle.expect( '\$' )
179 epochMs = self.handle.before
180 return epochMs
181 except Exception:
182 main.log.exception( 'Uncaught exception getting epoch time' )
183 main.cleanup()
184 main.exit()
185
pingping-lin57a56ce2015-05-20 16:43:48 -0700186 def onosPackage( self, opTimeout=30 ):
kelvin8ec71442015-01-15 16:57:00 -0800187 """
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400188 Produce a self-contained tar.gz file that can be deployed
kelvin8ec71442015-01-15 16:57:00 -0800189 and executed on any platform with Java 7 JRE.
190 """
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400191 try:
kelvin8ec71442015-01-15 16:57:00 -0800192 self.handle.sendline( "onos-package" )
193 self.handle.expect( "onos-package" )
pingping-lin57a56ce2015-05-20 16:43:48 -0700194 self.handle.expect( "tar.gz", opTimeout )
kelvin8ec71442015-01-15 16:57:00 -0800195 handle = str( self.handle.before )
196 main.log.info( "onos-package command returned: " +
197 handle )
198 # As long as the sendline does not time out,
199 # return true. However, be careful to interpret
200 # the results of the onos-package command return
andrewonlab0748d2a2014-10-09 13:24:17 -0400201 return main.TRUE
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400202
andrewonlab7735d852014-10-09 13:02:47 -0400203 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800204 main.log.error( self.name + ": EOF exception found" )
205 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -0800206 except Exception:
207 main.log.exception( "Failed to package ONOS" )
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400208 main.cleanup()
209 main.exit()
210
kelvin-onlabd3b64892015-01-20 13:26:24 -0800211 def onosBuild( self ):
kelvin8ec71442015-01-15 16:57:00 -0800212 """
andrewonlab8790abb2014-11-06 13:51:54 -0500213 Use the pre defined script to build onos via mvn
kelvin8ec71442015-01-15 16:57:00 -0800214 """
andrewonlab8790abb2014-11-06 13:51:54 -0500215 try:
kelvin8ec71442015-01-15 16:57:00 -0800216 self.handle.sendline( "onos-build" )
217 self.handle.expect( "onos-build" )
218 i = self.handle.expect( [
kelvin-onlabd3b64892015-01-20 13:26:24 -0800219 "BUILD SUCCESS",
220 "ERROR",
221 "BUILD FAILED" ],
222 timeout=120 )
kelvin8ec71442015-01-15 16:57:00 -0800223 handle = str( self.handle.before )
andrewonlab8790abb2014-11-06 13:51:54 -0500224
kelvin8ec71442015-01-15 16:57:00 -0800225 main.log.info( "onos-build command returned: " +
226 handle )
andrewonlab8790abb2014-11-06 13:51:54 -0500227
228 if i == 0:
229 return main.TRUE
230 else:
231 return handle
232
233 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800234 main.log.error( self.name + ": EOF exception found" )
235 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -0800236 except Exception:
237 main.log.exception( "Failed to build ONOS" )
andrewonlab8790abb2014-11-06 13:51:54 -0500238 main.cleanup()
239 main.exit()
240
shahshreya9f531fe2015-06-10 12:03:51 -0700241 def cleanInstall( self, skipTest=False, mciTimeout=600 ):
kelvin8ec71442015-01-15 16:57:00 -0800242 """
243 Runs mvn clean install in the root of the ONOS directory.
244 This will clean all ONOS artifacts then compile each module
shahshreya9f531fe2015-06-10 12:03:51 -0700245 Optional:
246 skipTest - Does "-DskipTests -Dcheckstyle.skip -U -T 1C" which
247 skip the test. This will make the building faster.
248 Disregarding the credibility of the build
kelvin8ec71442015-01-15 16:57:00 -0800249 Returns: main.TRUE on success
Jon Hallde9d9aa2014-10-08 20:36:02 -0400250 On Failure, exits the test
kelvin8ec71442015-01-15 16:57:00 -0800251 """
Jon Hallde9d9aa2014-10-08 20:36:02 -0400252 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800253 main.log.info( "Running 'mvn clean install' on " +
254 str( self.name ) +
kelvin8ec71442015-01-15 16:57:00 -0800255 ". This may take some time." )
256 self.handle.sendline( "cd " + self.home )
257 self.handle.expect( "\$" )
Jon Hallea7818b2014-10-09 14:30:59 -0400258
kelvin8ec71442015-01-15 16:57:00 -0800259 self.handle.sendline( "" )
260 self.handle.expect( "\$" )
shahshreya9f531fe2015-06-10 12:03:51 -0700261
262 if not skipTest:
263 self.handle.sendline( "mvn clean install" )
264 self.handle.expect( "mvn clean install" )
265 else:
266 self.handle.sendline( "mvn clean install -DskipTests" +
267 " -Dcheckstyle.skip -U -T 1C" )
268 self.handle.expect( "mvn clean install -DskipTests" +
269 " -Dcheckstyle.skip -U -T 1C" )
kelvin8ec71442015-01-15 16:57:00 -0800270 while True:
271 i = self.handle.expect( [
Jon Hall274b6642015-02-17 11:57:17 -0800272 'There\sis\sinsufficient\smemory\sfor\sthe\sJava\s' +
Jon Hallefbd9792015-03-05 16:11:36 -0800273 'Runtime\sEnvironment\sto\scontinue',
Jon Hallde9d9aa2014-10-08 20:36:02 -0400274 'BUILD\sFAILURE',
275 'BUILD\sSUCCESS',
Jon Halle94919c2015-03-23 11:42:57 -0700276 'onos\$', #TODO: fix this to be more generic?
Jon Hallde9d9aa2014-10-08 20:36:02 -0400277 'ONOS\$',
pingping-lin57a56ce2015-05-20 16:43:48 -0700278 pexpect.TIMEOUT ], mciTimeout )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400279 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -0800280 main.log.error( self.name + ":There is insufficient memory \
281 for the Java Runtime Environment to continue." )
282 # return main.FALSE
Jon Hallde9d9aa2014-10-08 20:36:02 -0400283 main.cleanup()
284 main.exit()
285 if i == 1:
kelvin8ec71442015-01-15 16:57:00 -0800286 main.log.error( self.name + ": Build failure!" )
287 # return main.FALSE
Jon Hallde9d9aa2014-10-08 20:36:02 -0400288 main.cleanup()
289 main.exit()
290 elif i == 2:
kelvin8ec71442015-01-15 16:57:00 -0800291 main.log.info( self.name + ": Build success!" )
Jon Halle94919c2015-03-23 11:42:57 -0700292 elif i == 3 or i == 4:
kelvin8ec71442015-01-15 16:57:00 -0800293 main.log.info( self.name + ": Build complete" )
294 # Print the build time
Jon Hallf8ef52c2014-10-09 19:37:33 -0400295 for line in self.handle.before.splitlines():
296 if "Total time:" in line:
kelvin8ec71442015-01-15 16:57:00 -0800297 main.log.info( line )
298 self.handle.sendline( "" )
299 self.handle.expect( "\$", timeout=60 )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400300 return main.TRUE
Jon Halle94919c2015-03-23 11:42:57 -0700301 elif i == 5:
kelvin8ec71442015-01-15 16:57:00 -0800302 main.log.error(
303 self.name +
304 ": mvn clean install TIMEOUT!" )
305 # return main.FALSE
Jon Hallde9d9aa2014-10-08 20:36:02 -0400306 main.cleanup()
307 main.exit()
308 else:
Jon Hall274b6642015-02-17 11:57:17 -0800309 main.log.error( self.name + ": unexpected response from " +
Jon Hallefbd9792015-03-05 16:11:36 -0800310 "mvn clean install" )
kelvin8ec71442015-01-15 16:57:00 -0800311 # return main.FALSE
Jon Hallde9d9aa2014-10-08 20:36:02 -0400312 main.cleanup()
313 main.exit()
314 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800315 main.log.error( self.name + ": EOF exception found" )
316 main.log.error( self.name + ": " + self.handle.before )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400317 main.cleanup()
318 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800319 except Exception:
320 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400321 main.cleanup()
322 main.exit()
Jon Hallacabffd2014-10-09 12:36:53 -0400323
Jon Hall61282e32015-03-19 11:34:11 -0700324 def gitPull( self, comp1="", fastForward=True ):
kelvin8ec71442015-01-15 16:57:00 -0800325 """
Jon Hallacabffd2014-10-09 12:36:53 -0400326 Assumes that "git pull" works without login
Jon Hall47a93fb2015-01-06 16:46:06 -0800327
Jon Hall61282e32015-03-19 11:34:11 -0700328 If the fastForward boolean is set to true, only git pulls that can
329 be fast forwarded will be performed. IE if you have not local commits
330 in your branch.
331
Jon Hallacabffd2014-10-09 12:36:53 -0400332 This function will perform a git pull on the ONOS instance.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800333 If used as gitPull( "NODE" ) it will do git pull + NODE. This is
Jon Hallacabffd2014-10-09 12:36:53 -0400334 for the purpose of pulling from other nodes if necessary.
335
Jon Hall47a93fb2015-01-06 16:46:06 -0800336 Otherwise, this function will perform a git pull in the
Jon Hallacabffd2014-10-09 12:36:53 -0400337 ONOS repository. If it has any problems, it will return main.ERROR
kelvin-onlabd3b64892015-01-20 13:26:24 -0800338 If it successfully does a gitPull, it will return a 1 ( main.TRUE )
Shreya Shahee15f6c2014-10-28 18:12:30 -0400339 If it has no updates, it will return 3.
Jon Hallacabffd2014-10-09 12:36:53 -0400340
kelvin8ec71442015-01-15 16:57:00 -0800341 """
Jon Hallacabffd2014-10-09 12:36:53 -0400342 try:
kelvin8ec71442015-01-15 16:57:00 -0800343 # main.log.info( self.name + ": Stopping ONOS" )
344 # self.stop()
345 self.handle.sendline( "cd " + self.home )
kelvin-onlaba1484582015-02-02 15:46:20 -0800346 self.handle.expect( self.home + "\$" )
Jon Hall61282e32015-03-19 11:34:11 -0700347 cmd = "git pull"
348 if comp1 != "":
349 cmd += ' ' + comp1
350 if fastForward:
351 cmd += ' ' + " --ff-only"
352 self.handle.sendline( cmd )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800353 i = self.handle.expect(
354 [
355 'fatal',
356 'Username\sfor\s(.*):\s',
357 '\sfile(s*) changed,\s',
358 'Already up-to-date',
359 'Aborting',
360 'You\sare\snot\scurrently\son\sa\sbranch',
Jon Hall274b6642015-02-17 11:57:17 -0800361 'You asked me to pull without telling me which branch you',
362 'Pull is not possible because you have unmerged files',
Jon Hall61282e32015-03-19 11:34:11 -0700363 'Please enter a commit message to explain why this merge',
364 'Found a swap file by the name',
365 'Please, commit your changes before you can merge.',
kelvin-onlabd3b64892015-01-20 13:26:24 -0800366 pexpect.TIMEOUT ],
367 timeout=300 )
kelvin8ec71442015-01-15 16:57:00 -0800368 # debug
kelvin-onlabd3b64892015-01-20 13:26:24 -0800369 # main.log.report( self.name +": DEBUG: \n"+
370 # "git pull response: " +
371 # str( self.handle.before ) + str( self.handle.after ) )
kelvin8ec71442015-01-15 16:57:00 -0800372 if i == 0:
Jon Hall61282e32015-03-19 11:34:11 -0700373 main.log.error( self.name + ": Git pull had some issue" )
374 output = self.handle.after
375 self.handle.expect( '\$' )
376 output += self.handle.before
377 main.log.warn( output )
Jon Hallacabffd2014-10-09 12:36:53 -0400378 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800379 elif i == 1:
380 main.log.error(
381 self.name +
382 ": Git Pull Asking for username. " )
Jon Hallacabffd2014-10-09 12:36:53 -0400383 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800384 elif i == 2:
385 main.log.info(
386 self.name +
387 ": Git Pull - pulling repository now" )
kelvin-onlaba1484582015-02-02 15:46:20 -0800388 self.handle.expect( self.home + "\$", 120 )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800389 # So that only when git pull is done, we do mvn clean compile
390 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800391 elif i == 3:
392 main.log.info( self.name + ": Git Pull - Already up to date" )
Jon Hall47a93fb2015-01-06 16:46:06 -0800393 return i
kelvin8ec71442015-01-15 16:57:00 -0800394 elif i == 4:
395 main.log.info(
396 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800397 ": Git Pull - Aborting..." +
398 "Are there conflicting git files?" )
Jon Hallacabffd2014-10-09 12:36:53 -0400399 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800400 elif i == 5:
401 main.log.info(
402 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800403 ": Git Pull - You are not currently " +
404 "on a branch so git pull failed!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400405 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800406 elif i == 6:
407 main.log.info(
408 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800409 ": Git Pull - You have not configured an upstream " +
410 "branch to pull from. Git pull failed!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400411 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800412 elif i == 7:
413 main.log.info(
414 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800415 ": Git Pull - Pull is not possible because " +
416 "you have unmerged files." )
Jon Hallacabffd2014-10-09 12:36:53 -0400417 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800418 elif i == 8:
Jon Hall61282e32015-03-19 11:34:11 -0700419 # NOTE: abandoning test since we can't reliably handle this
420 # there could be different default text editors and we
421 # also don't know if we actually want to make the commit
422 main.log.error( "Git pull resulted in a merge commit message" +
423 ". Exiting test!" )
424 main.cleanup()
425 main.exit()
426 elif i == 9: # Merge commit message but swap file exists
427 main.log.error( "Git pull resulted in a merge commit message" +
428 " but a swap file exists." )
429 try:
430 self.handle.send( 'A' ) # Abort
431 self.handle.expect( "\$" )
432 return main.ERROR
433 except Exception:
434 main.log.exception( "Couldn't exit editor prompt!")
435 main.cleanup()
436 main.exit()
437 elif i == 10: # In the middle of a merge commit
438 main.log.error( "Git branch is in the middle of a merge. " )
439 main.log.warn( self.handle.before + self.handle.after )
440 return main.ERROR
441 elif i == 11:
kelvin8ec71442015-01-15 16:57:00 -0800442 main.log.error( self.name + ": Git Pull - TIMEOUT" )
443 main.log.error(
444 self.name + " Response was: " + str(
445 self.handle.before ) )
Jon Hallacabffd2014-10-09 12:36:53 -0400446 return main.ERROR
447 else:
kelvin8ec71442015-01-15 16:57:00 -0800448 main.log.error(
449 self.name +
450 ": Git Pull - Unexpected response, check for pull errors" )
Jon Hallacabffd2014-10-09 12:36:53 -0400451 return main.ERROR
452 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800453 main.log.error( self.name + ": EOF exception found" )
454 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400455 main.cleanup()
456 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800457 except Exception:
458 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400459 main.cleanup()
460 main.exit()
461
kelvin-onlabd3b64892015-01-20 13:26:24 -0800462 def gitCheckout( self, branch="master" ):
kelvin8ec71442015-01-15 16:57:00 -0800463 """
Jon Hallacabffd2014-10-09 12:36:53 -0400464 Assumes that "git pull" works without login
kelvin8ec71442015-01-15 16:57:00 -0800465
Jon Hallacabffd2014-10-09 12:36:53 -0400466 This function will perform a git git checkout on the ONOS instance.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800467 If used as gitCheckout( "branch" ) it will do git checkout
468 of the "branch".
Jon Hallacabffd2014-10-09 12:36:53 -0400469
470 Otherwise, this function will perform a git checkout of the master
kelvin8ec71442015-01-15 16:57:00 -0800471 branch of the ONOS repository. If it has any problems, it will return
472 main.ERROR.
473 If the branch was already the specified branch, or the git checkout was
Jon Hallacabffd2014-10-09 12:36:53 -0400474 successful then the function will return main.TRUE.
475
kelvin8ec71442015-01-15 16:57:00 -0800476 """
Jon Hallacabffd2014-10-09 12:36:53 -0400477 try:
kelvin8ec71442015-01-15 16:57:00 -0800478 self.handle.sendline( "cd " + self.home )
kelvin-onlaba1484582015-02-02 15:46:20 -0800479 self.handle.expect( self.home + "\$" )
Jon Hall274b6642015-02-17 11:57:17 -0800480 main.log.info( self.name +
481 ": Checking out git branch/ref: " + branch + "..." )
kelvin8ec71442015-01-15 16:57:00 -0800482 cmd = "git checkout " + branch
483 self.handle.sendline( cmd )
484 self.handle.expect( cmd )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800485 i = self.handle.expect(
Jon Hall274b6642015-02-17 11:57:17 -0800486 [ 'fatal',
Jon Hall61282e32015-03-19 11:34:11 -0700487 'Username for (.*): ',
488 'Already on \'',
Jon Hall7a8354f2015-06-10 15:37:00 -0700489 'Switched to (a new )?branch \'' + str( branch ),
Jon Hall274b6642015-02-17 11:57:17 -0800490 pexpect.TIMEOUT,
491 'error: Your local changes to the following files' +
Jon Hallefbd9792015-03-05 16:11:36 -0800492 'would be overwritten by checkout:',
Jon Hall274b6642015-02-17 11:57:17 -0800493 'error: you need to resolve your current index first',
494 "You are in 'detached HEAD' state.",
495 "HEAD is now at " ],
kelvin-onlabd3b64892015-01-20 13:26:24 -0800496 timeout=60 )
kelvin8ec71442015-01-15 16:57:00 -0800497 if i == 0:
498 main.log.error(
499 self.name +
500 ": Git checkout had some issue..." )
501 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400502 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800503 elif i == 1:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800504 main.log.error(
505 self.name +
506 ": Git checkout asking for username." +
507 " Please configure your local git repository to be able " +
508 "to access your remote repository passwordlessly" )
Jon Hall274b6642015-02-17 11:57:17 -0800509 # TODO add support for authenticating
Jon Hallacabffd2014-10-09 12:36:53 -0400510 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800511 elif i == 2:
512 main.log.info(
513 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800514 ": Git Checkout %s : Already on this branch" % branch )
kelvin-onlaba1484582015-02-02 15:46:20 -0800515 self.handle.expect( self.home + "\$" )
kelvin8ec71442015-01-15 16:57:00 -0800516 # main.log.info( "DEBUG: after checkout cmd = "+
517 # self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400518 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800519 elif i == 3:
520 main.log.info(
521 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800522 ": Git checkout %s - Switched to this branch" % branch )
kelvin-onlaba1484582015-02-02 15:46:20 -0800523 self.handle.expect( self.home + "\$" )
kelvin8ec71442015-01-15 16:57:00 -0800524 # main.log.info( "DEBUG: after checkout cmd = "+
525 # self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400526 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800527 elif i == 4:
528 main.log.error( self.name + ": Git Checkout- TIMEOUT" )
529 main.log.error(
Jon Hall274b6642015-02-17 11:57:17 -0800530 self.name + " Response was: " + str( self.handle.before ) )
Jon Hallacabffd2014-10-09 12:36:53 -0400531 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800532 elif i == 5:
533 self.handle.expect( "Aborting" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800534 main.log.error(
535 self.name +
536 ": Git checkout error: \n" +
Jon Hall274b6642015-02-17 11:57:17 -0800537 "Your local changes to the following files would" +
538 " be overwritten by checkout:" +
539 str( self.handle.before ) )
kelvin-onlaba1484582015-02-02 15:46:20 -0800540 self.handle.expect( self.home + "\$" )
Jon Hall81e29af2014-11-04 20:41:23 -0500541 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800542 elif i == 6:
Jon Hall274b6642015-02-17 11:57:17 -0800543 main.log.error(
544 self.name +
545 ": Git checkout error: \n" +
546 "You need to resolve your current index first:" +
547 str( self.handle.before ) )
kelvin-onlaba1484582015-02-02 15:46:20 -0800548 self.handle.expect( self.home + "\$" )
Jon Hall81e29af2014-11-04 20:41:23 -0500549 return main.ERROR
Jon Hall274b6642015-02-17 11:57:17 -0800550 elif i == 7:
551 main.log.info(
552 self.name +
553 ": Git checkout " + str( branch ) +
554 " - You are in 'detached HEAD' state. HEAD is now at " +
555 str( branch ) )
556 self.handle.expect( self.home + "\$" )
557 return main.TRUE
558 elif i == 8: # Already in detached HEAD on the specified commit
559 main.log.info(
560 self.name +
561 ": Git Checkout %s : Already on commit" % branch )
562 self.handle.expect( self.home + "\$" )
563 return main.TRUE
Jon Hallacabffd2014-10-09 12:36:53 -0400564 else:
kelvin8ec71442015-01-15 16:57:00 -0800565 main.log.error(
566 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800567 ": Git Checkout - Unexpected response, " +
568 "check for pull errors" )
kelvin8ec71442015-01-15 16:57:00 -0800569 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400570 return main.ERROR
571
572 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800573 main.log.error( self.name + ": EOF exception found" )
574 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400575 main.cleanup()
576 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800577 except Exception:
578 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400579 main.cleanup()
580 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -0400581
pingping-lin6d23d9e2015-02-02 16:54:24 -0800582 def getBranchName( self ):
pingping-linf30cf272015-05-29 15:54:07 -0700583 main.log.info( "self.home = " )
584 main.log.info( self.home )
pingping-lin6d23d9e2015-02-02 16:54:24 -0800585 self.handle.sendline( "cd " + self.home )
pingping-lin9bf3d8f2015-05-29 16:05:28 -0700586 self.handle.expect( self.home + "\$" )
pingping-lin6d23d9e2015-02-02 16:54:24 -0800587 self.handle.sendline( "git name-rev --name-only HEAD" )
588 self.handle.expect( "git name-rev --name-only HEAD" )
589 self.handle.expect( "\$" )
590
591 lines = self.handle.before.splitlines()
592 if lines[1] == "master":
593 return "master"
594 elif lines[1] == "onos-1.0":
595 return "onos-1.0"
596 else:
597 main.log.info( lines[1] )
598 return "unexpected ONOS branch for SDN-IP test"
599
kelvin-onlabd3b64892015-01-20 13:26:24 -0800600 def getVersion( self, report=False ):
kelvin8ec71442015-01-15 16:57:00 -0800601 """
Jon Hall274b6642015-02-17 11:57:17 -0800602 Writes the COMMIT number to the report to be parsed
Jon Hallefbd9792015-03-05 16:11:36 -0800603 by Jenkins data collector.
kelvin8ec71442015-01-15 16:57:00 -0800604 """
Jon Hall45ec0922014-10-10 19:33:49 -0400605 try:
kelvin8ec71442015-01-15 16:57:00 -0800606 self.handle.sendline( "" )
607 self.handle.expect( "\$" )
608 self.handle.sendline(
609 "cd " +
610 self.home +
Jon Hall274b6642015-02-17 11:57:17 -0800611 "; git log -1 --pretty=fuller --decorate=short | grep -A 6 " +
612 " \"commit\" --color=never" )
kelvin8ec71442015-01-15 16:57:00 -0800613 # NOTE: for some reason there are backspaces inserted in this
614 # phrase when run from Jenkins on some tests
615 self.handle.expect( "never" )
616 self.handle.expect( "\$" )
617 response = ( self.name + ": \n" + str(
618 self.handle.before + self.handle.after ) )
619 self.handle.sendline( "cd " + self.home )
620 self.handle.expect( "\$" )
621 lines = response.splitlines()
Jon Hall45ec0922014-10-10 19:33:49 -0400622 for line in lines:
Jon Hallfd191202014-11-07 18:36:09 -0500623 print line
624 if report:
pingping-lin763ee042015-05-20 17:45:30 -0700625 main.log.wiki( "<blockquote>" )
kelvin8ec71442015-01-15 16:57:00 -0800626 for line in lines[ 2:-1 ]:
627 # Bracket replacement is for Wiki-compliant
628 # formatting. '<' or '>' are interpreted
629 # as xml specific tags that cause errors
630 line = line.replace( "<", "[" )
631 line = line.replace( ">", "]" )
pingping-lin763ee042015-05-20 17:45:30 -0700632 #main.log.wiki( "\t" + line )
633 main.log.wiki( line + "<br /> " )
634 main.log.summary( line )
635 main.log.wiki( "</blockquote>" )
636 main.log.summary("\n")
kelvin8ec71442015-01-15 16:57:00 -0800637 return lines[ 2 ]
Jon Hall45ec0922014-10-10 19:33:49 -0400638 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800639 main.log.error( self.name + ": EOF exception found" )
640 main.log.error( self.name + ": " + self.handle.before )
Jon Hall45ec0922014-10-10 19:33:49 -0400641 main.cleanup()
642 main.exit()
Jon Hall368769f2014-11-19 15:43:35 -0800643 except pexpect.TIMEOUT:
kelvin8ec71442015-01-15 16:57:00 -0800644 main.log.error( self.name + ": TIMEOUT exception found" )
645 main.log.error( self.name + ": " + self.handle.before )
Jon Hall368769f2014-11-19 15:43:35 -0800646 main.cleanup()
647 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800648 except Exception:
649 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall45ec0922014-10-10 19:33:49 -0400650 main.cleanup()
651 main.exit()
652
kelvin-onlabd3b64892015-01-20 13:26:24 -0800653 def createCellFile( self, benchIp, fileName, mnIpAddrs,
kelvin-onlaba4074292015-07-09 15:19:49 -0700654 appString, onosIpAddrs ):
kelvin8ec71442015-01-15 16:57:00 -0800655 """
andrewonlab94282092014-10-10 13:00:11 -0400656 Creates a cell file based on arguments
657 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800658 * Bench IP address ( benchIp )
andrewonlab94282092014-10-10 13:00:11 -0400659 - Needed to copy the cell file over
kelvin-onlabd3b64892015-01-20 13:26:24 -0800660 * File name of the cell file ( fileName )
661 * Mininet IP address ( mnIpAddrs )
kelvin8ec71442015-01-15 16:57:00 -0800662 - Note that only 1 ip address is
andrewonlab94282092014-10-10 13:00:11 -0400663 supported currently
kelvin-onlabd3b64892015-01-20 13:26:24 -0800664 * ONOS IP addresses ( onosIpAddrs )
andrewonlab94282092014-10-10 13:00:11 -0400665 - Must be passed in as last arguments
kelvin8ec71442015-01-15 16:57:00 -0800666
andrewonlab94282092014-10-10 13:00:11 -0400667 NOTE: Assumes cells are located at:
668 ~/<self.home>/tools/test/cells/
kelvin8ec71442015-01-15 16:57:00 -0800669 """
670 # Variable initialization
Jon Hall6801cda2015-07-15 14:13:45 -0700671 cellDirectory = self.home + "/tools/test/cells/"
kelvin8ec71442015-01-15 16:57:00 -0800672 # We want to create the cell file in the dependencies directory
673 # of TestON first, then copy over to ONOS bench
kelvin-onlabd3b64892015-01-20 13:26:24 -0800674 tempDirectory = "/tmp/"
kelvin8ec71442015-01-15 16:57:00 -0800675 # Create the cell file in the directory for writing ( w+ )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800676 cellFile = open( tempDirectory + fileName, 'w+' )
Jon Hall6801cda2015-07-15 14:13:45 -0700677 if isinstance( onosIpAddrs, types.StringType ):
678 onosIpAddrs = [ onosIpAddrs ]
kelvin8ec71442015-01-15 16:57:00 -0800679
cameron@onlab.us75900962015-03-30 13:22:49 -0700680 # App string is hardcoded environment variables
kelvin8ec71442015-01-15 16:57:00 -0800681 # That you may wish to use by default on startup.
cameron@onlab.us75900962015-03-30 13:22:49 -0700682 # Note that you may not want certain apps listed
kelvin8ec71442015-01-15 16:57:00 -0800683 # on here.
cameron@onlab.us75900962015-03-30 13:22:49 -0700684 appString = "export ONOS_APPS=" + appString
kelvin-onlabd3b64892015-01-20 13:26:24 -0800685 mnString = "export OCN="
kelvin-onlabf70fd542015-05-07 18:41:40 -0700686 if mnIpAddrs == "":
687 mnString = ""
kelvin-onlabd3b64892015-01-20 13:26:24 -0800688 onosString = "export OC"
689 tempCount = 1
kelvin8ec71442015-01-15 16:57:00 -0800690
kelvin-onlabd3b64892015-01-20 13:26:24 -0800691 # Create ONOSNIC ip address prefix
kelvin-onlaba4074292015-07-09 15:19:49 -0700692 tempOnosIp = str( onosIpAddrs[ 0 ] )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800693 tempList = []
694 tempList = tempOnosIp.split( "." )
kelvin8ec71442015-01-15 16:57:00 -0800695 # Omit last element of list to format for NIC
kelvin-onlabd3b64892015-01-20 13:26:24 -0800696 tempList = tempList[ :-1 ]
kelvin8ec71442015-01-15 16:57:00 -0800697 # Structure the nic string ip
kelvin-onlabd3b64892015-01-20 13:26:24 -0800698 nicAddr = ".".join( tempList ) + ".*"
699 onosNicString = "export ONOS_NIC=" + nicAddr
andrewonlab94282092014-10-10 13:00:11 -0400700
701 try:
kelvin8ec71442015-01-15 16:57:00 -0800702 # Start writing to file
kelvin-onlabd3b64892015-01-20 13:26:24 -0800703 cellFile.write( onosNicString + "\n" )
andrewonlab94282092014-10-10 13:00:11 -0400704
kelvin-onlabd3b64892015-01-20 13:26:24 -0800705 for arg in onosIpAddrs:
706 # For each argument in onosIpAddrs, write to file
kelvin8ec71442015-01-15 16:57:00 -0800707 # Output should look like the following:
andrewonlabd4940492014-10-24 12:21:27 -0400708 # export OC1="10.128.20.11"
709 # export OC2="10.128.20.12"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800710 cellFile.write( onosString + str( tempCount ) +
Jon Hall6f665652015-09-18 10:08:07 -0700711 "=\"" + arg + "\"\n" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800712 tempCount = tempCount + 1
kelvin8ec71442015-01-15 16:57:00 -0800713
Jon Hall6f665652015-09-18 10:08:07 -0700714 cellFile.write( "export OCI=$OC1\n" )
715 cellFile.write( mnString + "\"" + mnIpAddrs + "\"\n" )
cameron@onlab.us75900962015-03-30 13:22:49 -0700716 cellFile.write( appString + "\n" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800717 cellFile.close()
andrewonlab94282092014-10-10 13:00:11 -0400718
kelvin8ec71442015-01-15 16:57:00 -0800719 # We use os.system to send the command to TestON cluster
720 # to account for the case in which TestON is not located
721 # on the same cluster as the ONOS bench
722 # Note that even if TestON is located on the same cluster
723 # as ONOS bench, you must setup passwordless ssh
724 # between TestON and ONOS bench in order to automate the test.
kelvin-onlabc2b79102015-07-14 11:41:20 -0700725 os.system( "scp " + tempDirectory + fileName + " " +
726 self.user_name + "@" + self.ip_address + ":" + cellDirectory )
andrewonlab94282092014-10-10 13:00:11 -0400727
andrewonlab2a6c9342014-10-16 13:40:15 -0400728 return main.TRUE
729
andrewonlab94282092014-10-10 13:00:11 -0400730 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800731 main.log.error( self.name + ": EOF exception found" )
732 main.log.error( self.name + ": " + self.handle.before )
andrewonlab94282092014-10-10 13:00:11 -0400733 main.cleanup()
734 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800735 except Exception:
736 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab94282092014-10-10 13:00:11 -0400737 main.cleanup()
738 main.exit()
739
kelvin-onlabd3b64892015-01-20 13:26:24 -0800740 def setCell( self, cellname ):
kelvin8ec71442015-01-15 16:57:00 -0800741 """
andrewonlab95ca1462014-10-09 14:04:24 -0400742 Calls 'cell <name>' to set the environment variables on ONOSbench
kelvin8ec71442015-01-15 16:57:00 -0800743 """
Hari Krishna03f530e2015-07-10 17:28:27 -0700744 import re
andrewonlab95ca1462014-10-09 14:04:24 -0400745 try:
746 if not cellname:
kelvin8ec71442015-01-15 16:57:00 -0800747 main.log.error( "Must define cellname" )
andrewonlab95ca1462014-10-09 14:04:24 -0400748 main.cleanup()
749 main.exit()
750 else:
kelvin8ec71442015-01-15 16:57:00 -0800751 self.handle.sendline( "cell " + str( cellname ) )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800752 # Expect the cellname in the ONOSCELL variable.
kelvin8ec71442015-01-15 16:57:00 -0800753 # Note that this variable name is subject to change
andrewonlab95ca1462014-10-09 14:04:24 -0400754 # and that this driver will have to change accordingly
Cameron Franke9c94fb02015-01-21 10:20:20 -0800755 self.handle.expect(str(cellname))
kelvin-onlabd3b64892015-01-20 13:26:24 -0800756 handleBefore = self.handle.before
757 handleAfter = self.handle.after
kelvin8ec71442015-01-15 16:57:00 -0800758 # Get the rest of the handle
Cameron Franke9c94fb02015-01-21 10:20:20 -0800759 self.handle.sendline("")
760 self.handle.expect("\$")
kelvin-onlabd3b64892015-01-20 13:26:24 -0800761 handleMore = self.handle.before
andrewonlab95ca1462014-10-09 14:04:24 -0400762
Hari Krishna03f530e2015-07-10 17:28:27 -0700763 cell_result = handleBefore + handleAfter + handleMore
764 print cell_result
765 if( re.search( "No such cell", cell_result ) ):
766 main.log.error( "Cell call returned: " + handleBefore +
kelvin-onlabd3b64892015-01-20 13:26:24 -0800767 handleAfter + handleMore )
Hari Krishna03f530e2015-07-10 17:28:27 -0700768 main.cleanup()
769 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -0400770 return main.TRUE
771
772 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800773 main.log.error( self.name + ": EOF exception found" )
774 main.log.error( self.name + ": " + self.handle.before )
andrewonlab95ca1462014-10-09 14:04:24 -0400775 main.cleanup()
776 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800777 except Exception:
778 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ca1462014-10-09 14:04:24 -0400779 main.cleanup()
780 main.exit()
781
kelvin-onlabd3b64892015-01-20 13:26:24 -0800782 def verifyCell( self ):
kelvin8ec71442015-01-15 16:57:00 -0800783 """
andrewonlabc03bf6c2014-10-09 14:56:18 -0400784 Calls 'onos-verify-cell' to check for cell installation
kelvin8ec71442015-01-15 16:57:00 -0800785 """
786 # TODO: Add meaningful expect value
andrewonlab8d0d7d72014-10-09 16:33:15 -0400787
andrewonlabc03bf6c2014-10-09 14:56:18 -0400788 try:
kelvin8ec71442015-01-15 16:57:00 -0800789 # Clean handle by sending empty and expecting $
790 self.handle.sendline( "" )
791 self.handle.expect( "\$" )
792 self.handle.sendline( "onos-verify-cell" )
793 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800794 handleBefore = self.handle.before
795 handleAfter = self.handle.after
kelvin8ec71442015-01-15 16:57:00 -0800796 # Get the rest of the handle
797 self.handle.sendline( "" )
798 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800799 handleMore = self.handle.before
andrewonlabc03bf6c2014-10-09 14:56:18 -0400800
kelvin-onlabd3b64892015-01-20 13:26:24 -0800801 main.log.info( "Verify cell returned: " + handleBefore +
802 handleAfter + handleMore )
andrewonlabc03bf6c2014-10-09 14:56:18 -0400803
804 return main.TRUE
Jon Halla5cb6172015-02-23 09:28:28 -0800805 except pexpect.ExceptionPexpect as e:
806 main.log.error( self.name + ": Pexpect exception found of type " +
807 str( type( e ) ) )
808 main.log.error ( e.get_trace() )
kelvin8ec71442015-01-15 16:57:00 -0800809 main.log.error( self.name + ": " + self.handle.before )
Jon Hall7993bfc2014-10-09 16:30:14 -0400810 main.cleanup()
811 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800812 except Exception:
813 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall7993bfc2014-10-09 16:30:14 -0400814 main.cleanup()
815 main.exit()
816
jenkins1e99e7b2015-04-02 18:15:39 -0700817 def onosCfgSet( self, ONOSIp, configName, configParam ):
818 """
819 Uses 'onos <node-ip> cfg set' to change a parameter value of an
Jon Hall4ba53f02015-07-29 13:07:41 -0700820 application.
821
jenkins1e99e7b2015-04-02 18:15:39 -0700822 ex)
823 onos 10.0.0.1 cfg set org.onosproject.myapp appSetting 1
jenkins1e99e7b2015-04-02 18:15:39 -0700824 ONOSIp = '10.0.0.1'
825 configName = 'org.onosproject.myapp'
826 configParam = 'appSetting 1'
jenkins1e99e7b2015-04-02 18:15:39 -0700827 """
cameron@onlab.us78b89652015-07-08 15:21:03 -0700828 for i in range(5):
829 try:
830 cfgStr = ( "onos "+str(ONOSIp)+" cfg set "+
831 str(configName) + " " +
832 str(configParam)
833 )
jenkins1e99e7b2015-04-02 18:15:39 -0700834
cameron@onlab.us78b89652015-07-08 15:21:03 -0700835 self.handle.sendline( "" )
836 self.handle.expect( ":~" )
837 self.handle.sendline( cfgStr )
Jon Hall4ba53f02015-07-29 13:07:41 -0700838 self.handle.expect("cfg set")
cameron@onlab.us78b89652015-07-08 15:21:03 -0700839 self.handle.expect( ":~" )
Jon Hall4ba53f02015-07-29 13:07:41 -0700840
cameron@onlab.us78b89652015-07-08 15:21:03 -0700841 paramValue = configParam.split(" ")[1]
842 paramName = configParam.split(" ")[0]
Jon Hall4ba53f02015-07-29 13:07:41 -0700843
cameron@onlab.us78b89652015-07-08 15:21:03 -0700844 checkStr = ( "onos " + str(ONOSIp) + """ cfg get " """ + str(configName) + " " + paramName + """ " """)
jenkins1e99e7b2015-04-02 18:15:39 -0700845
cameron@onlab.us78b89652015-07-08 15:21:03 -0700846 self.handle.sendline( checkStr )
847 self.handle.expect( ":~" )
jenkins1e99e7b2015-04-02 18:15:39 -0700848
cameron@onlab.us78b89652015-07-08 15:21:03 -0700849 if "value=" + paramValue + "," in self.handle.before:
Jon Hall4ba53f02015-07-29 13:07:41 -0700850 main.log.info("cfg " + configName + " successfully set to " + configParam)
cameron@onlab.us78b89652015-07-08 15:21:03 -0700851 return main.TRUE
852
853 except pexpect.ExceptionPexpect as e:
854 main.log.error( self.name + ": Pexpect exception found of type " +
855 str( type( e ) ) )
856 main.log.error ( e.get_trace() )
857 main.log.error( self.name + ": " + self.handle.before )
858 main.cleanup()
859 main.exit()
860 except Exception:
861 main.log.exception( self.name + ": Uncaught exception!" )
862 main.cleanup()
863 main.exit()
Jon Hall4ba53f02015-07-29 13:07:41 -0700864
cameron@onlab.us78b89652015-07-08 15:21:03 -0700865 time.sleep(5)
866
867 main.log.error("CFG SET FAILURE: " + configName + " " + configParam )
Jon Hall4ba53f02015-07-29 13:07:41 -0700868 main.ONOSbench.handle.sendline("onos $OC1 cfg get")
cameron@onlab.us78b89652015-07-08 15:21:03 -0700869 main.ONOSbench.handle.expect("\$")
870 print main.ONOSbench.handle.before
871 main.ONOSbench.logReport( ONOSIp, ["ERROR","WARN","EXCEPT"], "d")
872 return main.FALSE
873
Jon Hall4ba53f02015-07-29 13:07:41 -0700874
kelvin-onlabd3b64892015-01-20 13:26:24 -0800875 def onosCli( self, ONOSIp, cmdstr ):
kelvin8ec71442015-01-15 16:57:00 -0800876 """
andrewonlab05e362f2014-10-10 00:40:57 -0400877 Uses 'onos' command to send various ONOS CLI arguments.
878 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800879 * ONOSIp: specify the ip of the cell machine
andrewonlab94282092014-10-10 13:00:11 -0400880 * cmdstr: specify the command string to send
kelvin8ec71442015-01-15 16:57:00 -0800881
882 This function is intended to expose the entire karaf
andrewonlab6e20c342014-10-10 18:08:48 -0400883 CLI commands for ONOS. Try to use this function first
884 before attempting to write a ONOS CLI specific driver
kelvin8ec71442015-01-15 16:57:00 -0800885 function.
886 You can see a list of available 'cmdstr' arguments
andrewonlab6e20c342014-10-10 18:08:48 -0400887 by starting onos, and typing in 'onos' to enter the
888 onos> CLI. Then, type 'help' to see the list of
kelvin8ec71442015-01-15 16:57:00 -0800889 available commands.
890 """
andrewonlab05e362f2014-10-10 00:40:57 -0400891 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800892 if not ONOSIp:
kelvin8ec71442015-01-15 16:57:00 -0800893 main.log.error( "You must specify the IP address" )
andrewonlab05e362f2014-10-10 00:40:57 -0400894 return main.FALSE
895 if not cmdstr:
kelvin8ec71442015-01-15 16:57:00 -0800896 main.log.error( "You must specify the command string" )
andrewonlab05e362f2014-10-10 00:40:57 -0400897 return main.FALSE
898
kelvin8ec71442015-01-15 16:57:00 -0800899 cmdstr = str( cmdstr )
900 self.handle.sendline( "" )
901 self.handle.expect( "\$" )
andrewonlab05e362f2014-10-10 00:40:57 -0400902
kelvin-onlabd3b64892015-01-20 13:26:24 -0800903 self.handle.sendline( "onos -w " + ONOSIp + " " + cmdstr )
kelvin8ec71442015-01-15 16:57:00 -0800904 self.handle.expect( "\$" )
andrewonlab05e362f2014-10-10 00:40:57 -0400905
kelvin-onlabd3b64892015-01-20 13:26:24 -0800906 handleBefore = self.handle.before
Shreya Shaha73aaad2014-10-27 18:03:09 -0400907 print "handle_before = ", self.handle.before
kelvin-onlabd3b64892015-01-20 13:26:24 -0800908 # handleAfter = str( self.handle.after )
Jon Hall47a93fb2015-01-06 16:46:06 -0800909
kelvin8ec71442015-01-15 16:57:00 -0800910 # self.handle.sendline( "" )
911 # self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800912 # handleMore = str( self.handle.before )
andrewonlab05e362f2014-10-10 00:40:57 -0400913
kelvin8ec71442015-01-15 16:57:00 -0800914 main.log.info( "Command sent successfully" )
andrewonlab05e362f2014-10-10 00:40:57 -0400915
kelvin8ec71442015-01-15 16:57:00 -0800916 # Obtain return handle that consists of result from
917 # the onos command. The string may need to be
918 # configured further.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800919 # returnString = handleBefore + handleAfter
920 returnString = handleBefore
921 print "return_string = ", returnString
922 return returnString
andrewonlab05e362f2014-10-10 00:40:57 -0400923
924 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800925 main.log.error( self.name + ": EOF exception found" )
926 main.log.error( self.name + ": " + self.handle.before )
andrewonlab05e362f2014-10-10 00:40:57 -0400927 main.cleanup()
928 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800929 except Exception:
930 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab05e362f2014-10-10 00:40:57 -0400931 main.cleanup()
932 main.exit()
Jon Hall7993bfc2014-10-09 16:30:14 -0400933
kelvin-onlabd3b64892015-01-20 13:26:24 -0800934 def onosInstall( self, options="-f", node="" ):
kelvin8ec71442015-01-15 16:57:00 -0800935 """
Jon Hall7993bfc2014-10-09 16:30:14 -0400936 Installs ONOS bits on the designated cell machine.
kelvin8ec71442015-01-15 16:57:00 -0800937 If -f option is provided, it also forces an uninstall.
938 Presently, install also includes onos-push-bits and
Jon Hall7993bfc2014-10-09 16:30:14 -0400939 onos-config within.
kelvin8ec71442015-01-15 16:57:00 -0800940 The node option allows you to selectively only push the jar
Jon Hall7993bfc2014-10-09 16:30:14 -0400941 files to certain onos nodes
942
943 Returns: main.TRUE on success and main.FALSE on failure
kelvin8ec71442015-01-15 16:57:00 -0800944 """
Jon Hall7993bfc2014-10-09 16:30:14 -0400945 try:
andrewonlab114768a2014-11-14 12:44:44 -0500946 if options:
kelvin8ec71442015-01-15 16:57:00 -0800947 self.handle.sendline( "onos-install " + options + " " + node )
andrewonlab114768a2014-11-14 12:44:44 -0500948 else:
kelvin8ec71442015-01-15 16:57:00 -0800949 self.handle.sendline( "onos-install " + node )
950 self.handle.expect( "onos-install " )
951 # NOTE: this timeout may need to change depending on the network
952 # and size of ONOS
953 i = self.handle.expect( [ "Network\sis\sunreachable",
kelvin-onlabd3b64892015-01-20 13:26:24 -0800954 "onos\sstart/running,\sprocess",
kelvin8ec71442015-01-15 16:57:00 -0800955 "ONOS\sis\salready\sinstalled",
956 pexpect.TIMEOUT ], timeout=60 )
Jon Hall7993bfc2014-10-09 16:30:14 -0400957
Jon Hall7993bfc2014-10-09 16:30:14 -0400958 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -0800959 main.log.warn( "Network is unreachable" )
Jon Hall7993bfc2014-10-09 16:30:14 -0400960 return main.FALSE
961 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -0800962 main.log.info(
963 "ONOS was installed on " +
964 node +
965 " and started" )
Jon Hall7993bfc2014-10-09 16:30:14 -0400966 return main.TRUE
andrewonlabd9a73a72014-11-14 17:28:21 -0500967 elif i == 2:
kelvin8ec71442015-01-15 16:57:00 -0800968 main.log.info( "ONOS is already installed on " + node )
andrewonlabd9a73a72014-11-14 17:28:21 -0500969 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800970 elif i == 3:
971 main.log.info(
972 "Installation of ONOS on " +
973 node +
974 " timed out" )
Jon Hall7993bfc2014-10-09 16:30:14 -0400975 return main.FALSE
andrewonlabc03bf6c2014-10-09 14:56:18 -0400976
977 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800978 main.log.error( self.name + ": EOF exception found" )
979 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc03bf6c2014-10-09 14:56:18 -0400980 main.cleanup()
981 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800982 except Exception:
983 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc03bf6c2014-10-09 14:56:18 -0400984 main.cleanup()
985 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -0400986
kelvin-onlabd3b64892015-01-20 13:26:24 -0800987 def onosStart( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -0800988 """
andrewonlab8d0d7d72014-10-09 16:33:15 -0400989 Calls onos command: 'onos-service [<node-ip>] start'
andrewonlabe8e56fd2014-10-09 17:12:44 -0400990 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -0800991 """
andrewonlab8d0d7d72014-10-09 16:33:15 -0400992 try:
kelvin8ec71442015-01-15 16:57:00 -0800993 self.handle.sendline( "" )
994 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800995 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -0800996 " start" )
997 i = self.handle.expect( [
andrewonlab8d0d7d72014-10-09 16:33:15 -0400998 "Job\sis\salready\srunning",
999 "start/running",
1000 "Unknown\sinstance",
kelvin8ec71442015-01-15 16:57:00 -08001001 pexpect.TIMEOUT ], timeout=120 )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001002
1003 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001004 main.log.info( "Service is already running" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001005 return main.TRUE
1006 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001007 main.log.info( "ONOS service started" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001008 return main.TRUE
1009 else:
kelvin8ec71442015-01-15 16:57:00 -08001010 main.log.error( "ONOS service failed to start" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001011 main.cleanup()
1012 main.exit()
andrewonlab8d0d7d72014-10-09 16:33:15 -04001013 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001014 main.log.error( self.name + ": EOF exception found" )
1015 main.log.error( self.name + ": " + self.handle.before )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001016 main.cleanup()
1017 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001018 except Exception:
1019 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001020 main.cleanup()
1021 main.exit()
1022
kelvin-onlabd3b64892015-01-20 13:26:24 -08001023 def onosStop( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001024 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001025 Calls onos command: 'onos-service [<node-ip>] stop'
andrewonlabe8e56fd2014-10-09 17:12:44 -04001026 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -08001027 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001028 try:
kelvin8ec71442015-01-15 16:57:00 -08001029 self.handle.sendline( "" )
1030 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001031 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001032 " stop" )
1033 i = self.handle.expect( [
andrewonlab2b30bd32014-10-09 16:48:55 -04001034 "stop/waiting",
Jon Hall61282e32015-03-19 11:34:11 -07001035 "Could not resolve hostname",
andrewonlab2b30bd32014-10-09 16:48:55 -04001036 "Unknown\sinstance",
kelvin8ec71442015-01-15 16:57:00 -08001037 pexpect.TIMEOUT ], timeout=60 )
andrewonlab2b30bd32014-10-09 16:48:55 -04001038
1039 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001040 main.log.info( "ONOS service stopped" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001041 return main.TRUE
1042 elif i == 1:
Jon Hall65844a32015-03-09 19:09:37 -07001043 main.log.info( "onosStop() Unknown ONOS instance specified: " +
kelvin-onlabd3b64892015-01-20 13:26:24 -08001044 str( nodeIp ) )
andrewonlab2b30bd32014-10-09 16:48:55 -04001045 return main.FALSE
Jon Hall61282e32015-03-19 11:34:11 -07001046 elif i == 2:
1047 main.log.warn( "ONOS wasn't running" )
1048 return main.TRUE
andrewonlab2b30bd32014-10-09 16:48:55 -04001049 else:
kelvin8ec71442015-01-15 16:57:00 -08001050 main.log.error( "ONOS service failed to stop" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001051 return main.FALSE
1052
1053 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001054 main.log.error( self.name + ": EOF exception found" )
1055 main.log.error( self.name + ": " + self.handle.before )
andrewonlab2b30bd32014-10-09 16:48:55 -04001056 main.cleanup()
1057 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001058 except Exception:
1059 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001060 main.cleanup()
1061 main.exit()
kelvin8ec71442015-01-15 16:57:00 -08001062
kelvin-onlabd3b64892015-01-20 13:26:24 -08001063 def onosUninstall( self, nodeIp="" ):
kelvin8ec71442015-01-15 16:57:00 -08001064 """
andrewonlabc8d47972014-10-09 16:52:36 -04001065 Calls the command: 'onos-uninstall'
kelvin8ec71442015-01-15 16:57:00 -08001066 Uninstalls ONOS from the designated cell machine, stopping
andrewonlabe8e56fd2014-10-09 17:12:44 -04001067 if needed
kelvin8ec71442015-01-15 16:57:00 -08001068 """
andrewonlabc8d47972014-10-09 16:52:36 -04001069 try:
kelvin8ec71442015-01-15 16:57:00 -08001070 self.handle.sendline( "" )
pingping-lin763ee042015-05-20 17:45:30 -07001071 self.handle.expect( "\$", timeout=60 )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001072 self.handle.sendline( "onos-uninstall " + str( nodeIp ) )
kelvin8ec71442015-01-15 16:57:00 -08001073 self.handle.expect( "\$" )
andrewonlabc8d47972014-10-09 16:52:36 -04001074
kelvin-onlabd3b64892015-01-20 13:26:24 -08001075 main.log.info( "ONOS " + nodeIp + " was uninstalled" )
andrewonlab9dfd2082014-11-13 17:44:03 -05001076
kelvin8ec71442015-01-15 16:57:00 -08001077 # onos-uninstall command does not return any text
andrewonlabc8d47972014-10-09 16:52:36 -04001078 return main.TRUE
1079
pingping-lin763ee042015-05-20 17:45:30 -07001080 except pexpect.TIMEOUT:
1081 main.log.exception( self.name + ": Timeout in onosUninstall" )
1082 return main.FALSE
andrewonlabc8d47972014-10-09 16:52:36 -04001083 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001084 main.log.error( self.name + ": EOF exception found" )
1085 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc8d47972014-10-09 16:52:36 -04001086 main.cleanup()
1087 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001088 except Exception:
1089 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc8d47972014-10-09 16:52:36 -04001090 main.cleanup()
1091 main.exit()
andrewonlab2b30bd32014-10-09 16:48:55 -04001092
kelvin-onlabd3b64892015-01-20 13:26:24 -08001093 def onosDie( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001094 """
andrewonlabaedc8332014-12-04 12:43:03 -05001095 Issues the command 'onos-die <node-ip>'
1096 This command calls onos-kill and also stops the node
kelvin8ec71442015-01-15 16:57:00 -08001097 """
andrewonlabaedc8332014-12-04 12:43:03 -05001098 try:
kelvin8ec71442015-01-15 16:57:00 -08001099 self.handle.sendline( "" )
1100 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001101 cmdStr = "onos-kill " + str( nodeIp )
1102 self.handle.sendline( cmdStr )
kelvin8ec71442015-01-15 16:57:00 -08001103 i = self.handle.expect( [
andrewonlabaedc8332014-12-04 12:43:03 -05001104 "Killing\sONOS",
1105 "ONOS\sprocess\sis\snot\srunning",
kelvin8ec71442015-01-15 16:57:00 -08001106 pexpect.TIMEOUT ], timeout=20 )
andrewonlabaedc8332014-12-04 12:43:03 -05001107 if i == 0:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001108 main.log.info( "ONOS instance " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001109 " was killed and stopped" )
andrewonlabaedc8332014-12-04 12:43:03 -05001110 return main.TRUE
1111 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001112 main.log.info( "ONOS process was not running" )
andrewonlabaedc8332014-12-04 12:43:03 -05001113 return main.FALSE
1114 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001115 main.log.error( self.name + ": EOF exception found" )
1116 main.log.error( self.name + ": " + self.handle.before )
andrewonlabaedc8332014-12-04 12:43:03 -05001117 main.cleanup()
1118 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001119 except Exception:
1120 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabaedc8332014-12-04 12:43:03 -05001121 main.cleanup()
1122 main.exit()
1123
kelvin-onlabd3b64892015-01-20 13:26:24 -08001124 def onosKill( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001125 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001126 Calls the command: 'onos-kill [<node-ip>]'
1127 "Remotely, and unceremoniously kills the ONOS instance running on
1128 the specified cell machine" - Tom V
kelvin8ec71442015-01-15 16:57:00 -08001129 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001130 try:
kelvin8ec71442015-01-15 16:57:00 -08001131 self.handle.sendline( "" )
1132 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001133 self.handle.sendline( "onos-kill " + str( nodeIp ) )
kelvin8ec71442015-01-15 16:57:00 -08001134 i = self.handle.expect( [
andrewonlabe8e56fd2014-10-09 17:12:44 -04001135 "\$",
1136 "No\sroute\sto\shost",
1137 "password:",
kelvin8ec71442015-01-15 16:57:00 -08001138 pexpect.TIMEOUT ], timeout=20 )
1139
andrewonlabe8e56fd2014-10-09 17:12:44 -04001140 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001141 main.log.info(
1142 "ONOS instance " + str(
kelvin-onlabd3b64892015-01-20 13:26:24 -08001143 nodeIp ) + " was killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001144 return main.TRUE
1145 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001146 main.log.info( "No route to host" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001147 return main.FALSE
1148 elif i == 2:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001149 main.log.info(
1150 "Passwordless login for host: " +
1151 str( nodeIp ) +
1152 " not configured" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001153 return main.FALSE
1154 else:
Jon Hallefbd9792015-03-05 16:11:36 -08001155 main.log.info( "ONOS instance was not killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001156 return main.FALSE
kelvin8ec71442015-01-15 16:57:00 -08001157
andrewonlabe8e56fd2014-10-09 17:12:44 -04001158 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001159 main.log.error( self.name + ": EOF exception found" )
1160 main.log.error( self.name + ": " + self.handle.before )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001161 main.cleanup()
1162 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001163 except Exception:
1164 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001165 main.cleanup()
1166 main.exit()
1167
kelvin-onlabd3b64892015-01-20 13:26:24 -08001168 def onosRemoveRaftLogs( self ):
kelvin8ec71442015-01-15 16:57:00 -08001169 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001170 Removes Raft / Copy cat files from ONOS to ensure
Jon Hallfcc88622014-11-25 13:09:54 -05001171 a cleaner environment.
1172
andrewonlab19fbdca2014-11-14 12:55:59 -05001173 Description:
Jon Hallfcc88622014-11-25 13:09:54 -05001174 Stops all ONOS defined in the cell,
andrewonlab19fbdca2014-11-14 12:55:59 -05001175 wipes the raft / copycat log files
kelvin8ec71442015-01-15 16:57:00 -08001176 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001177 try:
kelvin8ec71442015-01-15 16:57:00 -08001178 self.handle.sendline( "" )
1179 self.handle.expect( "\$" )
1180 self.handle.sendline( "onos-remove-raft-logs" )
1181 # Sometimes this command hangs
1182 i = self.handle.expect( [ "\$", pexpect.TIMEOUT ],
1183 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001184 if i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001185 i = self.handle.expect( [ "\$", pexpect.TIMEOUT ],
1186 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001187 if i == 1:
1188 return main.FALSE
shahshreya957feaa2015-03-23 16:08:29 -07001189 #self.handle.sendline( "" )
1190 #self.handle.expect( "\$" )
andrewonlab19fbdca2014-11-14 12:55:59 -05001191 return main.TRUE
1192
1193 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001194 main.log.error( self.name + ": EOF exception found" )
1195 main.log.error( self.name + ": " + self.handle.before )
andrewonlab19fbdca2014-11-14 12:55:59 -05001196 main.cleanup()
1197 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001198 except Exception:
1199 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab19fbdca2014-11-14 12:55:59 -05001200 main.cleanup()
1201 main.exit()
Jon Hallfcc88622014-11-25 13:09:54 -05001202
kelvin-onlabd3b64892015-01-20 13:26:24 -08001203 def onosStartNetwork( self, mntopo ):
kelvin8ec71442015-01-15 16:57:00 -08001204 """
1205 Calls the command 'onos-start-network [ <mininet-topo> ]
1206 "remotely starts the specified topology on the cell's
andrewonlab94282092014-10-10 13:00:11 -04001207 mininet machine against all controllers configured in the
kelvin8ec71442015-01-15 16:57:00 -08001208 cell."
andrewonlab94282092014-10-10 13:00:11 -04001209 * Specify mininet topology file name for mntopo
1210 * Topo files should be placed at:
1211 ~/<your-onos-directory>/tools/test/topos
kelvin8ec71442015-01-15 16:57:00 -08001212
andrewonlab94282092014-10-10 13:00:11 -04001213 NOTE: This function will take you to the mininet prompt
kelvin8ec71442015-01-15 16:57:00 -08001214 """
andrewonlab94282092014-10-10 13:00:11 -04001215 try:
1216 if not mntopo:
kelvin8ec71442015-01-15 16:57:00 -08001217 main.log.error( "You must specify a topo file to execute" )
andrewonlab94282092014-10-10 13:00:11 -04001218 return main.FALSE
andrewonlab94282092014-10-10 13:00:11 -04001219
kelvin8ec71442015-01-15 16:57:00 -08001220 mntopo = str( mntopo )
1221 self.handle.sendline( "" )
1222 self.handle.expect( "\$" )
andrewonlab94282092014-10-10 13:00:11 -04001223
kelvin8ec71442015-01-15 16:57:00 -08001224 self.handle.sendline( "onos-start-network " + mntopo )
1225 self.handle.expect( "mininet>" )
1226 main.log.info( "Network started, entered mininet prompt" )
1227
1228 # TODO: Think about whether return is necessary or not
andrewonlab94282092014-10-10 13:00:11 -04001229
1230 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001231 main.log.error( self.name + ": EOF exception found" )
1232 main.log.error( self.name + ": " + self.handle.before )
andrewonlab94282092014-10-10 13:00:11 -04001233 main.cleanup()
1234 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001235 except Exception:
1236 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab94282092014-10-10 13:00:11 -04001237 main.cleanup()
1238 main.exit()
1239
Cameron Franke9c94fb02015-01-21 10:20:20 -08001240 def isup(self, node = "", timeout = 120):
kelvin8ec71442015-01-15 16:57:00 -08001241 """
1242 Run's onos-wait-for-start which only returns once ONOS is at run
Cameron Franke9c94fb02015-01-21 10:20:20 -08001243 level 100(ready for use)
andrewonlab8d0d7d72014-10-09 16:33:15 -04001244
Jon Hall7993bfc2014-10-09 16:30:14 -04001245 Returns: main.TRUE if ONOS is running and main.FALSE on timeout
kelvin8ec71442015-01-15 16:57:00 -08001246 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001247 try:
Cameron Franke9c94fb02015-01-21 10:20:20 -08001248 self.handle.sendline("onos-wait-for-start " + node )
1249 self.handle.expect("onos-wait-for-start")
kelvin8ec71442015-01-15 16:57:00 -08001250 # NOTE: this timeout is arbitrary"
Cameron Franke9c94fb02015-01-21 10:20:20 -08001251 i = self.handle.expect(["\$", pexpect.TIMEOUT], timeout)
Jon Hall7993bfc2014-10-09 16:30:14 -04001252 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001253 main.log.info( self.name + ": " + node + " is up" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001254 return main.TRUE
1255 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001256 # NOTE: since this function won't return until ONOS is ready,
Jon Hall7993bfc2014-10-09 16:30:14 -04001257 # we will kill it on timeout
kelvin8ec71442015-01-15 16:57:00 -08001258 main.log.error( "ONOS has not started yet" )
1259 self.handle.send( "\x03" ) # Control-C
1260 self.handle.expect( "\$" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001261 return main.FALSE
1262 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001263 main.log.error( self.name + ": EOF exception found" )
1264 main.log.error( self.name + ": " + self.handle.before )
Jon Hall7993bfc2014-10-09 16:30:14 -04001265 main.cleanup()
1266 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001267 except Exception:
1268 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001269 main.cleanup()
1270 main.exit()
andrewonlab05e362f2014-10-10 00:40:57 -04001271
kelvin-onlabd3b64892015-01-20 13:26:24 -08001272 def pushTestIntentsShell(
1273 self,
1274 dpidSrc,
1275 dpidDst,
1276 numIntents,
1277 dirFile,
1278 onosIp,
1279 numMult="",
1280 appId="",
1281 report=True,
1282 options="" ):
kelvin8ec71442015-01-15 16:57:00 -08001283 """
andrewonlabb66dfa12014-12-02 15:51:10 -05001284 Description:
kelvin8ec71442015-01-15 16:57:00 -08001285 Use the linux prompt to push test intents to
andrewonlabb66dfa12014-12-02 15:51:10 -05001286 better parallelize the results than the CLI
1287 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001288 * dpidSrc: specify source dpid
1289 * dpidDst: specify destination dpid
1290 * numIntents: specify number of intents to push
1291 * dirFile: specify directory and file name to save
andrewonlabb66dfa12014-12-02 15:51:10 -05001292 results
kelvin-onlabd3b64892015-01-20 13:26:24 -08001293 * onosIp: specify the IP of ONOS to install on
kelvin8ec71442015-01-15 16:57:00 -08001294 NOTE:
andrewonlabb66dfa12014-12-02 15:51:10 -05001295 You must invoke this command at linux shell prompt
kelvin8ec71442015-01-15 16:57:00 -08001296 """
1297 try:
1298 # Create the string to sendline
andrewonlabaedc8332014-12-04 12:43:03 -05001299 if options:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001300 baseCmd = "onos " + str( onosIp ) + " push-test-intents " +\
kelvin8ec71442015-01-15 16:57:00 -08001301 options + " "
andrewonlabaedc8332014-12-04 12:43:03 -05001302 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001303 baseCmd = "onos " + str( onosIp ) + " push-test-intents "
kelvin8ec71442015-01-15 16:57:00 -08001304
kelvin-onlabd3b64892015-01-20 13:26:24 -08001305 addDpid = baseCmd + str( dpidSrc ) + " " + str( dpidDst )
1306 if not numMult:
1307 addIntents = addDpid + " " + str( numIntents )
1308 elif numMult:
1309 addIntents = addDpid + " " + str( numIntents ) + " " +\
1310 str( numMult )
1311 if appId:
1312 addApp = addIntents + " " + str( appId )
andrewonlabb66dfa12014-12-02 15:51:10 -05001313 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001314 addApp = addIntents
andrewonlabb66dfa12014-12-02 15:51:10 -05001315
andrewonlabaedc8332014-12-04 12:43:03 -05001316 if report:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001317 sendCmd = addApp + " > " + str( dirFile ) + " &"
andrewonlabaedc8332014-12-04 12:43:03 -05001318 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001319 sendCmd = addApp + " &"
1320 main.log.info( "Send cmd: " + sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001321
kelvin-onlabd3b64892015-01-20 13:26:24 -08001322 self.handle.sendline( sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001323
1324 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001325 main.log.error( self.name + ": EOF exception found" )
1326 main.log.error( self.name + ": " + self.handle.before )
andrewonlabb66dfa12014-12-02 15:51:10 -05001327 main.cleanup()
1328 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001329 except Exception:
1330 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabb66dfa12014-12-02 15:51:10 -05001331 main.cleanup()
kelvin8ec71442015-01-15 16:57:00 -08001332 main.exit()
andrewonlab05e362f2014-10-10 00:40:57 -04001333
kelvin-onlabd3b64892015-01-20 13:26:24 -08001334 def getTopology( self, topologyOutput ):
kelvin8ec71442015-01-15 16:57:00 -08001335 """
Hari Krishnaef1bd4e2015-03-12 16:55:30 -07001336 Definition:
1337 Loads a json topology output
1338 Return:
1339 topology = current ONOS topology
kelvin8ec71442015-01-15 16:57:00 -08001340 """
Hari Krishnaef1bd4e2015-03-12 16:55:30 -07001341 import json
Jon Hall77f53ce2014-10-13 18:02:06 -04001342 try:
Hari Krishnaef1bd4e2015-03-12 16:55:30 -07001343 # either onos:topology or 'topology' will work in CLI
1344 topology = json.loads(topologyOutput)
1345 print topology
Jon Hall77f53ce2014-10-13 18:02:06 -04001346 return topology
1347 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001348 main.log.error( self.name + ": EOF exception found" )
1349 main.log.error( self.name + ": " + self.handle.before )
Jon Hall77f53ce2014-10-13 18:02:06 -04001350 main.cleanup()
1351 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001352 except Exception:
1353 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall77f53ce2014-10-13 18:02:06 -04001354 main.cleanup()
1355 main.exit()
1356
kelvin-onlabd3b64892015-01-20 13:26:24 -08001357 def checkStatus(
1358 self,
1359 topologyResult,
1360 numoswitch,
1361 numolink,
1362 logLevel="info" ):
kelvin8ec71442015-01-15 16:57:00 -08001363 """
Jon Hallefbd9792015-03-05 16:11:36 -08001364 Checks the number of switches & links that ONOS sees against the
kelvin8ec71442015-01-15 16:57:00 -08001365 supplied values. By default this will report to main.log, but the
Jon Hallefbd9792015-03-05 16:11:36 -08001366 log level can be specific.
kelvin8ec71442015-01-15 16:57:00 -08001367
Jon Hall77f53ce2014-10-13 18:02:06 -04001368 Params: ip = ip used for the onos cli
1369 numoswitch = expected number of switches
Jon Hallefbd9792015-03-05 16:11:36 -08001370 numolink = expected number of links
kelvin-onlabd3b64892015-01-20 13:26:24 -08001371 logLevel = level to log to.
1372 Currently accepts 'info', 'warn' and 'report'
Jon Hall77f53ce2014-10-13 18:02:06 -04001373
1374
kelvin-onlabd3b64892015-01-20 13:26:24 -08001375 logLevel can
Jon Hall77f53ce2014-10-13 18:02:06 -04001376
Jon Hallefbd9792015-03-05 16:11:36 -08001377 Returns: main.TRUE if the number of switches and links are correct,
1378 main.FALSE if the number of switches and links is incorrect,
Jon Hall77f53ce2014-10-13 18:02:06 -04001379 and main.ERROR otherwise
kelvin8ec71442015-01-15 16:57:00 -08001380 """
Jon Hall77f53ce2014-10-13 18:02:06 -04001381 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001382 topology = self.getTopology( topologyResult )
Jon Hall77f53ce2014-10-13 18:02:06 -04001383 if topology == {}:
1384 return main.ERROR
1385 output = ""
kelvin8ec71442015-01-15 16:57:00 -08001386 # Is the number of switches is what we expected
shahshreya234a1682015-05-27 15:41:56 -07001387 devices = topology.get( 'devices', False )
1388 links = topology.get( 'links', False )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001389 if not devices or not links:
Jon Hall77f53ce2014-10-13 18:02:06 -04001390 return main.ERROR
kelvin-onlabd3b64892015-01-20 13:26:24 -08001391 switchCheck = ( int( devices ) == int( numoswitch ) )
kelvin8ec71442015-01-15 16:57:00 -08001392 # Is the number of links is what we expected
kelvin-onlabd3b64892015-01-20 13:26:24 -08001393 linkCheck = ( int( links ) == int( numolink ) )
Jon Hallefbd9792015-03-05 16:11:36 -08001394 if switchCheck and linkCheck:
kelvin8ec71442015-01-15 16:57:00 -08001395 # We expected the correct numbers
Jon Hall77f53ce2014-10-13 18:02:06 -04001396 output = output + "The number of links and switches match "\
kelvin8ec71442015-01-15 16:57:00 -08001397 + "what was expected"
Jon Hall77f53ce2014-10-13 18:02:06 -04001398 result = main.TRUE
1399 else:
1400 output = output + \
Jon Hall274b6642015-02-17 11:57:17 -08001401 "The number of links and switches does not match " + \
1402 "what was expected"
Jon Hall77f53ce2014-10-13 18:02:06 -04001403 result = main.FALSE
Jon Hallefbd9792015-03-05 16:11:36 -08001404 output = output + "\n ONOS sees %i devices" % int( devices )
1405 output = output + " (%i expected) " % int( numoswitch )
Jon Hall274b6642015-02-17 11:57:17 -08001406 output = output + "and %i links " % int( links )
1407 output = output + "(%i expected)" % int( numolink )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001408 if logLevel == "report":
kelvin8ec71442015-01-15 16:57:00 -08001409 main.log.report( output )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001410 elif logLevel == "warn":
kelvin8ec71442015-01-15 16:57:00 -08001411 main.log.warn( output )
Jon Hall77f53ce2014-10-13 18:02:06 -04001412 else:
kelvin8ec71442015-01-15 16:57:00 -08001413 main.log.info( output )
1414 return result
Jon Hall77f53ce2014-10-13 18:02:06 -04001415 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001416 main.log.error( self.name + ": EOF exception found" )
1417 main.log.error( self.name + ": " + self.handle.before )
Jon Hall77f53ce2014-10-13 18:02:06 -04001418 main.cleanup()
1419 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001420 except Exception:
1421 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall77f53ce2014-10-13 18:02:06 -04001422 main.cleanup()
1423 main.exit()
andrewonlabba44bcf2014-10-16 16:54:41 -04001424
kelvin-onlabd3b64892015-01-20 13:26:24 -08001425 def tsharkPcap( self, interface, dirFile ):
kelvin8ec71442015-01-15 16:57:00 -08001426 """
andrewonlab970399c2014-11-07 13:09:32 -05001427 Capture all packet activity and store in specified
1428 directory/file
1429
1430 Required:
1431 * interface: interface to capture
1432 * dir: directory/filename to store pcap
kelvin8ec71442015-01-15 16:57:00 -08001433 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001434 try:
1435 self.handle.sendline( "" )
1436 self.handle.expect( "\$" )
andrewonlab970399c2014-11-07 13:09:32 -05001437
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001438 self.handle.sendline( "tshark -i " + str( interface ) + " -t e -w " + str( dirFile ) + " &" )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001439 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001440 self.handle.expect( "Capturing on" )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001441 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001442 self.handle.expect( "\$" )
andrewonlab970399c2014-11-07 13:09:32 -05001443
Jon Hallfebb1c72015-03-05 13:30:09 -08001444 main.log.info( "Tshark started capturing files on " +
1445 str( interface ) + " and saving to directory: " +
1446 str( dirFile ) )
1447 except pexpect.EOF:
1448 main.log.error( self.name + ": EOF exception found" )
1449 main.log.error( self.name + ": " + self.handle.before )
1450 main.cleanup()
1451 main.exit()
1452 except Exception:
1453 main.log.exception( self.name + ": Uncaught exception!" )
1454 main.cleanup()
1455 main.exit()
Shreya Shaha73aaad2014-10-27 18:03:09 -04001456
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001457 def onosTopoCfg( self, onosIp, jsonFile ):
kelvin8ec71442015-01-15 16:57:00 -08001458 """
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001459 Description:
1460 Execute onos-topo-cfg command
1461 Required:
1462 onosIp - IP of the onos node you want to send the json to
1463 jsonFile - File path of the json file
1464 Return:
1465 Returns main.TRUE if the command is successfull; Returns
1466 main.FALSE if there was an error
kelvin8ec71442015-01-15 16:57:00 -08001467 """
shahshreyae6c7cf42014-11-26 16:39:01 -08001468 try:
kelvin8ec71442015-01-15 16:57:00 -08001469 self.handle.sendline( "" )
1470 self.handle.expect( "\$" )
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001471 cmd = "onos-topo-cfg "
1472 self.handle.sendline( cmd + str( onosIp ) + " " + jsonFile )
1473 handle = self.handle.before
1474 print handle
1475 if "Error" in handle:
1476 main.log.error( self.name + ": " + self.handle.before )
1477 return main.FALSE
1478 else:
1479 self.handle.expect( "\$" )
1480 return main.TRUE
1481
Jon Hallfebb1c72015-03-05 13:30:09 -08001482 except pexpect.EOF:
1483 main.log.error( self.name + ": EOF exception found" )
1484 main.log.error( self.name + ": " + self.handle.before )
1485 main.cleanup()
1486 main.exit()
1487 except Exception:
1488 main.log.exception( self.name + ": Uncaught exception!" )
1489 main.cleanup()
1490 main.exit()
kelvin8ec71442015-01-15 16:57:00 -08001491
jenkins1e99e7b2015-04-02 18:15:39 -07001492 def tsharkGrep( self, grep, directory, interface='eth0', grepOptions='' ):
kelvin8ec71442015-01-15 16:57:00 -08001493 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001494 Required:
kelvin8ec71442015-01-15 16:57:00 -08001495 * grep string
andrewonlabba44bcf2014-10-16 16:54:41 -04001496 * directory to store results
1497 Optional:
1498 * interface - default: eth0
Jon Hall4ba53f02015-07-29 13:07:41 -07001499 * grepOptions - options for grep
andrewonlabba44bcf2014-10-16 16:54:41 -04001500 Description:
1501 Uses tshark command to grep specific group of packets
1502 and stores the results to specified directory.
kelvin8ec71442015-01-15 16:57:00 -08001503 The timestamp is hardcoded to be in epoch
1504 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001505 try:
1506 self.handle.sendline( "" )
1507 self.handle.expect( "\$" )
1508 self.handle.sendline( "" )
jenkins1e99e7b2015-04-02 18:15:39 -07001509 if grepOptions:
1510 grepStr = "grep "+str(grepOptions)
1511 else:
1512 grepStr = "grep"
Jon Hall4ba53f02015-07-29 13:07:41 -07001513
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001514 cmd = (
1515 "sudo tshark -i " +
Jon Hallfebb1c72015-03-05 13:30:09 -08001516 str( interface ) +
jenkins1e99e7b2015-04-02 18:15:39 -07001517 " -t e | " +
1518 grepStr + " --line-buffered \"" +
Jon Hallfebb1c72015-03-05 13:30:09 -08001519 str(grep) +
1520 "\" >" +
1521 directory +
1522 " &" )
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001523 self.handle.sendline(cmd)
1524 main.log.info(cmd)
Jon Hallfebb1c72015-03-05 13:30:09 -08001525 self.handle.expect( "Capturing on" )
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001526 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001527 self.handle.expect( "\$" )
1528 except pexpect.EOF:
1529 main.log.error( self.name + ": EOF exception found" )
1530 main.log.error( self.name + ": " + self.handle.before )
1531 main.cleanup()
1532 main.exit()
1533 except Exception:
1534 main.log.exception( self.name + ": Uncaught exception!" )
1535 main.cleanup()
1536 main.exit()
1537
kelvin-onlabd3b64892015-01-20 13:26:24 -08001538 def tsharkStop( self ):
kelvin8ec71442015-01-15 16:57:00 -08001539 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001540 Removes wireshark files from /tmp and kills all tshark processes
kelvin8ec71442015-01-15 16:57:00 -08001541 """
1542 # Remove all pcap from previous captures
Jon Hallfebb1c72015-03-05 13:30:09 -08001543 try:
1544 self.execute( cmd="sudo rm /tmp/wireshark*" )
1545 self.handle.sendline( "" )
Jon Hallefbd9792015-03-05 16:11:36 -08001546 self.handle.sendline( "sudo kill -9 `ps -ef | grep \"tshark -i\"" +
1547 " | grep -v grep | awk '{print $2}'`" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001548 self.handle.sendline( "" )
1549 main.log.info( "Tshark stopped" )
1550 except pexpect.EOF:
1551 main.log.error( self.name + ": EOF exception found" )
1552 main.log.error( self.name + ": " + self.handle.before )
1553 main.cleanup()
1554 main.exit()
1555 except Exception:
1556 main.log.exception( self.name + ": Uncaught exception!" )
1557 main.cleanup()
1558 main.exit()
1559
kelvin8ec71442015-01-15 16:57:00 -08001560 def ptpd( self, args ):
1561 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001562 Initiate ptp with user-specified args.
1563 Required:
1564 * args: specify string of args after command
1565 'sudo ptpd'
kelvin8ec71442015-01-15 16:57:00 -08001566 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001567 try:
kelvin8ec71442015-01-15 16:57:00 -08001568 self.handle.sendline( "sudo ptpd " + str( args ) )
1569 i = self.handle.expect( [
andrewonlab0c38a4a2014-10-28 18:35:35 -04001570 "Multiple",
1571 "Error",
kelvin8ec71442015-01-15 16:57:00 -08001572 "\$" ] )
1573 self.handle.expect( "\$" )
andrewonlabba44bcf2014-10-16 16:54:41 -04001574
andrewonlab0c38a4a2014-10-28 18:35:35 -04001575 if i == 0:
1576 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001577 main.log.info( "ptpd returned an error: " +
1578 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001579 return handle
1580 elif i == 1:
1581 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001582 main.log.error( "ptpd returned an error: " +
1583 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001584 return handle
1585 else:
1586 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -08001587
andrewonlab0c38a4a2014-10-28 18:35:35 -04001588 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001589 main.log.error( self.name + ": EOF exception found" )
1590 main.log.error( self.name + ": " + self.handle.before )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001591 main.cleanup()
1592 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001593 except Exception:
1594 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001595 main.cleanup()
1596 main.exit()
andrewonlabba44bcf2014-10-16 16:54:41 -04001597
kelvin-onlabd3b64892015-01-20 13:26:24 -08001598 def cpLogsToDir( self, logToCopy,
Jon Hallefbd9792015-03-05 16:11:36 -08001599 destDir, copyFileName="" ):
kelvin8ec71442015-01-15 16:57:00 -08001600 """
1601 Copies logs to a desired directory.
andrewonlab5d7a8f32014-11-10 13:07:56 -05001602 Current implementation of ONOS deletes its karaf
1603 logs on every iteration. For debugging purposes,
kelvin8ec71442015-01-15 16:57:00 -08001604 you may want to use this function to capture
1605 certain karaf logs. ( or any other logs if needed )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001606 Localtime will be attached to the filename
1607
1608 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001609 * logToCopy: specify directory and log name to
andrewonlab5d7a8f32014-11-10 13:07:56 -05001610 copy.
kelvin8ec71442015-01-15 16:57:00 -08001611 ex ) /opt/onos/log/karaf.log.1
kelvin-onlabd3b64892015-01-20 13:26:24 -08001612 For copying multiple files, leave copyFileName
1613 empty and only specify destDir -
kelvin8ec71442015-01-15 16:57:00 -08001614 ex ) /opt/onos/log/karaf*
kelvin-onlabd3b64892015-01-20 13:26:24 -08001615 * destDir: specify directory to copy to.
kelvin8ec71442015-01-15 16:57:00 -08001616 ex ) /tmp/
1617 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001618 * copyFileName: If you want to rename the log
1619 file, specify copyFileName. This will not work
andrewonlab5d7a8f32014-11-10 13:07:56 -05001620 with multiple file copying
kelvin8ec71442015-01-15 16:57:00 -08001621 """
andrewonlab5d7a8f32014-11-10 13:07:56 -05001622 try:
kelvin8ec71442015-01-15 16:57:00 -08001623 localtime = time.strftime( '%x %X' )
1624 localtime = localtime.replace( "/", "" )
1625 localtime = localtime.replace( " ", "_" )
1626 localtime = localtime.replace( ":", "" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001627 if destDir[ -1: ] != "/":
1628 destDir += "/"
andrewonlab5d7a8f32014-11-10 13:07:56 -05001629
kelvin-onlabd3b64892015-01-20 13:26:24 -08001630 if copyFileName:
Jon Hallfebb1c72015-03-05 13:30:09 -08001631 self.handle.sendline( "cp " + str( logToCopy ) + " " +
1632 str( destDir ) + str( copyFileName ) +
1633 localtime )
kelvin8ec71442015-01-15 16:57:00 -08001634 self.handle.expect( "cp" )
1635 self.handle.expect( "\$" )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001636 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001637 self.handle.sendline( "cp " + str( logToCopy ) +
1638 " " + str( destDir ) )
kelvin8ec71442015-01-15 16:57:00 -08001639 self.handle.expect( "cp" )
1640 self.handle.expect( "\$" )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001641
kelvin8ec71442015-01-15 16:57:00 -08001642 return self.handle.before
1643
1644 except pexpect.EOF:
1645 main.log.error( "Copying files failed" )
1646 main.log.error( self.name + ": EOF exception found" )
1647 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001648 except Exception:
1649 main.log.exception( "Copying files failed" )
1650
Jon Hall16b72c42015-05-20 10:23:36 -07001651 def checkLogs( self, onosIp, restart=False):
kelvin8ec71442015-01-15 16:57:00 -08001652 """
Jon Hall94fd0472014-12-08 11:52:42 -08001653 runs onos-check-logs on the given onos node
Jon Hall80daded2015-05-27 16:07:00 -07001654 If restart is True, use the old version of onos-check-logs which
1655 does not print the full stacktrace, but shows the entire log file,
1656 including across restarts
Jon Hall94fd0472014-12-08 11:52:42 -08001657 returns the response
kelvin8ec71442015-01-15 16:57:00 -08001658 """
Jon Hall94fd0472014-12-08 11:52:42 -08001659 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001660 cmd = "onos-check-logs " + str( onosIp )
Jon Hall16b72c42015-05-20 10:23:36 -07001661 if restart:
1662 cmd += " old"
kelvin8ec71442015-01-15 16:57:00 -08001663 self.handle.sendline( cmd )
1664 self.handle.expect( cmd )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001665 self.handle.expect( "\$ " )
Jon Hall94fd0472014-12-08 11:52:42 -08001666 response = self.handle.before
1667 return response
1668 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001669 main.log.error( "Lost ssh connection" )
1670 main.log.error( self.name + ": EOF exception found" )
1671 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001672 except Exception:
1673 main.log.exception( self.name + ": Uncaught exception!" )
1674 main.cleanup()
1675 main.exit()
Jon Hall94fd0472014-12-08 11:52:42 -08001676
kelvin-onlabd3b64892015-01-20 13:26:24 -08001677 def onosStatus( self, node="" ):
kelvin8ec71442015-01-15 16:57:00 -08001678 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001679 Calls onos command: 'onos-service [<node-ip>] status'
kelvin8ec71442015-01-15 16:57:00 -08001680 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001681 try:
kelvin8ec71442015-01-15 16:57:00 -08001682 self.handle.sendline( "" )
1683 self.handle.expect( "\$" )
1684 self.handle.sendline( "onos-service " + str( node ) +
1685 " status" )
1686 i = self.handle.expect( [
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001687 "start/running",
1688 "stop/waiting",
kelvin8ec71442015-01-15 16:57:00 -08001689 pexpect.TIMEOUT ], timeout=120 )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001690
1691 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001692 main.log.info( "ONOS is running" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001693 return main.TRUE
1694 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001695 main.log.info( "ONOS is stopped" )
kelvin8ec71442015-01-15 16:57:00 -08001696 main.log.error( "ONOS service failed to check the status" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001697 main.cleanup()
1698 main.exit()
1699 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001700 main.log.error( self.name + ": EOF exception found" )
1701 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001702 main.cleanup()
1703 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001704 except Exception:
1705 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001706 main.cleanup()
1707 main.exit()
Jon Hall21270ac2015-02-16 17:59:55 -08001708
Jon Hall63604932015-02-26 17:09:50 -08001709 def setIpTables( self, ip, port='', action='add', packet_type='',
1710 direction='INPUT', rule='DROP', states=True ):
Jon Hallefbd9792015-03-05 16:11:36 -08001711 """
Jon Hall21270ac2015-02-16 17:59:55 -08001712 Description:
1713 add or remove iptables rule to DROP (default) packets from
1714 specific IP and PORT
1715 Usage:
1716 * specify action ('add' or 'remove')
1717 when removing, pass in the same argument as you would add. It will
1718 delete that specific rule.
1719 * specify the ip to block
1720 * specify the destination port to block (defaults to all ports)
1721 * optional packet type to block (default tcp)
1722 * optional iptables rule (default DROP)
1723 * optional direction to block (default 'INPUT')
Jon Hall63604932015-02-26 17:09:50 -08001724 * States boolean toggles adding all supported tcp states to the
1725 firewall rule
Jon Hall21270ac2015-02-16 17:59:55 -08001726 Returns:
1727 main.TRUE on success or
1728 main.FALSE if given invalid input or
1729 main.ERROR if there is an error in response from iptables
1730 WARNING:
1731 * This function uses root privilege iptables command which may result
1732 in unwanted network errors. USE WITH CAUTION
Jon Hallefbd9792015-03-05 16:11:36 -08001733 """
Jon Hall21270ac2015-02-16 17:59:55 -08001734
1735 # NOTE*********
1736 # The strict checking methods of this driver function is intentional
1737 # to discourage any misuse or error of iptables, which can cause
1738 # severe network errors
1739 # *************
1740
1741 # NOTE: Sleep needed to give some time for rule to be added and
1742 # registered to the instance. If you are calling this function
1743 # multiple times this sleep will prevent any errors.
1744 # DO NOT REMOVE
Jon Hall63604932015-02-26 17:09:50 -08001745 # time.sleep( 5 )
Jon Hall21270ac2015-02-16 17:59:55 -08001746 try:
1747 # input validation
1748 action_type = action.lower()
1749 rule = rule.upper()
1750 direction = direction.upper()
1751 if action_type != 'add' and action_type != 'remove':
1752 main.log.error( "Invalid action type. Use 'add' or "
1753 "'remove' table rule" )
1754 if rule != 'DROP' and rule != 'ACCEPT' and rule != 'LOG':
1755 # NOTE Currently only supports rules DROP, ACCEPT, and LOG
1756 main.log.error( "Invalid rule. Valid rules are 'DROP' or "
1757 "'ACCEPT' or 'LOG' only." )
1758 if direction != 'INPUT' and direction != 'OUTPUT':
1759 # NOTE currently only supports rules INPUT and OUPTUT
1760 main.log.error( "Invalid rule. Valid directions are"
1761 " 'OUTPUT' or 'INPUT'" )
1762 return main.FALSE
1763 return main.FALSE
1764 return main.FALSE
1765 if action_type == 'add':
1766 # -A is the 'append' action of iptables
1767 actionFlag = '-A'
1768 elif action_type == 'remove':
1769 # -D is the 'delete' rule of iptables
1770 actionFlag = '-D'
1771 self.handle.sendline( "" )
1772 self.handle.expect( "\$" )
1773 cmd = "sudo iptables " + actionFlag + " " +\
1774 direction +\
Jon Hall21270ac2015-02-16 17:59:55 -08001775 " -s " + str( ip )
Jon Hall63604932015-02-26 17:09:50 -08001776 # " -p " + str( packet_type ) +\
1777 if packet_type:
1778 cmd += " -p " + str( packet_type )
Jon Hall21270ac2015-02-16 17:59:55 -08001779 if port:
1780 cmd += " --dport " + str( port )
Jon Hall63604932015-02-26 17:09:50 -08001781 if states:
1782 cmd += " -m state --state="
1783 #FIXME- Allow user to configure which states to block
1784 cmd += "INVALID,ESTABLISHED,NEW,RELATED,UNTRACKED"
Jon Hall21270ac2015-02-16 17:59:55 -08001785 cmd += " -j " + str( rule )
1786
1787 self.handle.sendline( cmd )
1788 self.handle.expect( "\$" )
1789 main.log.warn( self.handle.before )
1790
1791 info_string = "On " + str( self.name )
1792 info_string += " " + str( action_type )
1793 info_string += " iptable rule [ "
1794 info_string += " IP: " + str( ip )
1795 info_string += " Port: " + str( port )
1796 info_string += " Rule: " + str( rule )
1797 info_string += " Direction: " + str( direction ) + " ]"
1798 main.log.info( info_string )
1799 return main.TRUE
1800 except pexpect.TIMEOUT:
1801 main.log.exception( self.name + ": Timeout exception in "
1802 "setIpTables function" )
1803 return main.ERROR
1804 except pexpect.EOF:
1805 main.log.error( self.name + ": EOF exception found" )
1806 main.log.error( self.name + ": " + self.handle.before )
1807 main.cleanup()
1808 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001809 except Exception:
1810 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall21270ac2015-02-16 17:59:55 -08001811 main.cleanup()
1812 main.exit()
1813
Jon Hall0468b042015-02-19 19:08:21 -08001814 def detailed_status(self, log_filename):
Jon Hallefbd9792015-03-05 16:11:36 -08001815 """
Jon Hall0468b042015-02-19 19:08:21 -08001816 This method is used by STS to check the status of the controller
1817 Reports RUNNING, STARTING, STOPPED, FROZEN, ERROR (and reason)
Jon Hallefbd9792015-03-05 16:11:36 -08001818 """
Jon Hall0468b042015-02-19 19:08:21 -08001819 import re
1820 try:
1821 self.handle.sendline( "" )
1822 self.handle.expect( "\$" )
1823 self.handle.sendline( "cd " + self.home )
1824 self.handle.expect( "\$" )
1825 self.handle.sendline( "service onos status" )
1826 self.handle.expect( "\$" )
1827 response = self.handle.before
1828 if re.search( "onos start/running", response ):
1829 # onos start/running, process 10457
1830 return 'RUNNING'
1831 # FIXME: Implement this case
1832 # elif re.search( pattern, response ):
1833 # return 'STARTING'
1834 elif re.search( "onos stop/", response ):
1835 # onos stop/waiting
1836 # FIXME handle this differently?: onos stop/pre-stop
1837 return 'STOPPED'
1838 # FIXME: Implement this case
1839 # elif re.search( pattern, response ):
1840 # return 'FROZEN'
1841 else:
1842 main.log.warn( self.name +
Jon Hallefbd9792015-03-05 16:11:36 -08001843 " WARNING: status received unknown response" )
Jon Hall0468b042015-02-19 19:08:21 -08001844 main.log.warn( response )
1845 return 'ERROR', "Unknown response: %s" % response
1846 except pexpect.TIMEOUT:
1847 main.log.exception( self.name + ": Timeout exception in "
1848 "setIpTables function" )
1849 return 'ERROR', "Pexpect Timeout"
1850 except pexpect.EOF:
1851 main.log.error( self.name + ": EOF exception found" )
1852 main.log.error( self.name + ": " + self.handle.before )
1853 main.cleanup()
1854 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001855 except Exception:
1856 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall0468b042015-02-19 19:08:21 -08001857 main.cleanup()
1858 main.exit()
1859
andrew@onlab.us3b087132015-03-11 15:00:08 -07001860 def createLinkGraphFile( self, benchIp, ONOSIpList, deviceCount):
1861 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07001862 Create/formats the LinkGraph.cfg file based on arguments
1863 -only creates a linear topology and connects islands
1864 -evenly distributes devices
andrew@onlab.us3b087132015-03-11 15:00:08 -07001865 -must be called by ONOSbench
1866
Jon Hall4ba53f02015-07-29 13:07:41 -07001867 ONOSIpList - list of all of the node IPs to be used
1868
1869 deviceCount - number of switches to be assigned
andrew@onlab.us3b087132015-03-11 15:00:08 -07001870 '''
1871 main.log.step("Creating link graph configuration file." )
1872 linkGraphPath = self.home + "/tools/package/etc/linkGraph.cfg"
Jon Hall4ba53f02015-07-29 13:07:41 -07001873 tempFile = "/tmp/linkGraph.cfg"
andrew@onlab.us3b087132015-03-11 15:00:08 -07001874
1875 linkGraph = open(tempFile, 'w+')
1876 linkGraph.write("# NullLinkProvider topology description (config file).\n")
1877 linkGraph.write("# The NodeId is only added if the destination is another node's device.\n")
1878 linkGraph.write("# Bugs: Comments cannot be appended to a line to be read.\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07001879
andrew@onlab.us3b087132015-03-11 15:00:08 -07001880 clusterCount = len(ONOSIpList)
Jon Hall4ba53f02015-07-29 13:07:41 -07001881
1882 if type(deviceCount) is int or type(deviceCount) is str:
andrew@onlab.us3b087132015-03-11 15:00:08 -07001883 deviceCount = int(deviceCount)
1884 switchList = [0]*(clusterCount+1)
1885 baselineSwitchCount = deviceCount/clusterCount
Jon Hall4ba53f02015-07-29 13:07:41 -07001886
andrew@onlab.us3b087132015-03-11 15:00:08 -07001887 for node in range(1, clusterCount + 1):
1888 switchList[node] = baselineSwitchCount
1889
1890 for node in range(1, (deviceCount%clusterCount)+1):
1891 switchList[node] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001892
andrew@onlab.us3b087132015-03-11 15:00:08 -07001893 if type(deviceCount) is list:
1894 main.log.info("Using provided device distribution")
1895 switchList = [0]
1896 for i in deviceCount:
1897 switchList.append(int(i))
1898
1899 tempList = ['0']
1900 tempList.extend(ONOSIpList)
1901 ONOSIpList = tempList
1902
1903 myPort = 6
1904 lastSwitch = 0
1905 for node in range(1, clusterCount+1):
1906 if switchList[node] == 0:
1907 continue
1908
1909 linkGraph.write("graph " + ONOSIpList[node] + " {\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07001910
andrew@onlab.us3b087132015-03-11 15:00:08 -07001911 if node > 1:
1912 #connect to last device on previous node
Jon Hall4ba53f02015-07-29 13:07:41 -07001913 line = ("\t0:5 -> " + str(lastSwitch) + ":6:" + lastIp + "\n") #ONOSIpList[node-1]
1914 linkGraph.write(line)
1915
1916 lastSwitch = 0
1917 for switch in range (0, switchList[node]-1):
andrew@onlab.us3b087132015-03-11 15:00:08 -07001918 line = ""
1919 line = ("\t" + str(switch) + ":" + str(myPort))
1920 line += " -- "
1921 line += (str(switch+1) + ":" + str(myPort-1) + "\n")
1922 linkGraph.write(line)
Jon Hall4ba53f02015-07-29 13:07:41 -07001923 lastSwitch = switch+1
andrew@onlab.us3b087132015-03-11 15:00:08 -07001924 lastIp = ONOSIpList[node]
Jon Hall4ba53f02015-07-29 13:07:41 -07001925
andrew@onlab.us3b087132015-03-11 15:00:08 -07001926 #lastSwitch += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001927 if node < (clusterCount):
andrew@onlab.us3b087132015-03-11 15:00:08 -07001928 #connect to first device on the next node
Jon Hall4ba53f02015-07-29 13:07:41 -07001929 line = ("\t" + str(lastSwitch) + ":6 -> 0:5:" + ONOSIpList[node+1] + "\n")
andrew@onlab.us3b087132015-03-11 15:00:08 -07001930 linkGraph.write(line)
Jon Hall4ba53f02015-07-29 13:07:41 -07001931
andrew@onlab.us3b087132015-03-11 15:00:08 -07001932 linkGraph.write("}\n")
1933 linkGraph.close()
1934
1935 #SCP
Jon Hall4ba53f02015-07-29 13:07:41 -07001936 os.system( "scp " + tempFile + " " + self.user_name + "@" + benchIp + ":" + linkGraphPath)
andrew@onlab.us3b087132015-03-11 15:00:08 -07001937 main.log.info("linkGraph.cfg creation complete")
1938
cameron@onlab.us75900962015-03-30 13:22:49 -07001939 def configNullDev( self, ONOSIpList, deviceCount, numPorts=10):
Jon Hall4ba53f02015-07-29 13:07:41 -07001940
andrew@onlab.us3b087132015-03-11 15:00:08 -07001941 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07001942 ONOSIpList = list of Ip addresses of nodes switches will be devided amongst
1943 deviceCount = number of switches to distribute, or list of values to use as custom distribution
cameron@onlab.us75900962015-03-30 13:22:49 -07001944 numPorts = number of ports per device. Defaults to 10 both in this function and in ONOS. Optional arg
andrew@onlab.us3b087132015-03-11 15:00:08 -07001945 '''
1946
cameron@onlab.us75900962015-03-30 13:22:49 -07001947 main.log.step("Configuring Null Device Provider" )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001948 clusterCount = len(ONOSIpList)
1949
Jon Hall4ba53f02015-07-29 13:07:41 -07001950 try:
1951
cameron@onlab.us75900962015-03-30 13:22:49 -07001952 if type(deviceCount) is int or type(deviceCount) is str:
1953 main.log.step("Creating device distribution")
1954 deviceCount = int(deviceCount)
1955 switchList = [0]*(clusterCount+1)
1956 baselineSwitchCount = deviceCount/clusterCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001957
cameron@onlab.us75900962015-03-30 13:22:49 -07001958 for node in range(1, clusterCount + 1):
1959 switchList[node] = baselineSwitchCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001960
cameron@onlab.us75900962015-03-30 13:22:49 -07001961 for node in range(1, (deviceCount%clusterCount)+1):
1962 switchList[node] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001963
1964 if type(deviceCount) is list:
1965 main.log.info("Using provided device distribution")
1966
1967 if len(deviceCount) == clusterCount:
cameron@onlab.us75900962015-03-30 13:22:49 -07001968 switchList = ['0']
1969 switchList.extend(deviceCount)
Jon Hall4ba53f02015-07-29 13:07:41 -07001970
1971 if len(deviceCount) == (clusterCount + 1):
1972 if deviceCount[0] == '0' or deviceCount[0] == 0:
cameron@onlab.us75900962015-03-30 13:22:49 -07001973 switchList = deviceCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001974
cameron@onlab.us75900962015-03-30 13:22:49 -07001975 assert len(switchList) == (clusterCount + 1)
Jon Hall4ba53f02015-07-29 13:07:41 -07001976
cameron@onlab.us75900962015-03-30 13:22:49 -07001977 except AssertionError:
Jon Hall4ba53f02015-07-29 13:07:41 -07001978 main.log.error( "Bad device/Ip list match")
cameron@onlab.us75900962015-03-30 13:22:49 -07001979 except TypeError:
1980 main.log.exception( self.name + ": Object not as expected" )
1981 return None
Jon Hall77ba41c2015-04-06 10:25:40 -07001982 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07001983 main.log.exception( self.name + ": Uncaught exception!" )
1984 main.cleanup()
1985 main.exit()
1986
andrew@onlab.us3b087132015-03-11 15:00:08 -07001987
1988 ONOSIp = [0]
1989 ONOSIp.extend(ONOSIpList)
Jon Hall4ba53f02015-07-29 13:07:41 -07001990
andrew@onlab.us3b087132015-03-11 15:00:08 -07001991 devicesString = "devConfigs = "
1992 for node in range(1, len(ONOSIp)):
1993 devicesString += (ONOSIp[node] + ":" + str(switchList[node] ))
1994 if node < clusterCount:
1995 devicesString += (",")
Jon Hall4ba53f02015-07-29 13:07:41 -07001996
1997 try:
cameron@onlab.us75900962015-03-30 13:22:49 -07001998 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider devConfigs " + devicesString )
1999 self.handle.expect(":~")
2000 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider numPorts " + str(numPorts) )
2001 self.handle.expect(":~")
andrew@onlab.us3b087132015-03-11 15:00:08 -07002002
cameron@onlab.us75900962015-03-30 13:22:49 -07002003 for i in range(10):
2004 self.handle.sendline("onos $OC1 cfg get org.onosproject.provider.nil.device.impl.NullDeviceProvider")
2005 self.handle.expect(":~")
2006 verification = self.handle.before
2007 if (" value=" + str(numPorts)) in verification and (" value=" + devicesString) in verification:
2008 break
2009 else:
2010 time.sleep(1)
andrew@onlab.us3b087132015-03-11 15:00:08 -07002011
cameron@onlab.us2cc8bf12015-04-02 14:12:30 -07002012 assert ("value=" + str(numPorts)) in verification and (" value=" + devicesString) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002013
cameron@onlab.us75900962015-03-30 13:22:49 -07002014 except AssertionError:
2015 main.log.error("Incorrect Config settings: " + verification)
Jon Hall77ba41c2015-04-06 10:25:40 -07002016 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002017 main.log.exception( self.name + ": Uncaught exception!" )
2018 main.cleanup()
2019 main.exit()
2020
Jon Hall4ba53f02015-07-29 13:07:41 -07002021 def configNullLink( self,fileName="/opt/onos/apache-karaf-3.0.3/etc/linkGraph.cfg", eventRate=0):
andrew@onlab.us3b087132015-03-11 15:00:08 -07002022 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07002023 fileName default is currently the same as the default on ONOS, specify alternate file if
cameron@onlab.us75900962015-03-30 13:22:49 -07002024 you want to use a different topology file than linkGraph.cfg
andrew@onlab.us3b087132015-03-11 15:00:08 -07002025 '''
2026
Jon Hall4ba53f02015-07-29 13:07:41 -07002027
2028 try:
2029 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider eventRate " + str(eventRate))
2030 self.handle.expect(":~")
cameron@onlab.us75900962015-03-30 13:22:49 -07002031 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider cfgFile " + fileName )
2032 self.handle.expect(":~")
Jon Hall4ba53f02015-07-29 13:07:41 -07002033
2034 for i in range(10):
2035 self.handle.sendline("onos $OC1 cfg get org.onosproject.provider.nil.link.impl.NullLinkProvider")
cameron@onlab.us75900962015-03-30 13:22:49 -07002036 self.handle.expect(":~")
2037 verification = self.handle.before
Jon Hall4ba53f02015-07-29 13:07:41 -07002038 if (" value=" + str(eventRate)) in verification and (" value=" + fileName) in verification:
cameron@onlab.us75900962015-03-30 13:22:49 -07002039 break
Jon Hall4ba53f02015-07-29 13:07:41 -07002040 else:
cameron@onlab.us75900962015-03-30 13:22:49 -07002041 time.sleep(1)
Jon Hall4ba53f02015-07-29 13:07:41 -07002042
cameron@onlab.us75900962015-03-30 13:22:49 -07002043 assert ("value=" + str(eventRate)) in verification and (" value=" + fileName) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002044
cameron@onlab.us75900962015-03-30 13:22:49 -07002045 except pexpect.EOF:
2046 main.log.error( self.name + ": EOF exception found" )
2047 main.log.error( self.name + ": " + self.handle.before )
2048 main.cleanup()
2049 main.exit()
cameron@onlab.us75900962015-03-30 13:22:49 -07002050 except AssertionError:
2051 main.log.info("Settings did not post to ONOS")
Jon Hall4ba53f02015-07-29 13:07:41 -07002052 main.log.error(varification)
Jon Hall77ba41c2015-04-06 10:25:40 -07002053 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002054 main.log.exception( self.name + ": Uncaught exception!" )
2055 main.log.error(varification)
2056 main.cleanup()
2057 main.exit()
andrew@onlab.us3b087132015-03-11 15:00:08 -07002058
kelvin-onlaba4074292015-07-09 15:19:49 -07002059 def getOnosIps( self ):
2060 """
2061 Get all onos IPs stored in
2062 """
cameron@onlab.us59d29d92015-05-11 14:31:54 -07002063
kelvin-onlaba4074292015-07-09 15:19:49 -07002064 return sorted( self.onosIps.values() )
cameron@onlab.us59d29d92015-05-11 14:31:54 -07002065
kelvin-onlaba4074292015-07-09 15:19:49 -07002066 def logReport( self, nodeIp, searchTerms, outputMode="s" ):
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002067 '''
2068 - accepts either a list or a string for "searchTerms" these
Jon Hall4ba53f02015-07-29 13:07:41 -07002069 terms will be searched for in the log and have their
2070 instances counted
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002071
Jon Hall4ba53f02015-07-29 13:07:41 -07002072 - nodeIp is the ip of the node whos log is to be scanned
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002073
Jon Hall4ba53f02015-07-29 13:07:41 -07002074 - output modes:
2075 "s" - Simple. Quiet output mode that just prints
2076 the occurences of each search term
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002077
cameron@onlab.us2e166212015-05-19 14:28:25 -07002078 "d" - Detailed. Prints number of occurences as well as the entire
Jon Hall4ba53f02015-07-29 13:07:41 -07002079 line for each of the last 5 occurences
cameron@onlab.us2e166212015-05-19 14:28:25 -07002080
2081 - returns total of the number of instances of all search terms
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002082 '''
2083 main.log.info("========================== Log Report ===========================\n")
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002084
Jon Hall4ba53f02015-07-29 13:07:41 -07002085 if type(searchTerms) is str:
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002086 searchTerms = [searchTerms]
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002087
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002088 logLines = [ [" "] for i in range(len(searchTerms)) ]
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002089
Jon Hall4ba53f02015-07-29 13:07:41 -07002090 for term in range(len(searchTerms)):
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002091 logLines[term][0] = searchTerms[term]
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002092
Jon Hall4ba53f02015-07-29 13:07:41 -07002093 totalHits = 0
2094 for term in range(len(searchTerms)):
2095 cmd = "onos-ssh " + nodeIp + " cat /opt/onos/log/karaf.log | grep " + searchTerms[term]
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002096 self.handle.sendline(cmd)
2097 self.handle.expect(":~")
2098 before = (self.handle.before).splitlines()
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002099
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002100 count = [searchTerms[term],0]
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002101
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002102 for line in before:
2103 if searchTerms[term] in line and "grep" not in line:
Jon Hall4ba53f02015-07-29 13:07:41 -07002104 count[1] += 1
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002105 if before.index(line) > ( len(before) - 7 ):
2106 logLines[term].append(line)
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002107
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002108 main.log.info( str(count[0]) + ": " + str(count[1]) )
Jon Hall4ba53f02015-07-29 13:07:41 -07002109 if term == len(searchTerms)-1:
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002110 print("\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07002111 totalHits += int(count[1])
cameron@onlab.us2e166212015-05-19 14:28:25 -07002112
Jon Hall4ba53f02015-07-29 13:07:41 -07002113 if outputMode != "s" and outputMode != "S":
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002114 outputString = ""
2115 for i in logLines:
Jon Hall4ba53f02015-07-29 13:07:41 -07002116 outputString = i[0] + ": \n"
2117 for x in range(1,len(i)):
2118 outputString += ( i[x] + "\n" )
2119
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002120 if outputString != (i[0] + ": \n"):
Jon Hall4ba53f02015-07-29 13:07:41 -07002121 main.log.info(outputString)
2122
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002123 main.log.info("================================================================\n")
Hari Krishnabe4b97b2015-07-15 12:19:43 -07002124 return totalHits
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002125
2126 def copyMininetFile( self, fileName, localPath, userName, ip,
2127 mnPath='~/mininet/custom/', timeout = 60 ):
2128 """
2129 Description:
2130 Copy mininet topology file from dependency folder in the test folder
2131 and paste it to the mininet machine's mininet/custom folder
2132 Required:
2133 fileName - Name of the topology file to copy
2134 localPath - File path of the mininet topology file
2135 userName - User name of the mininet machine to send the file to
2136 ip - Ip address of the mininet machine
2137 Optional:
2138 mnPath - of the mininet directory to send the file to
2139 Return:
2140 Return main.TRUE if successfully copied the file otherwise
2141 return main.FALSE
2142 """
2143
2144 try:
2145 cmd = "scp " + localPath + fileName + " " + userName + "@" + \
2146 str( ip ) + ":" + mnPath + fileName
2147
2148 self.handle.sendline( "" )
2149 self.handle.expect( "\$" )
2150
2151 main.log.info( self.name + ": Execute: " + cmd )
2152
2153 self.handle.sendline( cmd )
2154
2155 i = self.handle.expect( [ 'No such file',
2156 "100%",
2157 pexpect.TIMEOUT ] )
2158
2159 if i == 0:
2160 main.log.error( self.name + ": File " + fileName +
2161 " does not exist!" )
2162 return main.FALSE
2163
2164 if i == 1:
2165 main.log.info( self.name + ": File " + fileName +
2166 " has been copied!" )
2167 self.handle.sendline( "" )
2168 self.handle.expect( "\$" )
2169 return main.TRUE
2170
2171 except pexpect.EOF:
2172 main.log.error( self.name + ": EOF exception found" )
2173 main.log.error( self.name + ": " + self.handle.before )
2174 main.cleanup()
2175 main.exit()
2176 except pexpect.TIMEOUT:
2177 main.log.error( self.name + ": TIMEOUT exception found" )
2178 main.log.error( self.name + ": " + self.handle.before )
2179 main.cleanup()
2180 main.exit()
cameron@onlab.us78b89652015-07-08 15:21:03 -07002181
2182 def jvmSet(self, memory=8):
Jon Hall4ba53f02015-07-29 13:07:41 -07002183
cameron@onlab.us78b89652015-07-08 15:21:03 -07002184 import os
2185
2186 homeDir = os.path.expanduser('~')
2187 filename = "/onos/tools/package/bin/onos-service"
2188
2189 serviceConfig = open(homeDir + filename, 'w+')
2190 serviceConfig.write("#!/bin/bash\n ")
2191 serviceConfig.write("#------------------------------------- \n ")
2192 serviceConfig.write("# Starts ONOS Apache Karaf container\n ")
2193 serviceConfig.write("#------------------------------------- \n ")
2194 serviceConfig.write("#export JAVA_HOME=${JAVA_HOME:-/usr/lib/jvm/java-7-openjdk-amd64/}\n ")
2195 serviceConfig.write("""export JAVA_OPTS="${JAVA_OPTS:--Xms""" + str(memory) + "G -Xmx" + str(memory) + """G}" \n """)
2196 serviceConfig.write("[ -d $ONOS_HOME ] && cd $ONOS_HOME || ONOS_HOME=$(dirname $0)/..\n")
2197 serviceConfig.write("""${ONOS_HOME}/apache-karaf-$KARAF_VERSION/bin/karaf "$@" \n """)
2198 serviceConfig.close()
2199
2200 def createDBFile(self, testData):
Jon Hall4ba53f02015-07-29 13:07:41 -07002201
cameron@onlab.us78b89652015-07-08 15:21:03 -07002202 filename = main.TEST + "DB"
2203 DBString = ""
Jon Hall4ba53f02015-07-29 13:07:41 -07002204
cameron@onlab.us78b89652015-07-08 15:21:03 -07002205 for item in testData:
Jon Hall4ba53f02015-07-29 13:07:41 -07002206 if type(item) is string:
cameron@onlab.us78b89652015-07-08 15:21:03 -07002207 item = "'" + item + "'"
2208 if testData.index(item) < len(testData-1):
2209 item += ","
Jon Hall4ba53f02015-07-29 13:07:41 -07002210 DBString += str(item)
cameron@onlab.us78b89652015-07-08 15:21:03 -07002211
2212 DBFile = open(filename, "a")
2213 DBFile.write(DBString)
2214 DBFile.close()
2215
Jon Hall4ba53f02015-07-29 13:07:41 -07002216 def verifySummary(self, ONOSIp,*deviceCount):
cameron@onlab.us78b89652015-07-08 15:21:03 -07002217
2218 self.handle.sendline("onos " + ONOSIp + " summary")
2219 self.handle.expect(":~")
2220
2221 summaryStr = self.handle.before
2222 print "\nSummary\n==============\n" + summaryStr + "\n\n"
2223
2224 #passed = "SCC(s)=1" in summaryStr
2225 #if deviceCount:
2226 # passed = "devices=" + str(deviceCount) + "," not in summaryStr
2227
GlennRC772363b2015-08-25 13:05:57 -07002228 passed = False
cameron@onlab.us78b89652015-07-08 15:21:03 -07002229 if "SCC(s)=1," in summaryStr:
2230 passed = True
2231 print("Summary is verifed")
Jon Hall4ba53f02015-07-29 13:07:41 -07002232 else:
2233 print("Summary failed")
cameron@onlab.us78b89652015-07-08 15:21:03 -07002234
2235 if deviceCount:
2236 print" ============================="
2237 checkStr = "devices=" + str(deviceCount[0]) + ","
2238 print "Checkstr: " + checkStr
2239 if checkStr not in summaryStr:
2240 passed = False
Jon Hall4ba53f02015-07-29 13:07:41 -07002241 print("Device count failed")
2242 else:
2243 print "device count verified"
cameron@onlab.us78b89652015-07-08 15:21:03 -07002244
2245 return passed