blob: b6965d3dd639a66651016ad145349ef7b8024472 [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 ) +
711 "=" + "\"" + arg + "\"" + "\n" )
712 tempCount = tempCount + 1
kelvin8ec71442015-01-15 16:57:00 -0800713
kelvin-onlabd3b64892015-01-20 13:26:24 -0800714 cellFile.write( mnString + "\"" + mnIpAddrs + "\"" + "\n" )
cameron@onlab.us75900962015-03-30 13:22:49 -0700715 cellFile.write( appString + "\n" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800716 cellFile.close()
andrewonlab94282092014-10-10 13:00:11 -0400717
kelvin8ec71442015-01-15 16:57:00 -0800718 # We use os.system to send the command to TestON cluster
719 # to account for the case in which TestON is not located
720 # on the same cluster as the ONOS bench
721 # Note that even if TestON is located on the same cluster
722 # as ONOS bench, you must setup passwordless ssh
723 # between TestON and ONOS bench in order to automate the test.
kelvin-onlabc2b79102015-07-14 11:41:20 -0700724 os.system( "scp " + tempDirectory + fileName + " " +
725 self.user_name + "@" + self.ip_address + ":" + cellDirectory )
andrewonlab94282092014-10-10 13:00:11 -0400726
andrewonlab2a6c9342014-10-16 13:40:15 -0400727 return main.TRUE
728
andrewonlab94282092014-10-10 13:00:11 -0400729 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800730 main.log.error( self.name + ": EOF exception found" )
731 main.log.error( self.name + ": " + self.handle.before )
andrewonlab94282092014-10-10 13:00:11 -0400732 main.cleanup()
733 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800734 except Exception:
735 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab94282092014-10-10 13:00:11 -0400736 main.cleanup()
737 main.exit()
738
kelvin-onlabd3b64892015-01-20 13:26:24 -0800739 def setCell( self, cellname ):
kelvin8ec71442015-01-15 16:57:00 -0800740 """
andrewonlab95ca1462014-10-09 14:04:24 -0400741 Calls 'cell <name>' to set the environment variables on ONOSbench
kelvin8ec71442015-01-15 16:57:00 -0800742 """
Hari Krishna03f530e2015-07-10 17:28:27 -0700743 import re
andrewonlab95ca1462014-10-09 14:04:24 -0400744 try:
745 if not cellname:
kelvin8ec71442015-01-15 16:57:00 -0800746 main.log.error( "Must define cellname" )
andrewonlab95ca1462014-10-09 14:04:24 -0400747 main.cleanup()
748 main.exit()
749 else:
kelvin8ec71442015-01-15 16:57:00 -0800750 self.handle.sendline( "cell " + str( cellname ) )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800751 # Expect the cellname in the ONOSCELL variable.
kelvin8ec71442015-01-15 16:57:00 -0800752 # Note that this variable name is subject to change
andrewonlab95ca1462014-10-09 14:04:24 -0400753 # and that this driver will have to change accordingly
Cameron Franke9c94fb02015-01-21 10:20:20 -0800754 self.handle.expect(str(cellname))
kelvin-onlabd3b64892015-01-20 13:26:24 -0800755 handleBefore = self.handle.before
756 handleAfter = self.handle.after
kelvin8ec71442015-01-15 16:57:00 -0800757 # Get the rest of the handle
Cameron Franke9c94fb02015-01-21 10:20:20 -0800758 self.handle.sendline("")
759 self.handle.expect("\$")
kelvin-onlabd3b64892015-01-20 13:26:24 -0800760 handleMore = self.handle.before
andrewonlab95ca1462014-10-09 14:04:24 -0400761
Hari Krishna03f530e2015-07-10 17:28:27 -0700762 cell_result = handleBefore + handleAfter + handleMore
763 print cell_result
764 if( re.search( "No such cell", cell_result ) ):
765 main.log.error( "Cell call returned: " + handleBefore +
kelvin-onlabd3b64892015-01-20 13:26:24 -0800766 handleAfter + handleMore )
Hari Krishna03f530e2015-07-10 17:28:27 -0700767 main.cleanup()
768 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -0400769 return main.TRUE
770
771 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800772 main.log.error( self.name + ": EOF exception found" )
773 main.log.error( self.name + ": " + self.handle.before )
andrewonlab95ca1462014-10-09 14:04:24 -0400774 main.cleanup()
775 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800776 except Exception:
777 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ca1462014-10-09 14:04:24 -0400778 main.cleanup()
779 main.exit()
780
kelvin-onlabd3b64892015-01-20 13:26:24 -0800781 def verifyCell( self ):
kelvin8ec71442015-01-15 16:57:00 -0800782 """
andrewonlabc03bf6c2014-10-09 14:56:18 -0400783 Calls 'onos-verify-cell' to check for cell installation
kelvin8ec71442015-01-15 16:57:00 -0800784 """
785 # TODO: Add meaningful expect value
andrewonlab8d0d7d72014-10-09 16:33:15 -0400786
andrewonlabc03bf6c2014-10-09 14:56:18 -0400787 try:
kelvin8ec71442015-01-15 16:57:00 -0800788 # Clean handle by sending empty and expecting $
789 self.handle.sendline( "" )
790 self.handle.expect( "\$" )
791 self.handle.sendline( "onos-verify-cell" )
792 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800793 handleBefore = self.handle.before
794 handleAfter = self.handle.after
kelvin8ec71442015-01-15 16:57:00 -0800795 # Get the rest of the handle
796 self.handle.sendline( "" )
797 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800798 handleMore = self.handle.before
andrewonlabc03bf6c2014-10-09 14:56:18 -0400799
kelvin-onlabd3b64892015-01-20 13:26:24 -0800800 main.log.info( "Verify cell returned: " + handleBefore +
801 handleAfter + handleMore )
andrewonlabc03bf6c2014-10-09 14:56:18 -0400802
803 return main.TRUE
Jon Halla5cb6172015-02-23 09:28:28 -0800804 except pexpect.ExceptionPexpect as e:
805 main.log.error( self.name + ": Pexpect exception found of type " +
806 str( type( e ) ) )
807 main.log.error ( e.get_trace() )
kelvin8ec71442015-01-15 16:57:00 -0800808 main.log.error( self.name + ": " + self.handle.before )
Jon Hall7993bfc2014-10-09 16:30:14 -0400809 main.cleanup()
810 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800811 except Exception:
812 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall7993bfc2014-10-09 16:30:14 -0400813 main.cleanup()
814 main.exit()
815
jenkins1e99e7b2015-04-02 18:15:39 -0700816 def onosCfgSet( self, ONOSIp, configName, configParam ):
817 """
818 Uses 'onos <node-ip> cfg set' to change a parameter value of an
Jon Hall4ba53f02015-07-29 13:07:41 -0700819 application.
820
jenkins1e99e7b2015-04-02 18:15:39 -0700821 ex)
822 onos 10.0.0.1 cfg set org.onosproject.myapp appSetting 1
jenkins1e99e7b2015-04-02 18:15:39 -0700823 ONOSIp = '10.0.0.1'
824 configName = 'org.onosproject.myapp'
825 configParam = 'appSetting 1'
jenkins1e99e7b2015-04-02 18:15:39 -0700826 """
cameron@onlab.us78b89652015-07-08 15:21:03 -0700827 for i in range(5):
828 try:
829 cfgStr = ( "onos "+str(ONOSIp)+" cfg set "+
830 str(configName) + " " +
831 str(configParam)
832 )
jenkins1e99e7b2015-04-02 18:15:39 -0700833
cameron@onlab.us78b89652015-07-08 15:21:03 -0700834 self.handle.sendline( "" )
835 self.handle.expect( ":~" )
836 self.handle.sendline( cfgStr )
Jon Hall4ba53f02015-07-29 13:07:41 -0700837 self.handle.expect("cfg set")
cameron@onlab.us78b89652015-07-08 15:21:03 -0700838 self.handle.expect( ":~" )
Jon Hall4ba53f02015-07-29 13:07:41 -0700839
cameron@onlab.us78b89652015-07-08 15:21:03 -0700840 paramValue = configParam.split(" ")[1]
841 paramName = configParam.split(" ")[0]
Jon Hall4ba53f02015-07-29 13:07:41 -0700842
cameron@onlab.us78b89652015-07-08 15:21:03 -0700843 checkStr = ( "onos " + str(ONOSIp) + """ cfg get " """ + str(configName) + " " + paramName + """ " """)
jenkins1e99e7b2015-04-02 18:15:39 -0700844
cameron@onlab.us78b89652015-07-08 15:21:03 -0700845 self.handle.sendline( checkStr )
846 self.handle.expect( ":~" )
jenkins1e99e7b2015-04-02 18:15:39 -0700847
cameron@onlab.us78b89652015-07-08 15:21:03 -0700848 if "value=" + paramValue + "," in self.handle.before:
Jon Hall4ba53f02015-07-29 13:07:41 -0700849 main.log.info("cfg " + configName + " successfully set to " + configParam)
cameron@onlab.us78b89652015-07-08 15:21:03 -0700850 return main.TRUE
851
852 except pexpect.ExceptionPexpect as e:
853 main.log.error( self.name + ": Pexpect exception found of type " +
854 str( type( e ) ) )
855 main.log.error ( e.get_trace() )
856 main.log.error( self.name + ": " + self.handle.before )
857 main.cleanup()
858 main.exit()
859 except Exception:
860 main.log.exception( self.name + ": Uncaught exception!" )
861 main.cleanup()
862 main.exit()
Jon Hall4ba53f02015-07-29 13:07:41 -0700863
cameron@onlab.us78b89652015-07-08 15:21:03 -0700864 time.sleep(5)
865
866 main.log.error("CFG SET FAILURE: " + configName + " " + configParam )
Jon Hall4ba53f02015-07-29 13:07:41 -0700867 main.ONOSbench.handle.sendline("onos $OC1 cfg get")
cameron@onlab.us78b89652015-07-08 15:21:03 -0700868 main.ONOSbench.handle.expect("\$")
869 print main.ONOSbench.handle.before
870 main.ONOSbench.logReport( ONOSIp, ["ERROR","WARN","EXCEPT"], "d")
871 return main.FALSE
872
Jon Hall4ba53f02015-07-29 13:07:41 -0700873
kelvin-onlabd3b64892015-01-20 13:26:24 -0800874 def onosCli( self, ONOSIp, cmdstr ):
kelvin8ec71442015-01-15 16:57:00 -0800875 """
andrewonlab05e362f2014-10-10 00:40:57 -0400876 Uses 'onos' command to send various ONOS CLI arguments.
877 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800878 * ONOSIp: specify the ip of the cell machine
andrewonlab94282092014-10-10 13:00:11 -0400879 * cmdstr: specify the command string to send
kelvin8ec71442015-01-15 16:57:00 -0800880
881 This function is intended to expose the entire karaf
andrewonlab6e20c342014-10-10 18:08:48 -0400882 CLI commands for ONOS. Try to use this function first
883 before attempting to write a ONOS CLI specific driver
kelvin8ec71442015-01-15 16:57:00 -0800884 function.
885 You can see a list of available 'cmdstr' arguments
andrewonlab6e20c342014-10-10 18:08:48 -0400886 by starting onos, and typing in 'onos' to enter the
887 onos> CLI. Then, type 'help' to see the list of
kelvin8ec71442015-01-15 16:57:00 -0800888 available commands.
889 """
andrewonlab05e362f2014-10-10 00:40:57 -0400890 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800891 if not ONOSIp:
kelvin8ec71442015-01-15 16:57:00 -0800892 main.log.error( "You must specify the IP address" )
andrewonlab05e362f2014-10-10 00:40:57 -0400893 return main.FALSE
894 if not cmdstr:
kelvin8ec71442015-01-15 16:57:00 -0800895 main.log.error( "You must specify the command string" )
andrewonlab05e362f2014-10-10 00:40:57 -0400896 return main.FALSE
897
kelvin8ec71442015-01-15 16:57:00 -0800898 cmdstr = str( cmdstr )
899 self.handle.sendline( "" )
900 self.handle.expect( "\$" )
andrewonlab05e362f2014-10-10 00:40:57 -0400901
kelvin-onlabd3b64892015-01-20 13:26:24 -0800902 self.handle.sendline( "onos -w " + ONOSIp + " " + cmdstr )
kelvin8ec71442015-01-15 16:57:00 -0800903 self.handle.expect( "\$" )
andrewonlab05e362f2014-10-10 00:40:57 -0400904
kelvin-onlabd3b64892015-01-20 13:26:24 -0800905 handleBefore = self.handle.before
Shreya Shaha73aaad2014-10-27 18:03:09 -0400906 print "handle_before = ", self.handle.before
kelvin-onlabd3b64892015-01-20 13:26:24 -0800907 # handleAfter = str( self.handle.after )
Jon Hall47a93fb2015-01-06 16:46:06 -0800908
kelvin8ec71442015-01-15 16:57:00 -0800909 # self.handle.sendline( "" )
910 # self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800911 # handleMore = str( self.handle.before )
andrewonlab05e362f2014-10-10 00:40:57 -0400912
kelvin8ec71442015-01-15 16:57:00 -0800913 main.log.info( "Command sent successfully" )
andrewonlab05e362f2014-10-10 00:40:57 -0400914
kelvin8ec71442015-01-15 16:57:00 -0800915 # Obtain return handle that consists of result from
916 # the onos command. The string may need to be
917 # configured further.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800918 # returnString = handleBefore + handleAfter
919 returnString = handleBefore
920 print "return_string = ", returnString
921 return returnString
andrewonlab05e362f2014-10-10 00:40:57 -0400922
923 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800924 main.log.error( self.name + ": EOF exception found" )
925 main.log.error( self.name + ": " + self.handle.before )
andrewonlab05e362f2014-10-10 00:40:57 -0400926 main.cleanup()
927 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800928 except Exception:
929 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab05e362f2014-10-10 00:40:57 -0400930 main.cleanup()
931 main.exit()
Jon Hall7993bfc2014-10-09 16:30:14 -0400932
kelvin-onlabd3b64892015-01-20 13:26:24 -0800933 def onosInstall( self, options="-f", node="" ):
kelvin8ec71442015-01-15 16:57:00 -0800934 """
Jon Hall7993bfc2014-10-09 16:30:14 -0400935 Installs ONOS bits on the designated cell machine.
kelvin8ec71442015-01-15 16:57:00 -0800936 If -f option is provided, it also forces an uninstall.
937 Presently, install also includes onos-push-bits and
Jon Hall7993bfc2014-10-09 16:30:14 -0400938 onos-config within.
kelvin8ec71442015-01-15 16:57:00 -0800939 The node option allows you to selectively only push the jar
Jon Hall7993bfc2014-10-09 16:30:14 -0400940 files to certain onos nodes
941
942 Returns: main.TRUE on success and main.FALSE on failure
kelvin8ec71442015-01-15 16:57:00 -0800943 """
Jon Hall7993bfc2014-10-09 16:30:14 -0400944 try:
andrewonlab114768a2014-11-14 12:44:44 -0500945 if options:
kelvin8ec71442015-01-15 16:57:00 -0800946 self.handle.sendline( "onos-install " + options + " " + node )
andrewonlab114768a2014-11-14 12:44:44 -0500947 else:
kelvin8ec71442015-01-15 16:57:00 -0800948 self.handle.sendline( "onos-install " + node )
949 self.handle.expect( "onos-install " )
950 # NOTE: this timeout may need to change depending on the network
951 # and size of ONOS
952 i = self.handle.expect( [ "Network\sis\sunreachable",
kelvin-onlabd3b64892015-01-20 13:26:24 -0800953 "onos\sstart/running,\sprocess",
kelvin8ec71442015-01-15 16:57:00 -0800954 "ONOS\sis\salready\sinstalled",
955 pexpect.TIMEOUT ], timeout=60 )
Jon Hall7993bfc2014-10-09 16:30:14 -0400956
Jon Hall7993bfc2014-10-09 16:30:14 -0400957 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -0800958 main.log.warn( "Network is unreachable" )
Jon Hall7993bfc2014-10-09 16:30:14 -0400959 return main.FALSE
960 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -0800961 main.log.info(
962 "ONOS was installed on " +
963 node +
964 " and started" )
Jon Hall7993bfc2014-10-09 16:30:14 -0400965 return main.TRUE
andrewonlabd9a73a72014-11-14 17:28:21 -0500966 elif i == 2:
kelvin8ec71442015-01-15 16:57:00 -0800967 main.log.info( "ONOS is already installed on " + node )
andrewonlabd9a73a72014-11-14 17:28:21 -0500968 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800969 elif i == 3:
970 main.log.info(
971 "Installation of ONOS on " +
972 node +
973 " timed out" )
Jon Hall7993bfc2014-10-09 16:30:14 -0400974 return main.FALSE
andrewonlabc03bf6c2014-10-09 14:56:18 -0400975
976 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800977 main.log.error( self.name + ": EOF exception found" )
978 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc03bf6c2014-10-09 14:56:18 -0400979 main.cleanup()
980 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800981 except Exception:
982 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc03bf6c2014-10-09 14:56:18 -0400983 main.cleanup()
984 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -0400985
kelvin-onlabd3b64892015-01-20 13:26:24 -0800986 def onosStart( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -0800987 """
andrewonlab8d0d7d72014-10-09 16:33:15 -0400988 Calls onos command: 'onos-service [<node-ip>] start'
andrewonlabe8e56fd2014-10-09 17:12:44 -0400989 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -0800990 """
andrewonlab8d0d7d72014-10-09 16:33:15 -0400991 try:
kelvin8ec71442015-01-15 16:57:00 -0800992 self.handle.sendline( "" )
993 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800994 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -0800995 " start" )
996 i = self.handle.expect( [
andrewonlab8d0d7d72014-10-09 16:33:15 -0400997 "Job\sis\salready\srunning",
998 "start/running",
999 "Unknown\sinstance",
kelvin8ec71442015-01-15 16:57:00 -08001000 pexpect.TIMEOUT ], timeout=120 )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001001
1002 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001003 main.log.info( "Service is already running" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001004 return main.TRUE
1005 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001006 main.log.info( "ONOS service started" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001007 return main.TRUE
1008 else:
kelvin8ec71442015-01-15 16:57:00 -08001009 main.log.error( "ONOS service failed to start" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001010 main.cleanup()
1011 main.exit()
andrewonlab8d0d7d72014-10-09 16:33:15 -04001012 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001013 main.log.error( self.name + ": EOF exception found" )
1014 main.log.error( self.name + ": " + self.handle.before )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001015 main.cleanup()
1016 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001017 except Exception:
1018 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001019 main.cleanup()
1020 main.exit()
1021
kelvin-onlabd3b64892015-01-20 13:26:24 -08001022 def onosStop( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001023 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001024 Calls onos command: 'onos-service [<node-ip>] stop'
andrewonlabe8e56fd2014-10-09 17:12:44 -04001025 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -08001026 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001027 try:
kelvin8ec71442015-01-15 16:57:00 -08001028 self.handle.sendline( "" )
1029 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001030 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001031 " stop" )
1032 i = self.handle.expect( [
andrewonlab2b30bd32014-10-09 16:48:55 -04001033 "stop/waiting",
Jon Hall61282e32015-03-19 11:34:11 -07001034 "Could not resolve hostname",
andrewonlab2b30bd32014-10-09 16:48:55 -04001035 "Unknown\sinstance",
kelvin8ec71442015-01-15 16:57:00 -08001036 pexpect.TIMEOUT ], timeout=60 )
andrewonlab2b30bd32014-10-09 16:48:55 -04001037
1038 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001039 main.log.info( "ONOS service stopped" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001040 return main.TRUE
1041 elif i == 1:
Jon Hall65844a32015-03-09 19:09:37 -07001042 main.log.info( "onosStop() Unknown ONOS instance specified: " +
kelvin-onlabd3b64892015-01-20 13:26:24 -08001043 str( nodeIp ) )
andrewonlab2b30bd32014-10-09 16:48:55 -04001044 return main.FALSE
Jon Hall61282e32015-03-19 11:34:11 -07001045 elif i == 2:
1046 main.log.warn( "ONOS wasn't running" )
1047 return main.TRUE
andrewonlab2b30bd32014-10-09 16:48:55 -04001048 else:
kelvin8ec71442015-01-15 16:57:00 -08001049 main.log.error( "ONOS service failed to stop" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001050 return main.FALSE
1051
1052 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001053 main.log.error( self.name + ": EOF exception found" )
1054 main.log.error( self.name + ": " + self.handle.before )
andrewonlab2b30bd32014-10-09 16:48:55 -04001055 main.cleanup()
1056 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001057 except Exception:
1058 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001059 main.cleanup()
1060 main.exit()
kelvin8ec71442015-01-15 16:57:00 -08001061
kelvin-onlabd3b64892015-01-20 13:26:24 -08001062 def onosUninstall( self, nodeIp="" ):
kelvin8ec71442015-01-15 16:57:00 -08001063 """
andrewonlabc8d47972014-10-09 16:52:36 -04001064 Calls the command: 'onos-uninstall'
kelvin8ec71442015-01-15 16:57:00 -08001065 Uninstalls ONOS from the designated cell machine, stopping
andrewonlabe8e56fd2014-10-09 17:12:44 -04001066 if needed
kelvin8ec71442015-01-15 16:57:00 -08001067 """
andrewonlabc8d47972014-10-09 16:52:36 -04001068 try:
kelvin8ec71442015-01-15 16:57:00 -08001069 self.handle.sendline( "" )
pingping-lin763ee042015-05-20 17:45:30 -07001070 self.handle.expect( "\$", timeout=60 )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001071 self.handle.sendline( "onos-uninstall " + str( nodeIp ) )
kelvin8ec71442015-01-15 16:57:00 -08001072 self.handle.expect( "\$" )
andrewonlabc8d47972014-10-09 16:52:36 -04001073
kelvin-onlabd3b64892015-01-20 13:26:24 -08001074 main.log.info( "ONOS " + nodeIp + " was uninstalled" )
andrewonlab9dfd2082014-11-13 17:44:03 -05001075
kelvin8ec71442015-01-15 16:57:00 -08001076 # onos-uninstall command does not return any text
andrewonlabc8d47972014-10-09 16:52:36 -04001077 return main.TRUE
1078
pingping-lin763ee042015-05-20 17:45:30 -07001079 except pexpect.TIMEOUT:
1080 main.log.exception( self.name + ": Timeout in onosUninstall" )
1081 return main.FALSE
andrewonlabc8d47972014-10-09 16:52:36 -04001082 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001083 main.log.error( self.name + ": EOF exception found" )
1084 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc8d47972014-10-09 16:52:36 -04001085 main.cleanup()
1086 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001087 except Exception:
1088 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc8d47972014-10-09 16:52:36 -04001089 main.cleanup()
1090 main.exit()
andrewonlab2b30bd32014-10-09 16:48:55 -04001091
kelvin-onlabd3b64892015-01-20 13:26:24 -08001092 def onosDie( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001093 """
andrewonlabaedc8332014-12-04 12:43:03 -05001094 Issues the command 'onos-die <node-ip>'
1095 This command calls onos-kill and also stops the node
kelvin8ec71442015-01-15 16:57:00 -08001096 """
andrewonlabaedc8332014-12-04 12:43:03 -05001097 try:
kelvin8ec71442015-01-15 16:57:00 -08001098 self.handle.sendline( "" )
1099 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001100 cmdStr = "onos-kill " + str( nodeIp )
1101 self.handle.sendline( cmdStr )
kelvin8ec71442015-01-15 16:57:00 -08001102 i = self.handle.expect( [
andrewonlabaedc8332014-12-04 12:43:03 -05001103 "Killing\sONOS",
1104 "ONOS\sprocess\sis\snot\srunning",
kelvin8ec71442015-01-15 16:57:00 -08001105 pexpect.TIMEOUT ], timeout=20 )
andrewonlabaedc8332014-12-04 12:43:03 -05001106 if i == 0:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001107 main.log.info( "ONOS instance " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001108 " was killed and stopped" )
andrewonlabaedc8332014-12-04 12:43:03 -05001109 return main.TRUE
1110 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001111 main.log.info( "ONOS process was not running" )
andrewonlabaedc8332014-12-04 12:43:03 -05001112 return main.FALSE
1113 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001114 main.log.error( self.name + ": EOF exception found" )
1115 main.log.error( self.name + ": " + self.handle.before )
andrewonlabaedc8332014-12-04 12:43:03 -05001116 main.cleanup()
1117 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001118 except Exception:
1119 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabaedc8332014-12-04 12:43:03 -05001120 main.cleanup()
1121 main.exit()
1122
kelvin-onlabd3b64892015-01-20 13:26:24 -08001123 def onosKill( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001124 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001125 Calls the command: 'onos-kill [<node-ip>]'
1126 "Remotely, and unceremoniously kills the ONOS instance running on
1127 the specified cell machine" - Tom V
kelvin8ec71442015-01-15 16:57:00 -08001128 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001129 try:
kelvin8ec71442015-01-15 16:57:00 -08001130 self.handle.sendline( "" )
1131 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001132 self.handle.sendline( "onos-kill " + str( nodeIp ) )
kelvin8ec71442015-01-15 16:57:00 -08001133 i = self.handle.expect( [
andrewonlabe8e56fd2014-10-09 17:12:44 -04001134 "\$",
1135 "No\sroute\sto\shost",
1136 "password:",
kelvin8ec71442015-01-15 16:57:00 -08001137 pexpect.TIMEOUT ], timeout=20 )
1138
andrewonlabe8e56fd2014-10-09 17:12:44 -04001139 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001140 main.log.info(
1141 "ONOS instance " + str(
kelvin-onlabd3b64892015-01-20 13:26:24 -08001142 nodeIp ) + " was killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001143 return main.TRUE
1144 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001145 main.log.info( "No route to host" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001146 return main.FALSE
1147 elif i == 2:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001148 main.log.info(
1149 "Passwordless login for host: " +
1150 str( nodeIp ) +
1151 " not configured" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001152 return main.FALSE
1153 else:
Jon Hallefbd9792015-03-05 16:11:36 -08001154 main.log.info( "ONOS instance was not killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001155 return main.FALSE
kelvin8ec71442015-01-15 16:57:00 -08001156
andrewonlabe8e56fd2014-10-09 17:12:44 -04001157 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001158 main.log.error( self.name + ": EOF exception found" )
1159 main.log.error( self.name + ": " + self.handle.before )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001160 main.cleanup()
1161 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001162 except Exception:
1163 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001164 main.cleanup()
1165 main.exit()
1166
kelvin-onlabd3b64892015-01-20 13:26:24 -08001167 def onosRemoveRaftLogs( self ):
kelvin8ec71442015-01-15 16:57:00 -08001168 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001169 Removes Raft / Copy cat files from ONOS to ensure
Jon Hallfcc88622014-11-25 13:09:54 -05001170 a cleaner environment.
1171
andrewonlab19fbdca2014-11-14 12:55:59 -05001172 Description:
Jon Hallfcc88622014-11-25 13:09:54 -05001173 Stops all ONOS defined in the cell,
andrewonlab19fbdca2014-11-14 12:55:59 -05001174 wipes the raft / copycat log files
kelvin8ec71442015-01-15 16:57:00 -08001175 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001176 try:
kelvin8ec71442015-01-15 16:57:00 -08001177 self.handle.sendline( "" )
1178 self.handle.expect( "\$" )
1179 self.handle.sendline( "onos-remove-raft-logs" )
1180 # Sometimes this command hangs
1181 i = self.handle.expect( [ "\$", pexpect.TIMEOUT ],
1182 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001183 if i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001184 i = self.handle.expect( [ "\$", pexpect.TIMEOUT ],
1185 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001186 if i == 1:
1187 return main.FALSE
shahshreya957feaa2015-03-23 16:08:29 -07001188 #self.handle.sendline( "" )
1189 #self.handle.expect( "\$" )
andrewonlab19fbdca2014-11-14 12:55:59 -05001190 return main.TRUE
1191
1192 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001193 main.log.error( self.name + ": EOF exception found" )
1194 main.log.error( self.name + ": " + self.handle.before )
andrewonlab19fbdca2014-11-14 12:55:59 -05001195 main.cleanup()
1196 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001197 except Exception:
1198 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab19fbdca2014-11-14 12:55:59 -05001199 main.cleanup()
1200 main.exit()
Jon Hallfcc88622014-11-25 13:09:54 -05001201
kelvin-onlabd3b64892015-01-20 13:26:24 -08001202 def onosStartNetwork( self, mntopo ):
kelvin8ec71442015-01-15 16:57:00 -08001203 """
1204 Calls the command 'onos-start-network [ <mininet-topo> ]
1205 "remotely starts the specified topology on the cell's
andrewonlab94282092014-10-10 13:00:11 -04001206 mininet machine against all controllers configured in the
kelvin8ec71442015-01-15 16:57:00 -08001207 cell."
andrewonlab94282092014-10-10 13:00:11 -04001208 * Specify mininet topology file name for mntopo
1209 * Topo files should be placed at:
1210 ~/<your-onos-directory>/tools/test/topos
kelvin8ec71442015-01-15 16:57:00 -08001211
andrewonlab94282092014-10-10 13:00:11 -04001212 NOTE: This function will take you to the mininet prompt
kelvin8ec71442015-01-15 16:57:00 -08001213 """
andrewonlab94282092014-10-10 13:00:11 -04001214 try:
1215 if not mntopo:
kelvin8ec71442015-01-15 16:57:00 -08001216 main.log.error( "You must specify a topo file to execute" )
andrewonlab94282092014-10-10 13:00:11 -04001217 return main.FALSE
andrewonlab94282092014-10-10 13:00:11 -04001218
kelvin8ec71442015-01-15 16:57:00 -08001219 mntopo = str( mntopo )
1220 self.handle.sendline( "" )
1221 self.handle.expect( "\$" )
andrewonlab94282092014-10-10 13:00:11 -04001222
kelvin8ec71442015-01-15 16:57:00 -08001223 self.handle.sendline( "onos-start-network " + mntopo )
1224 self.handle.expect( "mininet>" )
1225 main.log.info( "Network started, entered mininet prompt" )
1226
1227 # TODO: Think about whether return is necessary or not
andrewonlab94282092014-10-10 13:00:11 -04001228
1229 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001230 main.log.error( self.name + ": EOF exception found" )
1231 main.log.error( self.name + ": " + self.handle.before )
andrewonlab94282092014-10-10 13:00:11 -04001232 main.cleanup()
1233 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001234 except Exception:
1235 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab94282092014-10-10 13:00:11 -04001236 main.cleanup()
1237 main.exit()
1238
Cameron Franke9c94fb02015-01-21 10:20:20 -08001239 def isup(self, node = "", timeout = 120):
kelvin8ec71442015-01-15 16:57:00 -08001240 """
1241 Run's onos-wait-for-start which only returns once ONOS is at run
Cameron Franke9c94fb02015-01-21 10:20:20 -08001242 level 100(ready for use)
andrewonlab8d0d7d72014-10-09 16:33:15 -04001243
Jon Hall7993bfc2014-10-09 16:30:14 -04001244 Returns: main.TRUE if ONOS is running and main.FALSE on timeout
kelvin8ec71442015-01-15 16:57:00 -08001245 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001246 try:
Cameron Franke9c94fb02015-01-21 10:20:20 -08001247 self.handle.sendline("onos-wait-for-start " + node )
1248 self.handle.expect("onos-wait-for-start")
kelvin8ec71442015-01-15 16:57:00 -08001249 # NOTE: this timeout is arbitrary"
Cameron Franke9c94fb02015-01-21 10:20:20 -08001250 i = self.handle.expect(["\$", pexpect.TIMEOUT], timeout)
Jon Hall7993bfc2014-10-09 16:30:14 -04001251 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001252 main.log.info( self.name + ": " + node + " is up" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001253 return main.TRUE
1254 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001255 # NOTE: since this function won't return until ONOS is ready,
Jon Hall7993bfc2014-10-09 16:30:14 -04001256 # we will kill it on timeout
kelvin8ec71442015-01-15 16:57:00 -08001257 main.log.error( "ONOS has not started yet" )
1258 self.handle.send( "\x03" ) # Control-C
1259 self.handle.expect( "\$" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001260 return main.FALSE
1261 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001262 main.log.error( self.name + ": EOF exception found" )
1263 main.log.error( self.name + ": " + self.handle.before )
Jon Hall7993bfc2014-10-09 16:30:14 -04001264 main.cleanup()
1265 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001266 except Exception:
1267 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001268 main.cleanup()
1269 main.exit()
andrewonlab05e362f2014-10-10 00:40:57 -04001270
kelvin-onlabd3b64892015-01-20 13:26:24 -08001271 def pushTestIntentsShell(
1272 self,
1273 dpidSrc,
1274 dpidDst,
1275 numIntents,
1276 dirFile,
1277 onosIp,
1278 numMult="",
1279 appId="",
1280 report=True,
1281 options="" ):
kelvin8ec71442015-01-15 16:57:00 -08001282 """
andrewonlabb66dfa12014-12-02 15:51:10 -05001283 Description:
kelvin8ec71442015-01-15 16:57:00 -08001284 Use the linux prompt to push test intents to
andrewonlabb66dfa12014-12-02 15:51:10 -05001285 better parallelize the results than the CLI
1286 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001287 * dpidSrc: specify source dpid
1288 * dpidDst: specify destination dpid
1289 * numIntents: specify number of intents to push
1290 * dirFile: specify directory and file name to save
andrewonlabb66dfa12014-12-02 15:51:10 -05001291 results
kelvin-onlabd3b64892015-01-20 13:26:24 -08001292 * onosIp: specify the IP of ONOS to install on
kelvin8ec71442015-01-15 16:57:00 -08001293 NOTE:
andrewonlabb66dfa12014-12-02 15:51:10 -05001294 You must invoke this command at linux shell prompt
kelvin8ec71442015-01-15 16:57:00 -08001295 """
1296 try:
1297 # Create the string to sendline
andrewonlabaedc8332014-12-04 12:43:03 -05001298 if options:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001299 baseCmd = "onos " + str( onosIp ) + " push-test-intents " +\
kelvin8ec71442015-01-15 16:57:00 -08001300 options + " "
andrewonlabaedc8332014-12-04 12:43:03 -05001301 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001302 baseCmd = "onos " + str( onosIp ) + " push-test-intents "
kelvin8ec71442015-01-15 16:57:00 -08001303
kelvin-onlabd3b64892015-01-20 13:26:24 -08001304 addDpid = baseCmd + str( dpidSrc ) + " " + str( dpidDst )
1305 if not numMult:
1306 addIntents = addDpid + " " + str( numIntents )
1307 elif numMult:
1308 addIntents = addDpid + " " + str( numIntents ) + " " +\
1309 str( numMult )
1310 if appId:
1311 addApp = addIntents + " " + str( appId )
andrewonlabb66dfa12014-12-02 15:51:10 -05001312 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001313 addApp = addIntents
andrewonlabb66dfa12014-12-02 15:51:10 -05001314
andrewonlabaedc8332014-12-04 12:43:03 -05001315 if report:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001316 sendCmd = addApp + " > " + str( dirFile ) + " &"
andrewonlabaedc8332014-12-04 12:43:03 -05001317 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001318 sendCmd = addApp + " &"
1319 main.log.info( "Send cmd: " + sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001320
kelvin-onlabd3b64892015-01-20 13:26:24 -08001321 self.handle.sendline( sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001322
1323 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001324 main.log.error( self.name + ": EOF exception found" )
1325 main.log.error( self.name + ": " + self.handle.before )
andrewonlabb66dfa12014-12-02 15:51:10 -05001326 main.cleanup()
1327 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001328 except Exception:
1329 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabb66dfa12014-12-02 15:51:10 -05001330 main.cleanup()
kelvin8ec71442015-01-15 16:57:00 -08001331 main.exit()
andrewonlab05e362f2014-10-10 00:40:57 -04001332
kelvin-onlabd3b64892015-01-20 13:26:24 -08001333 def getTopology( self, topologyOutput ):
kelvin8ec71442015-01-15 16:57:00 -08001334 """
Hari Krishnaef1bd4e2015-03-12 16:55:30 -07001335 Definition:
1336 Loads a json topology output
1337 Return:
1338 topology = current ONOS topology
kelvin8ec71442015-01-15 16:57:00 -08001339 """
Hari Krishnaef1bd4e2015-03-12 16:55:30 -07001340 import json
Jon Hall77f53ce2014-10-13 18:02:06 -04001341 try:
Hari Krishnaef1bd4e2015-03-12 16:55:30 -07001342 # either onos:topology or 'topology' will work in CLI
1343 topology = json.loads(topologyOutput)
1344 print topology
Jon Hall77f53ce2014-10-13 18:02:06 -04001345 return topology
1346 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001347 main.log.error( self.name + ": EOF exception found" )
1348 main.log.error( self.name + ": " + self.handle.before )
Jon Hall77f53ce2014-10-13 18:02:06 -04001349 main.cleanup()
1350 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001351 except Exception:
1352 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall77f53ce2014-10-13 18:02:06 -04001353 main.cleanup()
1354 main.exit()
1355
kelvin-onlabd3b64892015-01-20 13:26:24 -08001356 def checkStatus(
1357 self,
1358 topologyResult,
1359 numoswitch,
1360 numolink,
1361 logLevel="info" ):
kelvin8ec71442015-01-15 16:57:00 -08001362 """
Jon Hallefbd9792015-03-05 16:11:36 -08001363 Checks the number of switches & links that ONOS sees against the
kelvin8ec71442015-01-15 16:57:00 -08001364 supplied values. By default this will report to main.log, but the
Jon Hallefbd9792015-03-05 16:11:36 -08001365 log level can be specific.
kelvin8ec71442015-01-15 16:57:00 -08001366
Jon Hall77f53ce2014-10-13 18:02:06 -04001367 Params: ip = ip used for the onos cli
1368 numoswitch = expected number of switches
Jon Hallefbd9792015-03-05 16:11:36 -08001369 numolink = expected number of links
kelvin-onlabd3b64892015-01-20 13:26:24 -08001370 logLevel = level to log to.
1371 Currently accepts 'info', 'warn' and 'report'
Jon Hall77f53ce2014-10-13 18:02:06 -04001372
1373
kelvin-onlabd3b64892015-01-20 13:26:24 -08001374 logLevel can
Jon Hall77f53ce2014-10-13 18:02:06 -04001375
Jon Hallefbd9792015-03-05 16:11:36 -08001376 Returns: main.TRUE if the number of switches and links are correct,
1377 main.FALSE if the number of switches and links is incorrect,
Jon Hall77f53ce2014-10-13 18:02:06 -04001378 and main.ERROR otherwise
kelvin8ec71442015-01-15 16:57:00 -08001379 """
Jon Hall77f53ce2014-10-13 18:02:06 -04001380 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001381 topology = self.getTopology( topologyResult )
Jon Hall77f53ce2014-10-13 18:02:06 -04001382 if topology == {}:
1383 return main.ERROR
1384 output = ""
kelvin8ec71442015-01-15 16:57:00 -08001385 # Is the number of switches is what we expected
shahshreya234a1682015-05-27 15:41:56 -07001386 devices = topology.get( 'devices', False )
1387 links = topology.get( 'links', False )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001388 if not devices or not links:
Jon Hall77f53ce2014-10-13 18:02:06 -04001389 return main.ERROR
kelvin-onlabd3b64892015-01-20 13:26:24 -08001390 switchCheck = ( int( devices ) == int( numoswitch ) )
kelvin8ec71442015-01-15 16:57:00 -08001391 # Is the number of links is what we expected
kelvin-onlabd3b64892015-01-20 13:26:24 -08001392 linkCheck = ( int( links ) == int( numolink ) )
Jon Hallefbd9792015-03-05 16:11:36 -08001393 if switchCheck and linkCheck:
kelvin8ec71442015-01-15 16:57:00 -08001394 # We expected the correct numbers
Jon Hall77f53ce2014-10-13 18:02:06 -04001395 output = output + "The number of links and switches match "\
kelvin8ec71442015-01-15 16:57:00 -08001396 + "what was expected"
Jon Hall77f53ce2014-10-13 18:02:06 -04001397 result = main.TRUE
1398 else:
1399 output = output + \
Jon Hall274b6642015-02-17 11:57:17 -08001400 "The number of links and switches does not match " + \
1401 "what was expected"
Jon Hall77f53ce2014-10-13 18:02:06 -04001402 result = main.FALSE
Jon Hallefbd9792015-03-05 16:11:36 -08001403 output = output + "\n ONOS sees %i devices" % int( devices )
1404 output = output + " (%i expected) " % int( numoswitch )
Jon Hall274b6642015-02-17 11:57:17 -08001405 output = output + "and %i links " % int( links )
1406 output = output + "(%i expected)" % int( numolink )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001407 if logLevel == "report":
kelvin8ec71442015-01-15 16:57:00 -08001408 main.log.report( output )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001409 elif logLevel == "warn":
kelvin8ec71442015-01-15 16:57:00 -08001410 main.log.warn( output )
Jon Hall77f53ce2014-10-13 18:02:06 -04001411 else:
kelvin8ec71442015-01-15 16:57:00 -08001412 main.log.info( output )
1413 return result
Jon Hall77f53ce2014-10-13 18:02:06 -04001414 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001415 main.log.error( self.name + ": EOF exception found" )
1416 main.log.error( self.name + ": " + self.handle.before )
Jon Hall77f53ce2014-10-13 18:02:06 -04001417 main.cleanup()
1418 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001419 except Exception:
1420 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall77f53ce2014-10-13 18:02:06 -04001421 main.cleanup()
1422 main.exit()
andrewonlabba44bcf2014-10-16 16:54:41 -04001423
kelvin-onlabd3b64892015-01-20 13:26:24 -08001424 def tsharkPcap( self, interface, dirFile ):
kelvin8ec71442015-01-15 16:57:00 -08001425 """
andrewonlab970399c2014-11-07 13:09:32 -05001426 Capture all packet activity and store in specified
1427 directory/file
1428
1429 Required:
1430 * interface: interface to capture
1431 * dir: directory/filename to store pcap
kelvin8ec71442015-01-15 16:57:00 -08001432 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001433 try:
1434 self.handle.sendline( "" )
1435 self.handle.expect( "\$" )
andrewonlab970399c2014-11-07 13:09:32 -05001436
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001437 self.handle.sendline( "tshark -i " + str( interface ) + " -t e -w " + str( dirFile ) + " &" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001438 self.handle.sendline( "\r" )
1439 self.handle.expect( "Capturing on" )
1440 self.handle.sendline( "\r" )
1441 self.handle.expect( "\$" )
andrewonlab970399c2014-11-07 13:09:32 -05001442
Jon Hallfebb1c72015-03-05 13:30:09 -08001443 main.log.info( "Tshark started capturing files on " +
1444 str( interface ) + " and saving to directory: " +
1445 str( dirFile ) )
1446 except pexpect.EOF:
1447 main.log.error( self.name + ": EOF exception found" )
1448 main.log.error( self.name + ": " + self.handle.before )
1449 main.cleanup()
1450 main.exit()
1451 except Exception:
1452 main.log.exception( self.name + ": Uncaught exception!" )
1453 main.cleanup()
1454 main.exit()
Shreya Shaha73aaad2014-10-27 18:03:09 -04001455
kelvin-onlabd3b64892015-01-20 13:26:24 -08001456 def runOnosTopoCfg( self, instanceName, jsonFile ):
kelvin8ec71442015-01-15 16:57:00 -08001457 """
kelvin-onlabd3b64892015-01-20 13:26:24 -08001458 On ONOS bench, run this command:
Jon Halle94919c2015-03-23 11:42:57 -07001459 {ONOS_HOME}/tools/test/bin/onos-topo-cfg $OC1 filename
kelvin-onlabd3b64892015-01-20 13:26:24 -08001460 which starts the rest and copies
1461 the json file to the onos instance
kelvin8ec71442015-01-15 16:57:00 -08001462 """
shahshreyae6c7cf42014-11-26 16:39:01 -08001463 try:
kelvin8ec71442015-01-15 16:57:00 -08001464 self.handle.sendline( "" )
1465 self.handle.expect( "\$" )
Jon Halle94919c2015-03-23 11:42:57 -07001466 self.handle.sendline( "cd " + self.home + "/tools/test/bin" )
kelvin8ec71442015-01-15 16:57:00 -08001467 self.handle.expect( "/bin$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001468 cmd = "./onos-topo-cfg " + instanceName + " " + jsonFile
shahshreyae6c7cf42014-11-26 16:39:01 -08001469 print "cmd = ", cmd
kelvin8ec71442015-01-15 16:57:00 -08001470 self.handle.sendline( cmd )
1471 self.handle.expect( "\$" )
1472 self.handle.sendline( "cd ~" )
1473 self.handle.expect( "\$" )
shahshreyae6c7cf42014-11-26 16:39:01 -08001474 return main.TRUE
Jon Hallfebb1c72015-03-05 13:30:09 -08001475 except pexpect.EOF:
1476 main.log.error( self.name + ": EOF exception found" )
1477 main.log.error( self.name + ": " + self.handle.before )
1478 main.cleanup()
1479 main.exit()
1480 except Exception:
1481 main.log.exception( self.name + ": Uncaught exception!" )
1482 main.cleanup()
1483 main.exit()
kelvin8ec71442015-01-15 16:57:00 -08001484
jenkins1e99e7b2015-04-02 18:15:39 -07001485 def tsharkGrep( self, grep, directory, interface='eth0', grepOptions='' ):
kelvin8ec71442015-01-15 16:57:00 -08001486 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001487 Required:
kelvin8ec71442015-01-15 16:57:00 -08001488 * grep string
andrewonlabba44bcf2014-10-16 16:54:41 -04001489 * directory to store results
1490 Optional:
1491 * interface - default: eth0
Jon Hall4ba53f02015-07-29 13:07:41 -07001492 * grepOptions - options for grep
andrewonlabba44bcf2014-10-16 16:54:41 -04001493 Description:
1494 Uses tshark command to grep specific group of packets
1495 and stores the results to specified directory.
kelvin8ec71442015-01-15 16:57:00 -08001496 The timestamp is hardcoded to be in epoch
1497 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001498 try:
1499 self.handle.sendline( "" )
1500 self.handle.expect( "\$" )
1501 self.handle.sendline( "" )
jenkins1e99e7b2015-04-02 18:15:39 -07001502 if grepOptions:
1503 grepStr = "grep "+str(grepOptions)
1504 else:
1505 grepStr = "grep"
Jon Hall4ba53f02015-07-29 13:07:41 -07001506
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001507 cmd = (
1508 "sudo tshark -i " +
Jon Hallfebb1c72015-03-05 13:30:09 -08001509 str( interface ) +
jenkins1e99e7b2015-04-02 18:15:39 -07001510 " -t e | " +
1511 grepStr + " --line-buffered \"" +
Jon Hallfebb1c72015-03-05 13:30:09 -08001512 str(grep) +
1513 "\" >" +
1514 directory +
1515 " &" )
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001516 self.handle.sendline(cmd)
1517 main.log.info(cmd)
Jon Hallfebb1c72015-03-05 13:30:09 -08001518 self.handle.expect( "Capturing on" )
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001519 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001520 self.handle.expect( "\$" )
1521 except pexpect.EOF:
1522 main.log.error( self.name + ": EOF exception found" )
1523 main.log.error( self.name + ": " + self.handle.before )
1524 main.cleanup()
1525 main.exit()
1526 except Exception:
1527 main.log.exception( self.name + ": Uncaught exception!" )
1528 main.cleanup()
1529 main.exit()
1530
kelvin-onlabd3b64892015-01-20 13:26:24 -08001531 def tsharkStop( self ):
kelvin8ec71442015-01-15 16:57:00 -08001532 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001533 Removes wireshark files from /tmp and kills all tshark processes
kelvin8ec71442015-01-15 16:57:00 -08001534 """
1535 # Remove all pcap from previous captures
Jon Hallfebb1c72015-03-05 13:30:09 -08001536 try:
1537 self.execute( cmd="sudo rm /tmp/wireshark*" )
1538 self.handle.sendline( "" )
Jon Hallefbd9792015-03-05 16:11:36 -08001539 self.handle.sendline( "sudo kill -9 `ps -ef | grep \"tshark -i\"" +
1540 " | grep -v grep | awk '{print $2}'`" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001541 self.handle.sendline( "" )
1542 main.log.info( "Tshark stopped" )
1543 except pexpect.EOF:
1544 main.log.error( self.name + ": EOF exception found" )
1545 main.log.error( self.name + ": " + self.handle.before )
1546 main.cleanup()
1547 main.exit()
1548 except Exception:
1549 main.log.exception( self.name + ": Uncaught exception!" )
1550 main.cleanup()
1551 main.exit()
1552
kelvin8ec71442015-01-15 16:57:00 -08001553 def ptpd( self, args ):
1554 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001555 Initiate ptp with user-specified args.
1556 Required:
1557 * args: specify string of args after command
1558 'sudo ptpd'
kelvin8ec71442015-01-15 16:57:00 -08001559 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001560 try:
kelvin8ec71442015-01-15 16:57:00 -08001561 self.handle.sendline( "sudo ptpd " + str( args ) )
1562 i = self.handle.expect( [
andrewonlab0c38a4a2014-10-28 18:35:35 -04001563 "Multiple",
1564 "Error",
kelvin8ec71442015-01-15 16:57:00 -08001565 "\$" ] )
1566 self.handle.expect( "\$" )
andrewonlabba44bcf2014-10-16 16:54:41 -04001567
andrewonlab0c38a4a2014-10-28 18:35:35 -04001568 if i == 0:
1569 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001570 main.log.info( "ptpd returned an error: " +
1571 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001572 return handle
1573 elif i == 1:
1574 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001575 main.log.error( "ptpd returned an error: " +
1576 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001577 return handle
1578 else:
1579 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -08001580
andrewonlab0c38a4a2014-10-28 18:35:35 -04001581 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001582 main.log.error( self.name + ": EOF exception found" )
1583 main.log.error( self.name + ": " + self.handle.before )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001584 main.cleanup()
1585 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001586 except Exception:
1587 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001588 main.cleanup()
1589 main.exit()
andrewonlabba44bcf2014-10-16 16:54:41 -04001590
kelvin-onlabd3b64892015-01-20 13:26:24 -08001591 def cpLogsToDir( self, logToCopy,
Jon Hallefbd9792015-03-05 16:11:36 -08001592 destDir, copyFileName="" ):
kelvin8ec71442015-01-15 16:57:00 -08001593 """
1594 Copies logs to a desired directory.
andrewonlab5d7a8f32014-11-10 13:07:56 -05001595 Current implementation of ONOS deletes its karaf
1596 logs on every iteration. For debugging purposes,
kelvin8ec71442015-01-15 16:57:00 -08001597 you may want to use this function to capture
1598 certain karaf logs. ( or any other logs if needed )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001599 Localtime will be attached to the filename
1600
1601 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001602 * logToCopy: specify directory and log name to
andrewonlab5d7a8f32014-11-10 13:07:56 -05001603 copy.
kelvin8ec71442015-01-15 16:57:00 -08001604 ex ) /opt/onos/log/karaf.log.1
kelvin-onlabd3b64892015-01-20 13:26:24 -08001605 For copying multiple files, leave copyFileName
1606 empty and only specify destDir -
kelvin8ec71442015-01-15 16:57:00 -08001607 ex ) /opt/onos/log/karaf*
kelvin-onlabd3b64892015-01-20 13:26:24 -08001608 * destDir: specify directory to copy to.
kelvin8ec71442015-01-15 16:57:00 -08001609 ex ) /tmp/
1610 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001611 * copyFileName: If you want to rename the log
1612 file, specify copyFileName. This will not work
andrewonlab5d7a8f32014-11-10 13:07:56 -05001613 with multiple file copying
kelvin8ec71442015-01-15 16:57:00 -08001614 """
andrewonlab5d7a8f32014-11-10 13:07:56 -05001615 try:
kelvin8ec71442015-01-15 16:57:00 -08001616 localtime = time.strftime( '%x %X' )
1617 localtime = localtime.replace( "/", "" )
1618 localtime = localtime.replace( " ", "_" )
1619 localtime = localtime.replace( ":", "" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001620 if destDir[ -1: ] != "/":
1621 destDir += "/"
andrewonlab5d7a8f32014-11-10 13:07:56 -05001622
kelvin-onlabd3b64892015-01-20 13:26:24 -08001623 if copyFileName:
Jon Hallfebb1c72015-03-05 13:30:09 -08001624 self.handle.sendline( "cp " + str( logToCopy ) + " " +
1625 str( destDir ) + str( copyFileName ) +
1626 localtime )
kelvin8ec71442015-01-15 16:57:00 -08001627 self.handle.expect( "cp" )
1628 self.handle.expect( "\$" )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001629 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001630 self.handle.sendline( "cp " + str( logToCopy ) +
1631 " " + str( destDir ) )
kelvin8ec71442015-01-15 16:57:00 -08001632 self.handle.expect( "cp" )
1633 self.handle.expect( "\$" )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001634
kelvin8ec71442015-01-15 16:57:00 -08001635 return self.handle.before
1636
1637 except pexpect.EOF:
1638 main.log.error( "Copying files failed" )
1639 main.log.error( self.name + ": EOF exception found" )
1640 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001641 except Exception:
1642 main.log.exception( "Copying files failed" )
1643
Jon Hall16b72c42015-05-20 10:23:36 -07001644 def checkLogs( self, onosIp, restart=False):
kelvin8ec71442015-01-15 16:57:00 -08001645 """
Jon Hall94fd0472014-12-08 11:52:42 -08001646 runs onos-check-logs on the given onos node
Jon Hall80daded2015-05-27 16:07:00 -07001647 If restart is True, use the old version of onos-check-logs which
1648 does not print the full stacktrace, but shows the entire log file,
1649 including across restarts
Jon Hall94fd0472014-12-08 11:52:42 -08001650 returns the response
kelvin8ec71442015-01-15 16:57:00 -08001651 """
Jon Hall94fd0472014-12-08 11:52:42 -08001652 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001653 cmd = "onos-check-logs " + str( onosIp )
Jon Hall16b72c42015-05-20 10:23:36 -07001654 if restart:
1655 cmd += " old"
kelvin8ec71442015-01-15 16:57:00 -08001656 self.handle.sendline( cmd )
1657 self.handle.expect( cmd )
1658 self.handle.expect( "\$" )
Jon Hall94fd0472014-12-08 11:52:42 -08001659 response = self.handle.before
1660 return response
1661 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001662 main.log.error( "Lost ssh connection" )
1663 main.log.error( self.name + ": EOF exception found" )
1664 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001665 except Exception:
1666 main.log.exception( self.name + ": Uncaught exception!" )
1667 main.cleanup()
1668 main.exit()
Jon Hall94fd0472014-12-08 11:52:42 -08001669
kelvin-onlabd3b64892015-01-20 13:26:24 -08001670 def onosStatus( self, node="" ):
kelvin8ec71442015-01-15 16:57:00 -08001671 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001672 Calls onos command: 'onos-service [<node-ip>] status'
kelvin8ec71442015-01-15 16:57:00 -08001673 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001674 try:
kelvin8ec71442015-01-15 16:57:00 -08001675 self.handle.sendline( "" )
1676 self.handle.expect( "\$" )
1677 self.handle.sendline( "onos-service " + str( node ) +
1678 " status" )
1679 i = self.handle.expect( [
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001680 "start/running",
1681 "stop/waiting",
kelvin8ec71442015-01-15 16:57:00 -08001682 pexpect.TIMEOUT ], timeout=120 )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001683
1684 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001685 main.log.info( "ONOS is running" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001686 return main.TRUE
1687 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001688 main.log.info( "ONOS is stopped" )
kelvin8ec71442015-01-15 16:57:00 -08001689 main.log.error( "ONOS service failed to check the status" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001690 main.cleanup()
1691 main.exit()
1692 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001693 main.log.error( self.name + ": EOF exception found" )
1694 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001695 main.cleanup()
1696 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001697 except Exception:
1698 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001699 main.cleanup()
1700 main.exit()
Jon Hall21270ac2015-02-16 17:59:55 -08001701
Jon Hall63604932015-02-26 17:09:50 -08001702 def setIpTables( self, ip, port='', action='add', packet_type='',
1703 direction='INPUT', rule='DROP', states=True ):
Jon Hallefbd9792015-03-05 16:11:36 -08001704 """
Jon Hall21270ac2015-02-16 17:59:55 -08001705 Description:
1706 add or remove iptables rule to DROP (default) packets from
1707 specific IP and PORT
1708 Usage:
1709 * specify action ('add' or 'remove')
1710 when removing, pass in the same argument as you would add. It will
1711 delete that specific rule.
1712 * specify the ip to block
1713 * specify the destination port to block (defaults to all ports)
1714 * optional packet type to block (default tcp)
1715 * optional iptables rule (default DROP)
1716 * optional direction to block (default 'INPUT')
Jon Hall63604932015-02-26 17:09:50 -08001717 * States boolean toggles adding all supported tcp states to the
1718 firewall rule
Jon Hall21270ac2015-02-16 17:59:55 -08001719 Returns:
1720 main.TRUE on success or
1721 main.FALSE if given invalid input or
1722 main.ERROR if there is an error in response from iptables
1723 WARNING:
1724 * This function uses root privilege iptables command which may result
1725 in unwanted network errors. USE WITH CAUTION
Jon Hallefbd9792015-03-05 16:11:36 -08001726 """
Jon Hall21270ac2015-02-16 17:59:55 -08001727 import time
1728
1729 # NOTE*********
1730 # The strict checking methods of this driver function is intentional
1731 # to discourage any misuse or error of iptables, which can cause
1732 # severe network errors
1733 # *************
1734
1735 # NOTE: Sleep needed to give some time for rule to be added and
1736 # registered to the instance. If you are calling this function
1737 # multiple times this sleep will prevent any errors.
1738 # DO NOT REMOVE
Jon Hall63604932015-02-26 17:09:50 -08001739 # time.sleep( 5 )
Jon Hall21270ac2015-02-16 17:59:55 -08001740 try:
1741 # input validation
1742 action_type = action.lower()
1743 rule = rule.upper()
1744 direction = direction.upper()
1745 if action_type != 'add' and action_type != 'remove':
1746 main.log.error( "Invalid action type. Use 'add' or "
1747 "'remove' table rule" )
1748 if rule != 'DROP' and rule != 'ACCEPT' and rule != 'LOG':
1749 # NOTE Currently only supports rules DROP, ACCEPT, and LOG
1750 main.log.error( "Invalid rule. Valid rules are 'DROP' or "
1751 "'ACCEPT' or 'LOG' only." )
1752 if direction != 'INPUT' and direction != 'OUTPUT':
1753 # NOTE currently only supports rules INPUT and OUPTUT
1754 main.log.error( "Invalid rule. Valid directions are"
1755 " 'OUTPUT' or 'INPUT'" )
1756 return main.FALSE
1757 return main.FALSE
1758 return main.FALSE
1759 if action_type == 'add':
1760 # -A is the 'append' action of iptables
1761 actionFlag = '-A'
1762 elif action_type == 'remove':
1763 # -D is the 'delete' rule of iptables
1764 actionFlag = '-D'
1765 self.handle.sendline( "" )
1766 self.handle.expect( "\$" )
1767 cmd = "sudo iptables " + actionFlag + " " +\
1768 direction +\
Jon Hall21270ac2015-02-16 17:59:55 -08001769 " -s " + str( ip )
Jon Hall63604932015-02-26 17:09:50 -08001770 # " -p " + str( packet_type ) +\
1771 if packet_type:
1772 cmd += " -p " + str( packet_type )
Jon Hall21270ac2015-02-16 17:59:55 -08001773 if port:
1774 cmd += " --dport " + str( port )
Jon Hall63604932015-02-26 17:09:50 -08001775 if states:
1776 cmd += " -m state --state="
1777 #FIXME- Allow user to configure which states to block
1778 cmd += "INVALID,ESTABLISHED,NEW,RELATED,UNTRACKED"
Jon Hall21270ac2015-02-16 17:59:55 -08001779 cmd += " -j " + str( rule )
1780
1781 self.handle.sendline( cmd )
1782 self.handle.expect( "\$" )
1783 main.log.warn( self.handle.before )
1784
1785 info_string = "On " + str( self.name )
1786 info_string += " " + str( action_type )
1787 info_string += " iptable rule [ "
1788 info_string += " IP: " + str( ip )
1789 info_string += " Port: " + str( port )
1790 info_string += " Rule: " + str( rule )
1791 info_string += " Direction: " + str( direction ) + " ]"
1792 main.log.info( info_string )
1793 return main.TRUE
1794 except pexpect.TIMEOUT:
1795 main.log.exception( self.name + ": Timeout exception in "
1796 "setIpTables function" )
1797 return main.ERROR
1798 except pexpect.EOF:
1799 main.log.error( self.name + ": EOF exception found" )
1800 main.log.error( self.name + ": " + self.handle.before )
1801 main.cleanup()
1802 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001803 except Exception:
1804 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall21270ac2015-02-16 17:59:55 -08001805 main.cleanup()
1806 main.exit()
1807
Jon Hall0468b042015-02-19 19:08:21 -08001808 def detailed_status(self, log_filename):
Jon Hallefbd9792015-03-05 16:11:36 -08001809 """
Jon Hall0468b042015-02-19 19:08:21 -08001810 This method is used by STS to check the status of the controller
1811 Reports RUNNING, STARTING, STOPPED, FROZEN, ERROR (and reason)
Jon Hallefbd9792015-03-05 16:11:36 -08001812 """
Jon Hall0468b042015-02-19 19:08:21 -08001813 import re
1814 try:
1815 self.handle.sendline( "" )
1816 self.handle.expect( "\$" )
1817 self.handle.sendline( "cd " + self.home )
1818 self.handle.expect( "\$" )
1819 self.handle.sendline( "service onos status" )
1820 self.handle.expect( "\$" )
1821 response = self.handle.before
1822 if re.search( "onos start/running", response ):
1823 # onos start/running, process 10457
1824 return 'RUNNING'
1825 # FIXME: Implement this case
1826 # elif re.search( pattern, response ):
1827 # return 'STARTING'
1828 elif re.search( "onos stop/", response ):
1829 # onos stop/waiting
1830 # FIXME handle this differently?: onos stop/pre-stop
1831 return 'STOPPED'
1832 # FIXME: Implement this case
1833 # elif re.search( pattern, response ):
1834 # return 'FROZEN'
1835 else:
1836 main.log.warn( self.name +
Jon Hallefbd9792015-03-05 16:11:36 -08001837 " WARNING: status received unknown response" )
Jon Hall0468b042015-02-19 19:08:21 -08001838 main.log.warn( response )
1839 return 'ERROR', "Unknown response: %s" % response
1840 except pexpect.TIMEOUT:
1841 main.log.exception( self.name + ": Timeout exception in "
1842 "setIpTables function" )
1843 return 'ERROR', "Pexpect Timeout"
1844 except pexpect.EOF:
1845 main.log.error( self.name + ": EOF exception found" )
1846 main.log.error( self.name + ": " + self.handle.before )
1847 main.cleanup()
1848 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001849 except Exception:
1850 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall0468b042015-02-19 19:08:21 -08001851 main.cleanup()
1852 main.exit()
1853
andrew@onlab.us3b087132015-03-11 15:00:08 -07001854 def createLinkGraphFile( self, benchIp, ONOSIpList, deviceCount):
1855 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07001856 Create/formats the LinkGraph.cfg file based on arguments
1857 -only creates a linear topology and connects islands
1858 -evenly distributes devices
andrew@onlab.us3b087132015-03-11 15:00:08 -07001859 -must be called by ONOSbench
1860
Jon Hall4ba53f02015-07-29 13:07:41 -07001861 ONOSIpList - list of all of the node IPs to be used
1862
1863 deviceCount - number of switches to be assigned
andrew@onlab.us3b087132015-03-11 15:00:08 -07001864 '''
1865 main.log.step("Creating link graph configuration file." )
1866 linkGraphPath = self.home + "/tools/package/etc/linkGraph.cfg"
Jon Hall4ba53f02015-07-29 13:07:41 -07001867 tempFile = "/tmp/linkGraph.cfg"
andrew@onlab.us3b087132015-03-11 15:00:08 -07001868
1869 linkGraph = open(tempFile, 'w+')
1870 linkGraph.write("# NullLinkProvider topology description (config file).\n")
1871 linkGraph.write("# The NodeId is only added if the destination is another node's device.\n")
1872 linkGraph.write("# Bugs: Comments cannot be appended to a line to be read.\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07001873
andrew@onlab.us3b087132015-03-11 15:00:08 -07001874 clusterCount = len(ONOSIpList)
Jon Hall4ba53f02015-07-29 13:07:41 -07001875
1876 if type(deviceCount) is int or type(deviceCount) is str:
andrew@onlab.us3b087132015-03-11 15:00:08 -07001877 deviceCount = int(deviceCount)
1878 switchList = [0]*(clusterCount+1)
1879 baselineSwitchCount = deviceCount/clusterCount
Jon Hall4ba53f02015-07-29 13:07:41 -07001880
andrew@onlab.us3b087132015-03-11 15:00:08 -07001881 for node in range(1, clusterCount + 1):
1882 switchList[node] = baselineSwitchCount
1883
1884 for node in range(1, (deviceCount%clusterCount)+1):
1885 switchList[node] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001886
andrew@onlab.us3b087132015-03-11 15:00:08 -07001887 if type(deviceCount) is list:
1888 main.log.info("Using provided device distribution")
1889 switchList = [0]
1890 for i in deviceCount:
1891 switchList.append(int(i))
1892
1893 tempList = ['0']
1894 tempList.extend(ONOSIpList)
1895 ONOSIpList = tempList
1896
1897 myPort = 6
1898 lastSwitch = 0
1899 for node in range(1, clusterCount+1):
1900 if switchList[node] == 0:
1901 continue
1902
1903 linkGraph.write("graph " + ONOSIpList[node] + " {\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07001904
andrew@onlab.us3b087132015-03-11 15:00:08 -07001905 if node > 1:
1906 #connect to last device on previous node
Jon Hall4ba53f02015-07-29 13:07:41 -07001907 line = ("\t0:5 -> " + str(lastSwitch) + ":6:" + lastIp + "\n") #ONOSIpList[node-1]
1908 linkGraph.write(line)
1909
1910 lastSwitch = 0
1911 for switch in range (0, switchList[node]-1):
andrew@onlab.us3b087132015-03-11 15:00:08 -07001912 line = ""
1913 line = ("\t" + str(switch) + ":" + str(myPort))
1914 line += " -- "
1915 line += (str(switch+1) + ":" + str(myPort-1) + "\n")
1916 linkGraph.write(line)
Jon Hall4ba53f02015-07-29 13:07:41 -07001917 lastSwitch = switch+1
andrew@onlab.us3b087132015-03-11 15:00:08 -07001918 lastIp = ONOSIpList[node]
Jon Hall4ba53f02015-07-29 13:07:41 -07001919
andrew@onlab.us3b087132015-03-11 15:00:08 -07001920 #lastSwitch += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001921 if node < (clusterCount):
andrew@onlab.us3b087132015-03-11 15:00:08 -07001922 #connect to first device on the next node
Jon Hall4ba53f02015-07-29 13:07:41 -07001923 line = ("\t" + str(lastSwitch) + ":6 -> 0:5:" + ONOSIpList[node+1] + "\n")
andrew@onlab.us3b087132015-03-11 15:00:08 -07001924 linkGraph.write(line)
Jon Hall4ba53f02015-07-29 13:07:41 -07001925
andrew@onlab.us3b087132015-03-11 15:00:08 -07001926 linkGraph.write("}\n")
1927 linkGraph.close()
1928
1929 #SCP
Jon Hall4ba53f02015-07-29 13:07:41 -07001930 os.system( "scp " + tempFile + " " + self.user_name + "@" + benchIp + ":" + linkGraphPath)
andrew@onlab.us3b087132015-03-11 15:00:08 -07001931 main.log.info("linkGraph.cfg creation complete")
1932
cameron@onlab.us75900962015-03-30 13:22:49 -07001933 def configNullDev( self, ONOSIpList, deviceCount, numPorts=10):
Jon Hall4ba53f02015-07-29 13:07:41 -07001934
andrew@onlab.us3b087132015-03-11 15:00:08 -07001935 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07001936 ONOSIpList = list of Ip addresses of nodes switches will be devided amongst
1937 deviceCount = number of switches to distribute, or list of values to use as custom distribution
cameron@onlab.us75900962015-03-30 13:22:49 -07001938 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 -07001939 '''
1940
cameron@onlab.us75900962015-03-30 13:22:49 -07001941 main.log.step("Configuring Null Device Provider" )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001942 clusterCount = len(ONOSIpList)
1943
Jon Hall4ba53f02015-07-29 13:07:41 -07001944 try:
1945
cameron@onlab.us75900962015-03-30 13:22:49 -07001946 if type(deviceCount) is int or type(deviceCount) is str:
1947 main.log.step("Creating device distribution")
1948 deviceCount = int(deviceCount)
1949 switchList = [0]*(clusterCount+1)
1950 baselineSwitchCount = deviceCount/clusterCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001951
cameron@onlab.us75900962015-03-30 13:22:49 -07001952 for node in range(1, clusterCount + 1):
1953 switchList[node] = baselineSwitchCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001954
cameron@onlab.us75900962015-03-30 13:22:49 -07001955 for node in range(1, (deviceCount%clusterCount)+1):
1956 switchList[node] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001957
1958 if type(deviceCount) is list:
1959 main.log.info("Using provided device distribution")
1960
1961 if len(deviceCount) == clusterCount:
cameron@onlab.us75900962015-03-30 13:22:49 -07001962 switchList = ['0']
1963 switchList.extend(deviceCount)
Jon Hall4ba53f02015-07-29 13:07:41 -07001964
1965 if len(deviceCount) == (clusterCount + 1):
1966 if deviceCount[0] == '0' or deviceCount[0] == 0:
cameron@onlab.us75900962015-03-30 13:22:49 -07001967 switchList = deviceCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001968
cameron@onlab.us75900962015-03-30 13:22:49 -07001969 assert len(switchList) == (clusterCount + 1)
Jon Hall4ba53f02015-07-29 13:07:41 -07001970
cameron@onlab.us75900962015-03-30 13:22:49 -07001971 except AssertionError:
Jon Hall4ba53f02015-07-29 13:07:41 -07001972 main.log.error( "Bad device/Ip list match")
cameron@onlab.us75900962015-03-30 13:22:49 -07001973 except TypeError:
1974 main.log.exception( self.name + ": Object not as expected" )
1975 return None
Jon Hall77ba41c2015-04-06 10:25:40 -07001976 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07001977 main.log.exception( self.name + ": Uncaught exception!" )
1978 main.cleanup()
1979 main.exit()
1980
andrew@onlab.us3b087132015-03-11 15:00:08 -07001981
1982 ONOSIp = [0]
1983 ONOSIp.extend(ONOSIpList)
Jon Hall4ba53f02015-07-29 13:07:41 -07001984
andrew@onlab.us3b087132015-03-11 15:00:08 -07001985 devicesString = "devConfigs = "
1986 for node in range(1, len(ONOSIp)):
1987 devicesString += (ONOSIp[node] + ":" + str(switchList[node] ))
1988 if node < clusterCount:
1989 devicesString += (",")
Jon Hall4ba53f02015-07-29 13:07:41 -07001990
1991 try:
cameron@onlab.us75900962015-03-30 13:22:49 -07001992 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider devConfigs " + devicesString )
1993 self.handle.expect(":~")
1994 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider numPorts " + str(numPorts) )
1995 self.handle.expect(":~")
andrew@onlab.us3b087132015-03-11 15:00:08 -07001996
cameron@onlab.us75900962015-03-30 13:22:49 -07001997 for i in range(10):
1998 self.handle.sendline("onos $OC1 cfg get org.onosproject.provider.nil.device.impl.NullDeviceProvider")
1999 self.handle.expect(":~")
2000 verification = self.handle.before
2001 if (" value=" + str(numPorts)) in verification and (" value=" + devicesString) in verification:
2002 break
2003 else:
2004 time.sleep(1)
andrew@onlab.us3b087132015-03-11 15:00:08 -07002005
cameron@onlab.us2cc8bf12015-04-02 14:12:30 -07002006 assert ("value=" + str(numPorts)) in verification and (" value=" + devicesString) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002007
cameron@onlab.us75900962015-03-30 13:22:49 -07002008 except AssertionError:
2009 main.log.error("Incorrect Config settings: " + verification)
Jon Hall77ba41c2015-04-06 10:25:40 -07002010 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002011 main.log.exception( self.name + ": Uncaught exception!" )
2012 main.cleanup()
2013 main.exit()
2014
Jon Hall4ba53f02015-07-29 13:07:41 -07002015 def configNullLink( self,fileName="/opt/onos/apache-karaf-3.0.3/etc/linkGraph.cfg", eventRate=0):
andrew@onlab.us3b087132015-03-11 15:00:08 -07002016 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07002017 fileName default is currently the same as the default on ONOS, specify alternate file if
cameron@onlab.us75900962015-03-30 13:22:49 -07002018 you want to use a different topology file than linkGraph.cfg
andrew@onlab.us3b087132015-03-11 15:00:08 -07002019 '''
2020
Jon Hall4ba53f02015-07-29 13:07:41 -07002021
2022 try:
2023 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider eventRate " + str(eventRate))
2024 self.handle.expect(":~")
cameron@onlab.us75900962015-03-30 13:22:49 -07002025 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider cfgFile " + fileName )
2026 self.handle.expect(":~")
Jon Hall4ba53f02015-07-29 13:07:41 -07002027
2028 for i in range(10):
2029 self.handle.sendline("onos $OC1 cfg get org.onosproject.provider.nil.link.impl.NullLinkProvider")
cameron@onlab.us75900962015-03-30 13:22:49 -07002030 self.handle.expect(":~")
2031 verification = self.handle.before
Jon Hall4ba53f02015-07-29 13:07:41 -07002032 if (" value=" + str(eventRate)) in verification and (" value=" + fileName) in verification:
cameron@onlab.us75900962015-03-30 13:22:49 -07002033 break
Jon Hall4ba53f02015-07-29 13:07:41 -07002034 else:
cameron@onlab.us75900962015-03-30 13:22:49 -07002035 time.sleep(1)
Jon Hall4ba53f02015-07-29 13:07:41 -07002036
cameron@onlab.us75900962015-03-30 13:22:49 -07002037 assert ("value=" + str(eventRate)) in verification and (" value=" + fileName) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002038
cameron@onlab.us75900962015-03-30 13:22:49 -07002039 except pexpect.EOF:
2040 main.log.error( self.name + ": EOF exception found" )
2041 main.log.error( self.name + ": " + self.handle.before )
2042 main.cleanup()
2043 main.exit()
cameron@onlab.us75900962015-03-30 13:22:49 -07002044 except AssertionError:
2045 main.log.info("Settings did not post to ONOS")
Jon Hall4ba53f02015-07-29 13:07:41 -07002046 main.log.error(varification)
Jon Hall77ba41c2015-04-06 10:25:40 -07002047 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002048 main.log.exception( self.name + ": Uncaught exception!" )
2049 main.log.error(varification)
2050 main.cleanup()
2051 main.exit()
andrew@onlab.us3b087132015-03-11 15:00:08 -07002052
kelvin-onlaba4074292015-07-09 15:19:49 -07002053 def getOnosIps( self ):
2054 """
2055 Get all onos IPs stored in
2056 """
cameron@onlab.us59d29d92015-05-11 14:31:54 -07002057
kelvin-onlaba4074292015-07-09 15:19:49 -07002058 return sorted( self.onosIps.values() )
cameron@onlab.us59d29d92015-05-11 14:31:54 -07002059
kelvin-onlaba4074292015-07-09 15:19:49 -07002060 def logReport( self, nodeIp, searchTerms, outputMode="s" ):
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002061 '''
2062 - accepts either a list or a string for "searchTerms" these
Jon Hall4ba53f02015-07-29 13:07:41 -07002063 terms will be searched for in the log and have their
2064 instances counted
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002065
Jon Hall4ba53f02015-07-29 13:07:41 -07002066 - nodeIp is the ip of the node whos log is to be scanned
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002067
Jon Hall4ba53f02015-07-29 13:07:41 -07002068 - output modes:
2069 "s" - Simple. Quiet output mode that just prints
2070 the occurences of each search term
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002071
cameron@onlab.us2e166212015-05-19 14:28:25 -07002072 "d" - Detailed. Prints number of occurences as well as the entire
Jon Hall4ba53f02015-07-29 13:07:41 -07002073 line for each of the last 5 occurences
cameron@onlab.us2e166212015-05-19 14:28:25 -07002074
2075 - returns total of the number of instances of all search terms
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002076 '''
2077 main.log.info("========================== Log Report ===========================\n")
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002078
Jon Hall4ba53f02015-07-29 13:07:41 -07002079 if type(searchTerms) is str:
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002080 searchTerms = [searchTerms]
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002081
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002082 logLines = [ [" "] for i in range(len(searchTerms)) ]
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002083
Jon Hall4ba53f02015-07-29 13:07:41 -07002084 for term in range(len(searchTerms)):
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002085 logLines[term][0] = searchTerms[term]
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002086
Jon Hall4ba53f02015-07-29 13:07:41 -07002087 totalHits = 0
2088 for term in range(len(searchTerms)):
2089 cmd = "onos-ssh " + nodeIp + " cat /opt/onos/log/karaf.log | grep " + searchTerms[term]
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002090 self.handle.sendline(cmd)
2091 self.handle.expect(":~")
2092 before = (self.handle.before).splitlines()
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002093
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002094 count = [searchTerms[term],0]
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002095
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002096 for line in before:
2097 if searchTerms[term] in line and "grep" not in line:
Jon Hall4ba53f02015-07-29 13:07:41 -07002098 count[1] += 1
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002099 if before.index(line) > ( len(before) - 7 ):
2100 logLines[term].append(line)
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002101
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002102 main.log.info( str(count[0]) + ": " + str(count[1]) )
Jon Hall4ba53f02015-07-29 13:07:41 -07002103 if term == len(searchTerms)-1:
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002104 print("\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07002105 totalHits += int(count[1])
cameron@onlab.us2e166212015-05-19 14:28:25 -07002106
Jon Hall4ba53f02015-07-29 13:07:41 -07002107 if outputMode != "s" and outputMode != "S":
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002108 outputString = ""
2109 for i in logLines:
Jon Hall4ba53f02015-07-29 13:07:41 -07002110 outputString = i[0] + ": \n"
2111 for x in range(1,len(i)):
2112 outputString += ( i[x] + "\n" )
2113
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002114 if outputString != (i[0] + ": \n"):
Jon Hall4ba53f02015-07-29 13:07:41 -07002115 main.log.info(outputString)
2116
cameron@onlab.us966d1be2015-05-15 14:54:09 -07002117 main.log.info("================================================================\n")
Hari Krishnabe4b97b2015-07-15 12:19:43 -07002118 return totalHits
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002119
2120 def copyMininetFile( self, fileName, localPath, userName, ip,
2121 mnPath='~/mininet/custom/', timeout = 60 ):
2122 """
2123 Description:
2124 Copy mininet topology file from dependency folder in the test folder
2125 and paste it to the mininet machine's mininet/custom folder
2126 Required:
2127 fileName - Name of the topology file to copy
2128 localPath - File path of the mininet topology file
2129 userName - User name of the mininet machine to send the file to
2130 ip - Ip address of the mininet machine
2131 Optional:
2132 mnPath - of the mininet directory to send the file to
2133 Return:
2134 Return main.TRUE if successfully copied the file otherwise
2135 return main.FALSE
2136 """
2137
2138 try:
2139 cmd = "scp " + localPath + fileName + " " + userName + "@" + \
2140 str( ip ) + ":" + mnPath + fileName
2141
2142 self.handle.sendline( "" )
2143 self.handle.expect( "\$" )
2144
2145 main.log.info( self.name + ": Execute: " + cmd )
2146
2147 self.handle.sendline( cmd )
2148
2149 i = self.handle.expect( [ 'No such file',
2150 "100%",
2151 pexpect.TIMEOUT ] )
2152
2153 if i == 0:
2154 main.log.error( self.name + ": File " + fileName +
2155 " does not exist!" )
2156 return main.FALSE
2157
2158 if i == 1:
2159 main.log.info( self.name + ": File " + fileName +
2160 " has been copied!" )
2161 self.handle.sendline( "" )
2162 self.handle.expect( "\$" )
2163 return main.TRUE
2164
2165 except pexpect.EOF:
2166 main.log.error( self.name + ": EOF exception found" )
2167 main.log.error( self.name + ": " + self.handle.before )
2168 main.cleanup()
2169 main.exit()
2170 except pexpect.TIMEOUT:
2171 main.log.error( self.name + ": TIMEOUT exception found" )
2172 main.log.error( self.name + ": " + self.handle.before )
2173 main.cleanup()
2174 main.exit()
cameron@onlab.us78b89652015-07-08 15:21:03 -07002175
2176 def jvmSet(self, memory=8):
Jon Hall4ba53f02015-07-29 13:07:41 -07002177
cameron@onlab.us78b89652015-07-08 15:21:03 -07002178 import os
2179
2180 homeDir = os.path.expanduser('~')
2181 filename = "/onos/tools/package/bin/onos-service"
2182
2183 serviceConfig = open(homeDir + filename, 'w+')
2184 serviceConfig.write("#!/bin/bash\n ")
2185 serviceConfig.write("#------------------------------------- \n ")
2186 serviceConfig.write("# Starts ONOS Apache Karaf container\n ")
2187 serviceConfig.write("#------------------------------------- \n ")
2188 serviceConfig.write("#export JAVA_HOME=${JAVA_HOME:-/usr/lib/jvm/java-7-openjdk-amd64/}\n ")
2189 serviceConfig.write("""export JAVA_OPTS="${JAVA_OPTS:--Xms""" + str(memory) + "G -Xmx" + str(memory) + """G}" \n """)
2190 serviceConfig.write("[ -d $ONOS_HOME ] && cd $ONOS_HOME || ONOS_HOME=$(dirname $0)/..\n")
2191 serviceConfig.write("""${ONOS_HOME}/apache-karaf-$KARAF_VERSION/bin/karaf "$@" \n """)
2192 serviceConfig.close()
2193
2194 def createDBFile(self, testData):
Jon Hall4ba53f02015-07-29 13:07:41 -07002195
cameron@onlab.us78b89652015-07-08 15:21:03 -07002196 filename = main.TEST + "DB"
2197 DBString = ""
Jon Hall4ba53f02015-07-29 13:07:41 -07002198
cameron@onlab.us78b89652015-07-08 15:21:03 -07002199 for item in testData:
Jon Hall4ba53f02015-07-29 13:07:41 -07002200 if type(item) is string:
cameron@onlab.us78b89652015-07-08 15:21:03 -07002201 item = "'" + item + "'"
2202 if testData.index(item) < len(testData-1):
2203 item += ","
Jon Hall4ba53f02015-07-29 13:07:41 -07002204 DBString += str(item)
cameron@onlab.us78b89652015-07-08 15:21:03 -07002205
2206 DBFile = open(filename, "a")
2207 DBFile.write(DBString)
2208 DBFile.close()
2209
Jon Hall4ba53f02015-07-29 13:07:41 -07002210 def verifySummary(self, ONOSIp,*deviceCount):
cameron@onlab.us78b89652015-07-08 15:21:03 -07002211
2212 self.handle.sendline("onos " + ONOSIp + " summary")
2213 self.handle.expect(":~")
2214
2215 summaryStr = self.handle.before
2216 print "\nSummary\n==============\n" + summaryStr + "\n\n"
2217
2218 #passed = "SCC(s)=1" in summaryStr
2219 #if deviceCount:
2220 # passed = "devices=" + str(deviceCount) + "," not in summaryStr
2221
Jon Hall4ba53f02015-07-29 13:07:41 -07002222
cameron@onlab.us78b89652015-07-08 15:21:03 -07002223 if "SCC(s)=1," in summaryStr:
2224 passed = True
2225 print("Summary is verifed")
Jon Hall4ba53f02015-07-29 13:07:41 -07002226 else:
2227 print("Summary failed")
cameron@onlab.us78b89652015-07-08 15:21:03 -07002228
2229 if deviceCount:
2230 print" ============================="
2231 checkStr = "devices=" + str(deviceCount[0]) + ","
2232 print "Checkstr: " + checkStr
2233 if checkStr not in summaryStr:
2234 passed = False
Jon Hall4ba53f02015-07-29 13:07:41 -07002235 print("Device count failed")
2236 else:
2237 print "device count verified"
cameron@onlab.us78b89652015-07-08 15:21:03 -07002238
2239 return passed