blob: 47baeb0a8115d43a4e8b73a36e39b2162fdaadf3 [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
Jeremy Songsterae01bba2016-07-11 15:39:17 -070017Modified 2016 by ON.Lab
18
19Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
20the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
21or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>
andrewonlabe8e56fd2014-10-09 17:12:44 -040022
kelvin8ec71442015-01-15 16:57:00 -080023"""
Jon Hall05b2b432014-10-08 19:53:25 -040024import time
Jon Hall6801cda2015-07-15 14:13:45 -070025import types
Jon Hall05b2b432014-10-08 19:53:25 -040026import pexpect
kelvin-onlaba4074292015-07-09 15:19:49 -070027import os
Jon Hall6c44c0b2016-04-20 15:21:00 -070028import re
29import subprocess
pingping-lin6d23d9e2015-02-02 16:54:24 -080030from requests.models import Response
Jon Hall05b2b432014-10-08 19:53:25 -040031from drivers.common.clidriver import CLI
32
kelvin8ec71442015-01-15 16:57:00 -080033class OnosDriver( CLI ):
Jon Hall05b2b432014-10-08 19:53:25 -040034
kelvin8ec71442015-01-15 16:57:00 -080035 def __init__( self ):
36 """
37 Initialize client
38 """
Jon Hallefbd9792015-03-05 16:11:36 -080039 self.name = None
40 self.home = None
41 self.handle = None
Jon Hall6c44c0b2016-04-20 15:21:00 -070042 self.nicAddr = None
kelvin8ec71442015-01-15 16:57:00 -080043 super( CLI, self ).__init__()
44
45 def connect( self, **connectargs ):
46 """
Jon Hall05b2b432014-10-08 19:53:25 -040047 Creates ssh handle for ONOS "bench".
kelvin-onlaba4074292015-07-09 15:19:49 -070048 NOTE:
49 The ip_address would come from the topo file using the host tag, the
50 value can be an environment variable as well as a "localhost" to get
51 the ip address needed to ssh to the "bench"
kelvin8ec71442015-01-15 16:57:00 -080052 """
Jon Hall05b2b432014-10-08 19:53:25 -040053 try:
54 for key in connectargs:
kelvin8ec71442015-01-15 16:57:00 -080055 vars( self )[ key ] = connectargs[ key ]
andrew@onlab.us3b087132015-03-11 15:00:08 -070056 self.home = "~/onos"
Jon Hall05b2b432014-10-08 19:53:25 -040057 for key in self.options:
58 if key == "home":
kelvin8ec71442015-01-15 16:57:00 -080059 self.home = self.options[ 'home' ]
Jon Hall05b2b432014-10-08 19:53:25 -040060 break
Jon Hall274b6642015-02-17 11:57:17 -080061 if self.home is None or self.home == "":
Jon Halle94919c2015-03-23 11:42:57 -070062 self.home = "~/onos"
Jon Hall21270ac2015-02-16 17:59:55 -080063
kelvin8ec71442015-01-15 16:57:00 -080064 self.name = self.options[ 'name' ]
kelvin-onlaba4074292015-07-09 15:19:49 -070065
kelvin-onlabc2b79102015-07-14 11:41:20 -070066 # The 'nodes' tag is optional and it is not required in .topo file
kelvin-onlaba4074292015-07-09 15:19:49 -070067 for key in self.options:
68 if key == "nodes":
kelvin-onlabc2b79102015-07-14 11:41:20 -070069 # Maximum number of ONOS nodes to run, if there is any
kelvin-onlaba4074292015-07-09 15:19:49 -070070 self.maxNodes = int( self.options[ 'nodes' ] )
71 break
72 self.maxNodes = None
73
kelvin-onlabc2b79102015-07-14 11:41:20 -070074 if self.maxNodes == None or self.maxNodes == "":
75 self.maxNodes = 100
kelvin-onlaba4074292015-07-09 15:19:49 -070076
kelvin-onlabc2b79102015-07-14 11:41:20 -070077
78 # Grabs all OC environment variables based on max number of nodes
kelvin-onlaba4074292015-07-09 15:19:49 -070079 self.onosIps = {} # Dictionary of all possible ONOS ip
80
81 try:
82 if self.maxNodes:
kelvin-onlaba4074292015-07-09 15:19:49 -070083 for i in range( self.maxNodes ):
84 envString = "OC" + str( i + 1 )
kelvin-onlabc2b79102015-07-14 11:41:20 -070085 # If there is no more OC# then break the loop
86 if os.getenv( envString ):
87 self.onosIps[ envString ] = os.getenv( envString )
88 else:
89 self.maxNodes = len( self.onosIps )
90 main.log.info( self.name +
91 ": Created cluster data with " +
92 str( self.maxNodes ) +
93 " maximum number" +
94 " of nodes" )
95 break
kelvin-onlaba4074292015-07-09 15:19:49 -070096
97 if not self.onosIps:
98 main.log.info( "Could not read any environment variable"
99 + " please load a cell file with all" +
100 " onos IP" )
Jon Hall5cf14d52015-07-16 12:15:19 -0700101 self.maxNodes = None
kelvin-onlaba4074292015-07-09 15:19:49 -0700102 else:
103 main.log.info( self.name + ": Found " +
104 str( self.onosIps.values() ) +
105 " ONOS IPs" )
kelvin-onlaba4074292015-07-09 15:19:49 -0700106 except KeyError:
107 main.log.info( "Invalid environment variable" )
108 except Exception as inst:
109 main.log.error( "Uncaught exception: " + str( inst ) )
110
111 try:
112 if os.getenv( str( self.ip_address ) ) != None:
113 self.ip_address = os.getenv( str( self.ip_address ) )
114 else:
115 main.log.info( self.name +
116 ": Trying to connect to " +
117 self.ip_address )
kelvin-onlaba4074292015-07-09 15:19:49 -0700118 except KeyError:
119 main.log.info( "Invalid host name," +
120 " connecting to local host instead" )
121 self.ip_address = 'localhost'
122 except Exception as inst:
123 main.log.error( "Uncaught exception: " + str( inst ) )
124
kelvin8ec71442015-01-15 16:57:00 -0800125 self.handle = super( OnosDriver, self ).connect(
126 user_name=self.user_name,
kelvin-onlab08679eb2015-01-21 16:11:48 -0800127 ip_address=self.ip_address,
kelvin-onlabd3b64892015-01-20 13:26:24 -0800128 port=self.port,
129 pwd=self.pwd,
130 home=self.home )
Jon Hall05b2b432014-10-08 19:53:25 -0400131
Jon Hall05b2b432014-10-08 19:53:25 -0400132 if self.handle:
Jon Hall0fc0d452015-07-14 09:49:58 -0700133 self.handle.sendline( "cd " + self.home )
134 self.handle.expect( "\$" )
Jon Hall05b2b432014-10-08 19:53:25 -0400135 return self.handle
kelvin8ec71442015-01-15 16:57:00 -0800136 else:
Jon Hall0fc0d452015-07-14 09:49:58 -0700137 main.log.info( "Failed to create ONOS handle" )
Jon Hall05b2b432014-10-08 19:53:25 -0400138 return main.FALSE
139 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800140 main.log.error( self.name + ": EOF exception found" )
141 main.log.error( self.name + ": " + self.handle.before )
Jon Hall05b2b432014-10-08 19:53:25 -0400142 main.cleanup()
143 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800144 except Exception:
145 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall05b2b432014-10-08 19:53:25 -0400146 main.cleanup()
147 main.exit()
148
kelvin8ec71442015-01-15 16:57:00 -0800149 def disconnect( self ):
150 """
Jon Hall05b2b432014-10-08 19:53:25 -0400151 Called when Test is complete to disconnect the ONOS handle.
kelvin8ec71442015-01-15 16:57:00 -0800152 """
Jon Halld61331b2015-02-17 16:35:47 -0800153 response = main.TRUE
Jon Hall05b2b432014-10-08 19:53:25 -0400154 try:
Jon Hall61282e32015-03-19 11:34:11 -0700155 if self.handle:
156 self.handle.sendline( "" )
157 self.handle.expect( "\$" )
158 self.handle.sendline( "exit" )
159 self.handle.expect( "closed" )
Jon Hall05b2b432014-10-08 19:53:25 -0400160 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800161 main.log.error( self.name + ": EOF exception found" )
162 main.log.error( self.name + ": " + self.handle.before )
Jon Hall61282e32015-03-19 11:34:11 -0700163 except ValueError:
Jon Hall1a77a1e2015-04-06 10:41:13 -0700164 main.log.exception( "Exception in disconnect of " + self.name )
Jon Hall61282e32015-03-19 11:34:11 -0700165 response = main.TRUE
Jon Hallfebb1c72015-03-05 13:30:09 -0800166 except Exception:
167 main.log.exception( self.name + ": Connection failed to the host" )
Jon Hall05b2b432014-10-08 19:53:25 -0400168 response = main.FALSE
169 return response
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400170
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400171 def getEpochMs( self ):
172 """
173 Returns milliseconds since epoch
Jon Hall4ba53f02015-07-29 13:07:41 -0700174
175 When checking multiple nodes in a for loop,
176 around a hundred milliseconds of difference (ascending) is
177 generally acceptable due to calltime of the function.
178 Few seconds, however, is not and it means clocks
179 are off sync.
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400180 """
181 try:
182 self.handle.sendline( 'date +%s.%N' )
183 self.handle.expect( 'date \+\%s\.\%N' )
184 self.handle.expect( '\$' )
185 epochMs = self.handle.before
186 return epochMs
187 except Exception:
188 main.log.exception( 'Uncaught exception getting epoch time' )
189 main.cleanup()
190 main.exit()
191
Jon Hall6c44c0b2016-04-20 15:21:00 -0700192 def onosPackage( self, opTimeout=180 ):
kelvin8ec71442015-01-15 16:57:00 -0800193 """
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400194 Produce a self-contained tar.gz file that can be deployed
Jon Hall64af8502015-12-15 10:09:33 -0800195 and executed on any platform with Java 8 JRE.
kelvin8ec71442015-01-15 16:57:00 -0800196 """
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400197 try:
Jon Hall64af8502015-12-15 10:09:33 -0800198 ret = main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800199 self.handle.sendline( "onos-package" )
200 self.handle.expect( "onos-package" )
Jon Hall96451092016-05-04 09:42:30 -0700201 while True:
202 i = self.handle.expect( [ "Downloading",
203 "Unknown options",
204 "No such file or directory",
205 "tar.gz",
206 "\$" ],
207 opTimeout )
208 handle = str( self.handle.before + self.handle.after )
209 if i == 0:
210 # Give more time to download the file
211 continue # expect again
212 elif i == 1:
213 # Incorrect usage
214 main.log.error( "onos-package does not recognize the given options" )
215 ret = main.FALSE
216 continue # expect again
217 elif i == 2:
218 # File(s) not found
219 main.log.error( "onos-package could not find a file or directory" )
220 ret = main.FALSE
221 continue # expect again
222 elif i == 3:
223 # tar.gz
224 continue # expect again
225 elif i == 4:
226 # Prompt returned
227 break
Jon Hallc6793552016-01-19 14:18:37 -0800228 main.log.info( "onos-package command returned: " + handle )
kelvin8ec71442015-01-15 16:57:00 -0800229 # As long as the sendline does not time out,
230 # return true. However, be careful to interpret
231 # the results of the onos-package command return
Jon Hall64af8502015-12-15 10:09:33 -0800232 return ret
233 except pexpect.TIMEOUT:
234 main.log.exception( self.name + ": TIMEOUT exception found in onosPackage" )
235 main.log.error( self.name + ": " + self.handle.before )
236 return main.FALSE
andrewonlab7735d852014-10-09 13:02:47 -0400237 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800238 main.log.error( self.name + ": EOF exception found" )
239 main.log.error( self.name + ": " + self.handle.before )
Jon Hall64af8502015-12-15 10:09:33 -0800240 main.cleanup()
241 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800242 except Exception:
243 main.log.exception( "Failed to package ONOS" )
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400244 main.cleanup()
245 main.exit()
246
kelvin-onlabd3b64892015-01-20 13:26:24 -0800247 def onosBuild( self ):
kelvin8ec71442015-01-15 16:57:00 -0800248 """
andrewonlab8790abb2014-11-06 13:51:54 -0500249 Use the pre defined script to build onos via mvn
kelvin8ec71442015-01-15 16:57:00 -0800250 """
andrewonlab8790abb2014-11-06 13:51:54 -0500251 try:
kelvin8ec71442015-01-15 16:57:00 -0800252 self.handle.sendline( "onos-build" )
253 self.handle.expect( "onos-build" )
254 i = self.handle.expect( [
kelvin-onlabd3b64892015-01-20 13:26:24 -0800255 "BUILD SUCCESS",
256 "ERROR",
257 "BUILD FAILED" ],
258 timeout=120 )
kelvin8ec71442015-01-15 16:57:00 -0800259 handle = str( self.handle.before )
Jon Hall3b489db2015-10-05 14:38:37 -0700260 self.handle.expect( "\$" )
andrewonlab8790abb2014-11-06 13:51:54 -0500261
kelvin8ec71442015-01-15 16:57:00 -0800262 main.log.info( "onos-build command returned: " +
263 handle )
andrewonlab8790abb2014-11-06 13:51:54 -0500264
265 if i == 0:
266 return main.TRUE
267 else:
268 return handle
269
270 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800271 main.log.error( self.name + ": EOF exception found" )
272 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -0800273 except Exception:
274 main.log.exception( "Failed to build ONOS" )
andrewonlab8790abb2014-11-06 13:51:54 -0500275 main.cleanup()
276 main.exit()
277
shahshreya9f531fe2015-06-10 12:03:51 -0700278 def cleanInstall( self, skipTest=False, mciTimeout=600 ):
kelvin8ec71442015-01-15 16:57:00 -0800279 """
280 Runs mvn clean install in the root of the ONOS directory.
281 This will clean all ONOS artifacts then compile each module
shahshreya9f531fe2015-06-10 12:03:51 -0700282 Optional:
283 skipTest - Does "-DskipTests -Dcheckstyle.skip -U -T 1C" which
284 skip the test. This will make the building faster.
285 Disregarding the credibility of the build
kelvin8ec71442015-01-15 16:57:00 -0800286 Returns: main.TRUE on success
Jon Hallde9d9aa2014-10-08 20:36:02 -0400287 On Failure, exits the test
kelvin8ec71442015-01-15 16:57:00 -0800288 """
Jon Hallde9d9aa2014-10-08 20:36:02 -0400289 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800290 main.log.info( "Running 'mvn clean install' on " +
291 str( self.name ) +
kelvin8ec71442015-01-15 16:57:00 -0800292 ". This may take some time." )
293 self.handle.sendline( "cd " + self.home )
294 self.handle.expect( "\$" )
Jon Hallea7818b2014-10-09 14:30:59 -0400295
kelvin8ec71442015-01-15 16:57:00 -0800296 self.handle.sendline( "" )
297 self.handle.expect( "\$" )
shahshreya9f531fe2015-06-10 12:03:51 -0700298
299 if not skipTest:
300 self.handle.sendline( "mvn clean install" )
301 self.handle.expect( "mvn clean install" )
302 else:
303 self.handle.sendline( "mvn clean install -DskipTests" +
304 " -Dcheckstyle.skip -U -T 1C" )
305 self.handle.expect( "mvn clean install -DskipTests" +
306 " -Dcheckstyle.skip -U -T 1C" )
kelvin8ec71442015-01-15 16:57:00 -0800307 while True:
308 i = self.handle.expect( [
Jon Hall274b6642015-02-17 11:57:17 -0800309 'There\sis\sinsufficient\smemory\sfor\sthe\sJava\s' +
Jon Hallefbd9792015-03-05 16:11:36 -0800310 'Runtime\sEnvironment\sto\scontinue',
Jon Hallde9d9aa2014-10-08 20:36:02 -0400311 'BUILD\sFAILURE',
312 'BUILD\sSUCCESS',
Jon Halle94919c2015-03-23 11:42:57 -0700313 'onos\$', #TODO: fix this to be more generic?
Jon Hallde9d9aa2014-10-08 20:36:02 -0400314 'ONOS\$',
pingping-lin57a56ce2015-05-20 16:43:48 -0700315 pexpect.TIMEOUT ], mciTimeout )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400316 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -0800317 main.log.error( self.name + ":There is insufficient memory \
318 for the Java Runtime Environment to continue." )
319 # return main.FALSE
Jon Hallde9d9aa2014-10-08 20:36:02 -0400320 main.cleanup()
321 main.exit()
322 if i == 1:
kelvin8ec71442015-01-15 16:57:00 -0800323 main.log.error( self.name + ": Build failure!" )
324 # return main.FALSE
Jon Hallde9d9aa2014-10-08 20:36:02 -0400325 main.cleanup()
326 main.exit()
327 elif i == 2:
kelvin8ec71442015-01-15 16:57:00 -0800328 main.log.info( self.name + ": Build success!" )
Jon Halle94919c2015-03-23 11:42:57 -0700329 elif i == 3 or i == 4:
kelvin8ec71442015-01-15 16:57:00 -0800330 main.log.info( self.name + ": Build complete" )
331 # Print the build time
Jon Hallf8ef52c2014-10-09 19:37:33 -0400332 for line in self.handle.before.splitlines():
333 if "Total time:" in line:
kelvin8ec71442015-01-15 16:57:00 -0800334 main.log.info( line )
335 self.handle.sendline( "" )
336 self.handle.expect( "\$", timeout=60 )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400337 return main.TRUE
Jon Halle94919c2015-03-23 11:42:57 -0700338 elif i == 5:
kelvin8ec71442015-01-15 16:57:00 -0800339 main.log.error(
340 self.name +
341 ": mvn clean install TIMEOUT!" )
342 # return main.FALSE
Jon Hallde9d9aa2014-10-08 20:36:02 -0400343 main.cleanup()
344 main.exit()
345 else:
Jon Hall274b6642015-02-17 11:57:17 -0800346 main.log.error( self.name + ": unexpected response from " +
Jon Hallefbd9792015-03-05 16:11:36 -0800347 "mvn clean install" )
kelvin8ec71442015-01-15 16:57:00 -0800348 # return main.FALSE
Jon Hallde9d9aa2014-10-08 20:36:02 -0400349 main.cleanup()
350 main.exit()
351 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800352 main.log.error( self.name + ": EOF exception found" )
353 main.log.error( self.name + ": " + self.handle.before )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400354 main.cleanup()
355 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800356 except Exception:
357 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400358 main.cleanup()
359 main.exit()
Jon Hallacabffd2014-10-09 12:36:53 -0400360
Jon Hall3576f572016-08-23 10:01:07 -0700361 def buckBuild( self, timeout=180 ):
362 """
363 Build onos using buck.
364 """
365 try:
366 ret = main.TRUE
367 self.handle.sendline( "buck build onos" )
368 self.handle.expect( "buck build onos" )
369 output = ""
370 while True:
371 i = self.handle.expect( [ "This does not appear to be the root of a Buck project.",
372 "\n",
373 "BUILD FAILED",
374 "\$" ],
375 timeout=timeout )
376 output += str( self.handle.before + self.handle.after )
377 if i == 0:
378 main.log.error( "Wrong location" )
379 ret = main.FALSE
380 elif i == 1:
381 # end of a line, buck is still printing output
382 pass
383 elif i == 2:
384 # Build failed
385 main.log.error( "Build failed" )
386 ret = main.FALSE
387 elif i == 3:
388 # Prompt returned
389 break
390 main.log.debug( output )
391 return ret
392 except pexpect.TIMEOUT:
393 main.log.exception( self.name + ": TIMEOUT exception found" )
394 main.log.error( self.name + ": " + self.handle.before )
395 return main.FALSE
396 except pexpect.EOF:
397 main.log.error( self.name + ": EOF exception found" )
398 main.log.error( self.name + ": " + self.handle.before )
399 main.cleanup()
400 main.exit()
401 except Exception:
402 main.log.exception( "Failed to build and package ONOS" )
403 main.cleanup()
404 main.exit()
405
Jon Hall61282e32015-03-19 11:34:11 -0700406 def gitPull( self, comp1="", fastForward=True ):
kelvin8ec71442015-01-15 16:57:00 -0800407 """
Jon Hallacabffd2014-10-09 12:36:53 -0400408 Assumes that "git pull" works without login
Jon Hall47a93fb2015-01-06 16:46:06 -0800409
Jon Hall61282e32015-03-19 11:34:11 -0700410 If the fastForward boolean is set to true, only git pulls that can
411 be fast forwarded will be performed. IE if you have not local commits
412 in your branch.
413
Jon Hallacabffd2014-10-09 12:36:53 -0400414 This function will perform a git pull on the ONOS instance.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800415 If used as gitPull( "NODE" ) it will do git pull + NODE. This is
Jon Hallacabffd2014-10-09 12:36:53 -0400416 for the purpose of pulling from other nodes if necessary.
417
Jon Hall47a93fb2015-01-06 16:46:06 -0800418 Otherwise, this function will perform a git pull in the
Jon Hallacabffd2014-10-09 12:36:53 -0400419 ONOS repository. If it has any problems, it will return main.ERROR
kelvin-onlabd3b64892015-01-20 13:26:24 -0800420 If it successfully does a gitPull, it will return a 1 ( main.TRUE )
Shreya Shahee15f6c2014-10-28 18:12:30 -0400421 If it has no updates, it will return 3.
Jon Hallacabffd2014-10-09 12:36:53 -0400422
kelvin8ec71442015-01-15 16:57:00 -0800423 """
Jon Hallacabffd2014-10-09 12:36:53 -0400424 try:
kelvin8ec71442015-01-15 16:57:00 -0800425 self.handle.sendline( "cd " + self.home )
kelvin-onlaba1484582015-02-02 15:46:20 -0800426 self.handle.expect( self.home + "\$" )
Jon Hall61282e32015-03-19 11:34:11 -0700427 cmd = "git pull"
428 if comp1 != "":
429 cmd += ' ' + comp1
430 if fastForward:
431 cmd += ' ' + " --ff-only"
432 self.handle.sendline( cmd )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800433 i = self.handle.expect(
434 [
435 'fatal',
436 'Username\sfor\s(.*):\s',
437 '\sfile(s*) changed,\s',
438 'Already up-to-date',
439 'Aborting',
440 'You\sare\snot\scurrently\son\sa\sbranch',
Jon Hall274b6642015-02-17 11:57:17 -0800441 'You asked me to pull without telling me which branch you',
442 'Pull is not possible because you have unmerged files',
Jon Hall61282e32015-03-19 11:34:11 -0700443 'Please enter a commit message to explain why this merge',
444 'Found a swap file by the name',
445 'Please, commit your changes before you can merge.',
kelvin-onlabd3b64892015-01-20 13:26:24 -0800446 pexpect.TIMEOUT ],
447 timeout=300 )
kelvin8ec71442015-01-15 16:57:00 -0800448 if i == 0:
Jon Hall61282e32015-03-19 11:34:11 -0700449 main.log.error( self.name + ": Git pull had some issue" )
450 output = self.handle.after
451 self.handle.expect( '\$' )
452 output += self.handle.before
453 main.log.warn( output )
Jon Hallacabffd2014-10-09 12:36:53 -0400454 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800455 elif i == 1:
456 main.log.error(
457 self.name +
458 ": Git Pull Asking for username. " )
Jon Hallacabffd2014-10-09 12:36:53 -0400459 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800460 elif i == 2:
461 main.log.info(
462 self.name +
463 ": Git Pull - pulling repository now" )
kelvin-onlaba1484582015-02-02 15:46:20 -0800464 self.handle.expect( self.home + "\$", 120 )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800465 # So that only when git pull is done, we do mvn clean compile
466 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800467 elif i == 3:
468 main.log.info( self.name + ": Git Pull - Already up to date" )
Jon Hall47a93fb2015-01-06 16:46:06 -0800469 return i
kelvin8ec71442015-01-15 16:57:00 -0800470 elif i == 4:
471 main.log.info(
472 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800473 ": Git Pull - Aborting..." +
474 "Are there conflicting git files?" )
Jon Hallacabffd2014-10-09 12:36:53 -0400475 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800476 elif i == 5:
477 main.log.info(
478 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800479 ": Git Pull - You are not currently " +
480 "on a branch so git pull failed!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400481 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800482 elif i == 6:
483 main.log.info(
484 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800485 ": Git Pull - You have not configured an upstream " +
486 "branch to pull from. Git pull failed!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400487 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800488 elif i == 7:
489 main.log.info(
490 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800491 ": Git Pull - Pull is not possible because " +
492 "you have unmerged files." )
Jon Hallacabffd2014-10-09 12:36:53 -0400493 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800494 elif i == 8:
Jon Hall61282e32015-03-19 11:34:11 -0700495 # NOTE: abandoning test since we can't reliably handle this
496 # there could be different default text editors and we
497 # also don't know if we actually want to make the commit
498 main.log.error( "Git pull resulted in a merge commit message" +
499 ". Exiting test!" )
500 main.cleanup()
501 main.exit()
502 elif i == 9: # Merge commit message but swap file exists
503 main.log.error( "Git pull resulted in a merge commit message" +
504 " but a swap file exists." )
505 try:
506 self.handle.send( 'A' ) # Abort
507 self.handle.expect( "\$" )
508 return main.ERROR
509 except Exception:
510 main.log.exception( "Couldn't exit editor prompt!")
511 main.cleanup()
512 main.exit()
513 elif i == 10: # In the middle of a merge commit
514 main.log.error( "Git branch is in the middle of a merge. " )
515 main.log.warn( self.handle.before + self.handle.after )
516 return main.ERROR
517 elif i == 11:
kelvin8ec71442015-01-15 16:57:00 -0800518 main.log.error( self.name + ": Git Pull - TIMEOUT" )
519 main.log.error(
520 self.name + " Response was: " + str(
521 self.handle.before ) )
Jon Hallacabffd2014-10-09 12:36:53 -0400522 return main.ERROR
523 else:
kelvin8ec71442015-01-15 16:57:00 -0800524 main.log.error(
525 self.name +
526 ": Git Pull - Unexpected response, check for pull errors" )
Jon Hallacabffd2014-10-09 12:36:53 -0400527 return main.ERROR
528 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800529 main.log.error( self.name + ": EOF exception found" )
530 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400531 main.cleanup()
532 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800533 except Exception:
534 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400535 main.cleanup()
536 main.exit()
537
kelvin-onlabd3b64892015-01-20 13:26:24 -0800538 def gitCheckout( self, branch="master" ):
kelvin8ec71442015-01-15 16:57:00 -0800539 """
Jon Hallacabffd2014-10-09 12:36:53 -0400540 Assumes that "git pull" works without login
kelvin8ec71442015-01-15 16:57:00 -0800541
Jon Hallacabffd2014-10-09 12:36:53 -0400542 This function will perform a git git checkout on the ONOS instance.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800543 If used as gitCheckout( "branch" ) it will do git checkout
544 of the "branch".
Jon Hallacabffd2014-10-09 12:36:53 -0400545
546 Otherwise, this function will perform a git checkout of the master
kelvin8ec71442015-01-15 16:57:00 -0800547 branch of the ONOS repository. If it has any problems, it will return
548 main.ERROR.
549 If the branch was already the specified branch, or the git checkout was
Jon Hallacabffd2014-10-09 12:36:53 -0400550 successful then the function will return main.TRUE.
551
kelvin8ec71442015-01-15 16:57:00 -0800552 """
Jon Hallacabffd2014-10-09 12:36:53 -0400553 try:
kelvin8ec71442015-01-15 16:57:00 -0800554 self.handle.sendline( "cd " + self.home )
kelvin-onlaba1484582015-02-02 15:46:20 -0800555 self.handle.expect( self.home + "\$" )
Jon Hall274b6642015-02-17 11:57:17 -0800556 main.log.info( self.name +
557 ": Checking out git branch/ref: " + branch + "..." )
kelvin8ec71442015-01-15 16:57:00 -0800558 cmd = "git checkout " + branch
559 self.handle.sendline( cmd )
560 self.handle.expect( cmd )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800561 i = self.handle.expect(
Jon Hall274b6642015-02-17 11:57:17 -0800562 [ 'fatal',
Jon Hall61282e32015-03-19 11:34:11 -0700563 'Username for (.*): ',
564 'Already on \'',
Jon Hall7a8354f2015-06-10 15:37:00 -0700565 'Switched to (a new )?branch \'' + str( branch ),
Jon Hall274b6642015-02-17 11:57:17 -0800566 pexpect.TIMEOUT,
567 'error: Your local changes to the following files' +
Jon Hallefbd9792015-03-05 16:11:36 -0800568 'would be overwritten by checkout:',
Jon Hall274b6642015-02-17 11:57:17 -0800569 'error: you need to resolve your current index first',
570 "You are in 'detached HEAD' state.",
571 "HEAD is now at " ],
kelvin-onlabd3b64892015-01-20 13:26:24 -0800572 timeout=60 )
kelvin8ec71442015-01-15 16:57:00 -0800573 if i == 0:
574 main.log.error(
575 self.name +
576 ": Git checkout had some issue..." )
577 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400578 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800579 elif i == 1:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800580 main.log.error(
581 self.name +
582 ": Git checkout asking for username." +
583 " Please configure your local git repository to be able " +
584 "to access your remote repository passwordlessly" )
Jon Hall274b6642015-02-17 11:57:17 -0800585 # TODO add support for authenticating
Jon Hallacabffd2014-10-09 12:36:53 -0400586 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800587 elif i == 2:
588 main.log.info(
589 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800590 ": Git Checkout %s : Already on this branch" % branch )
kelvin-onlaba1484582015-02-02 15:46:20 -0800591 self.handle.expect( self.home + "\$" )
kelvin8ec71442015-01-15 16:57:00 -0800592 # main.log.info( "DEBUG: after checkout cmd = "+
593 # self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400594 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800595 elif i == 3:
596 main.log.info(
597 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800598 ": Git checkout %s - Switched to this branch" % branch )
kelvin-onlaba1484582015-02-02 15:46:20 -0800599 self.handle.expect( self.home + "\$" )
kelvin8ec71442015-01-15 16:57:00 -0800600 # main.log.info( "DEBUG: after checkout cmd = "+
601 # self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400602 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800603 elif i == 4:
604 main.log.error( self.name + ": Git Checkout- TIMEOUT" )
605 main.log.error(
Jon Hall274b6642015-02-17 11:57:17 -0800606 self.name + " Response was: " + str( self.handle.before ) )
Jon Hallacabffd2014-10-09 12:36:53 -0400607 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800608 elif i == 5:
609 self.handle.expect( "Aborting" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800610 main.log.error(
611 self.name +
612 ": Git checkout error: \n" +
Jon Hall274b6642015-02-17 11:57:17 -0800613 "Your local changes to the following files would" +
614 " be overwritten by checkout:" +
615 str( self.handle.before ) )
kelvin-onlaba1484582015-02-02 15:46:20 -0800616 self.handle.expect( self.home + "\$" )
Jon Hall81e29af2014-11-04 20:41:23 -0500617 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800618 elif i == 6:
Jon Hall274b6642015-02-17 11:57:17 -0800619 main.log.error(
620 self.name +
621 ": Git checkout error: \n" +
622 "You need to resolve your current index first:" +
623 str( self.handle.before ) )
kelvin-onlaba1484582015-02-02 15:46:20 -0800624 self.handle.expect( self.home + "\$" )
Jon Hall81e29af2014-11-04 20:41:23 -0500625 return main.ERROR
Jon Hall274b6642015-02-17 11:57:17 -0800626 elif i == 7:
627 main.log.info(
628 self.name +
629 ": Git checkout " + str( branch ) +
630 " - You are in 'detached HEAD' state. HEAD is now at " +
631 str( branch ) )
632 self.handle.expect( self.home + "\$" )
633 return main.TRUE
634 elif i == 8: # Already in detached HEAD on the specified commit
635 main.log.info(
636 self.name +
637 ": Git Checkout %s : Already on commit" % branch )
638 self.handle.expect( self.home + "\$" )
639 return main.TRUE
Jon Hallacabffd2014-10-09 12:36:53 -0400640 else:
kelvin8ec71442015-01-15 16:57:00 -0800641 main.log.error(
642 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800643 ": Git Checkout - Unexpected response, " +
644 "check for pull errors" )
kelvin8ec71442015-01-15 16:57:00 -0800645 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400646 return main.ERROR
647
648 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800649 main.log.error( self.name + ": EOF exception found" )
650 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400651 main.cleanup()
652 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800653 except Exception:
654 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400655 main.cleanup()
656 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -0400657
pingping-lin6d23d9e2015-02-02 16:54:24 -0800658 def getBranchName( self ):
pingping-linf30cf272015-05-29 15:54:07 -0700659 main.log.info( "self.home = " )
660 main.log.info( self.home )
pingping-lin6d23d9e2015-02-02 16:54:24 -0800661 self.handle.sendline( "cd " + self.home )
pingping-lin9bf3d8f2015-05-29 16:05:28 -0700662 self.handle.expect( self.home + "\$" )
pingping-lin6d23d9e2015-02-02 16:54:24 -0800663 self.handle.sendline( "git name-rev --name-only HEAD" )
664 self.handle.expect( "git name-rev --name-only HEAD" )
665 self.handle.expect( "\$" )
666
667 lines = self.handle.before.splitlines()
668 if lines[1] == "master":
669 return "master"
670 elif lines[1] == "onos-1.0":
671 return "onos-1.0"
672 else:
673 main.log.info( lines[1] )
674 return "unexpected ONOS branch for SDN-IP test"
675
kelvin-onlabd3b64892015-01-20 13:26:24 -0800676 def getVersion( self, report=False ):
kelvin8ec71442015-01-15 16:57:00 -0800677 """
Jon Hall274b6642015-02-17 11:57:17 -0800678 Writes the COMMIT number to the report to be parsed
Jon Hallefbd9792015-03-05 16:11:36 -0800679 by Jenkins data collector.
kelvin8ec71442015-01-15 16:57:00 -0800680 """
Jon Hall45ec0922014-10-10 19:33:49 -0400681 try:
kelvin8ec71442015-01-15 16:57:00 -0800682 self.handle.sendline( "" )
683 self.handle.expect( "\$" )
684 self.handle.sendline(
685 "cd " +
686 self.home +
Jon Hall274b6642015-02-17 11:57:17 -0800687 "; git log -1 --pretty=fuller --decorate=short | grep -A 6 " +
688 " \"commit\" --color=never" )
kelvin8ec71442015-01-15 16:57:00 -0800689 # NOTE: for some reason there are backspaces inserted in this
690 # phrase when run from Jenkins on some tests
691 self.handle.expect( "never" )
692 self.handle.expect( "\$" )
693 response = ( self.name + ": \n" + str(
694 self.handle.before + self.handle.after ) )
695 self.handle.sendline( "cd " + self.home )
696 self.handle.expect( "\$" )
697 lines = response.splitlines()
Jon Hall45ec0922014-10-10 19:33:49 -0400698 for line in lines:
Jon Hallfd191202014-11-07 18:36:09 -0500699 print line
700 if report:
pingping-lin763ee042015-05-20 17:45:30 -0700701 main.log.wiki( "<blockquote>" )
kelvin8ec71442015-01-15 16:57:00 -0800702 for line in lines[ 2:-1 ]:
703 # Bracket replacement is for Wiki-compliant
704 # formatting. '<' or '>' are interpreted
705 # as xml specific tags that cause errors
706 line = line.replace( "<", "[" )
707 line = line.replace( ">", "]" )
pingping-lin763ee042015-05-20 17:45:30 -0700708 #main.log.wiki( "\t" + line )
709 main.log.wiki( line + "<br /> " )
710 main.log.summary( line )
711 main.log.wiki( "</blockquote>" )
712 main.log.summary("\n")
kelvin8ec71442015-01-15 16:57:00 -0800713 return lines[ 2 ]
Jon Hall45ec0922014-10-10 19:33:49 -0400714 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800715 main.log.error( self.name + ": EOF exception found" )
716 main.log.error( self.name + ": " + self.handle.before )
Jon Hall45ec0922014-10-10 19:33:49 -0400717 main.cleanup()
718 main.exit()
Jon Hall368769f2014-11-19 15:43:35 -0800719 except pexpect.TIMEOUT:
kelvin8ec71442015-01-15 16:57:00 -0800720 main.log.error( self.name + ": TIMEOUT exception found" )
721 main.log.error( self.name + ": " + self.handle.before )
Jon Hall368769f2014-11-19 15:43:35 -0800722 main.cleanup()
723 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800724 except Exception:
725 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall45ec0922014-10-10 19:33:49 -0400726 main.cleanup()
727 main.exit()
728
kelvin-onlabd3b64892015-01-20 13:26:24 -0800729 def createCellFile( self, benchIp, fileName, mnIpAddrs,
Jon Hall810b67d2016-12-05 10:19:01 -0800730 appString, onosIpAddrs, onosUser="sdn", useSSH=True ):
kelvin8ec71442015-01-15 16:57:00 -0800731 """
andrewonlab94282092014-10-10 13:00:11 -0400732 Creates a cell file based on arguments
733 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800734 * Bench IP address ( benchIp )
andrewonlab94282092014-10-10 13:00:11 -0400735 - Needed to copy the cell file over
kelvin-onlabd3b64892015-01-20 13:26:24 -0800736 * File name of the cell file ( fileName )
737 * Mininet IP address ( mnIpAddrs )
kelvin8ec71442015-01-15 16:57:00 -0800738 - Note that only 1 ip address is
andrewonlab94282092014-10-10 13:00:11 -0400739 supported currently
kelvin-onlabd3b64892015-01-20 13:26:24 -0800740 * ONOS IP addresses ( onosIpAddrs )
andrewonlab94282092014-10-10 13:00:11 -0400741 - Must be passed in as last arguments
Flavio Castrocc38a542016-03-03 13:15:46 -0800742 * ONOS USER (onosUser)
743 - optional argument to set ONOS_USER environment variable
kelvin8ec71442015-01-15 16:57:00 -0800744
andrewonlab94282092014-10-10 13:00:11 -0400745 NOTE: Assumes cells are located at:
746 ~/<self.home>/tools/test/cells/
kelvin8ec71442015-01-15 16:57:00 -0800747 """
andrewonlab94282092014-10-10 13:00:11 -0400748 try:
Jon Hall2c8959e2016-12-16 12:17:34 -0800749 # Variable initialization
750 cellDirectory = self.home + "/tools/test/cells/"
751 # We want to create the cell file in the dependencies directory
752 # of TestON first, then copy over to ONOS bench
753 tempDirectory = "/tmp/"
754 # Create the cell file in the directory for writing ( w+ )
755 cellFile = open( tempDirectory + fileName, 'w+' )
756 if isinstance( onosIpAddrs, types.StringType ):
757 onosIpAddrs = [ onosIpAddrs ]
758
759 # App string is hardcoded environment variables
760 # That you may wish to use by default on startup.
761 # Note that you may not want certain apps listed
762 # on here.
763 appString = "export ONOS_APPS=" + appString
764 onosGroup = "export ONOS_GROUP=" + onosUser
765 onosUser = "export ONOS_USER=" + onosUser
766 if useSSH:
767 onosUseSSH = "export ONOS_USE_SSH=true"
768 mnString = "export OCN="
769 if mnIpAddrs == "":
770 mnString = ""
771 onosString = "export OC"
772 tempCount = 1
773
774 # Create ONOSNIC ip address prefix
775 tempOnosIp = str( onosIpAddrs[ 0 ] )
776 tempList = []
777 tempList = tempOnosIp.split( "." )
778 # Omit last element of list to format for NIC
779 tempList = tempList[ :-1 ]
780 # Structure the nic string ip
781 nicAddr = ".".join( tempList ) + ".*"
782 self.nicAddr = nicAddr
783 onosNicString = "export ONOS_NIC=" + nicAddr
784
kelvin8ec71442015-01-15 16:57:00 -0800785 # Start writing to file
kelvin-onlabd3b64892015-01-20 13:26:24 -0800786 cellFile.write( onosNicString + "\n" )
andrewonlab94282092014-10-10 13:00:11 -0400787
kelvin-onlabd3b64892015-01-20 13:26:24 -0800788 for arg in onosIpAddrs:
789 # For each argument in onosIpAddrs, write to file
kelvin8ec71442015-01-15 16:57:00 -0800790 # Output should look like the following:
andrewonlabd4940492014-10-24 12:21:27 -0400791 # export OC1="10.128.20.11"
792 # export OC2="10.128.20.12"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800793 cellFile.write( onosString + str( tempCount ) +
Jon Hall6f665652015-09-18 10:08:07 -0700794 "=\"" + arg + "\"\n" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800795 tempCount = tempCount + 1
kelvin8ec71442015-01-15 16:57:00 -0800796
Jon Hall6f665652015-09-18 10:08:07 -0700797 cellFile.write( "export OCI=$OC1\n" )
798 cellFile.write( mnString + "\"" + mnIpAddrs + "\"\n" )
cameron@onlab.us75900962015-03-30 13:22:49 -0700799 cellFile.write( appString + "\n" )
Flavio Castrocc38a542016-03-03 13:15:46 -0800800 cellFile.write( onosGroup + "\n" )
801 cellFile.write( onosUser + "\n" )
Pier88189b62016-09-07 17:01:53 -0700802 if useSSH:
803 cellFile.write( onosUseSSH + "\n" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800804 cellFile.close()
andrewonlab94282092014-10-10 13:00:11 -0400805
kelvin8ec71442015-01-15 16:57:00 -0800806 # We use os.system to send the command to TestON cluster
807 # to account for the case in which TestON is not located
808 # on the same cluster as the ONOS bench
809 # Note that even if TestON is located on the same cluster
810 # as ONOS bench, you must setup passwordless ssh
811 # between TestON and ONOS bench in order to automate the test.
kelvin-onlabc2b79102015-07-14 11:41:20 -0700812 os.system( "scp " + tempDirectory + fileName + " " +
813 self.user_name + "@" + self.ip_address + ":" + cellDirectory )
andrewonlab94282092014-10-10 13:00:11 -0400814
andrewonlab2a6c9342014-10-16 13:40:15 -0400815 return main.TRUE
816
andrewonlab94282092014-10-10 13:00:11 -0400817 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800818 main.log.error( self.name + ": EOF exception found" )
819 main.log.error( self.name + ": " + self.handle.before )
andrewonlab94282092014-10-10 13:00:11 -0400820 main.cleanup()
821 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800822 except Exception:
823 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab94282092014-10-10 13:00:11 -0400824 main.cleanup()
825 main.exit()
826
kelvin-onlabd3b64892015-01-20 13:26:24 -0800827 def setCell( self, cellname ):
kelvin8ec71442015-01-15 16:57:00 -0800828 """
andrewonlab95ca1462014-10-09 14:04:24 -0400829 Calls 'cell <name>' to set the environment variables on ONOSbench
kelvin8ec71442015-01-15 16:57:00 -0800830 """
Hari Krishna03f530e2015-07-10 17:28:27 -0700831 import re
andrewonlab95ca1462014-10-09 14:04:24 -0400832 try:
833 if not cellname:
kelvin8ec71442015-01-15 16:57:00 -0800834 main.log.error( "Must define cellname" )
andrewonlab95ca1462014-10-09 14:04:24 -0400835 main.cleanup()
836 main.exit()
837 else:
kelvin8ec71442015-01-15 16:57:00 -0800838 self.handle.sendline( "cell " + str( cellname ) )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800839 # Expect the cellname in the ONOSCELL variable.
kelvin8ec71442015-01-15 16:57:00 -0800840 # Note that this variable name is subject to change
andrewonlab95ca1462014-10-09 14:04:24 -0400841 # and that this driver will have to change accordingly
Jon Hall3b489db2015-10-05 14:38:37 -0700842 self.handle.expect( str( cellname ) )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800843 handleBefore = self.handle.before
844 handleAfter = self.handle.after
kelvin8ec71442015-01-15 16:57:00 -0800845 # Get the rest of the handle
Jon Hall3b489db2015-10-05 14:38:37 -0700846 self.handle.expect( "\$" )
Jon Hall439c8912016-04-15 02:22:03 -0700847 time.sleep(10)
kelvin-onlabd3b64892015-01-20 13:26:24 -0800848 handleMore = self.handle.before
andrewonlab95ca1462014-10-09 14:04:24 -0400849
Hari Krishna03f530e2015-07-10 17:28:27 -0700850 cell_result = handleBefore + handleAfter + handleMore
suibin zhang116647a2016-05-06 16:30:09 -0700851 #print cell_result
Hari Krishna03f530e2015-07-10 17:28:27 -0700852 if( re.search( "No such cell", cell_result ) ):
853 main.log.error( "Cell call returned: " + handleBefore +
kelvin-onlabd3b64892015-01-20 13:26:24 -0800854 handleAfter + handleMore )
Hari Krishna03f530e2015-07-10 17:28:27 -0700855 main.cleanup()
856 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -0400857 return main.TRUE
andrewonlab95ca1462014-10-09 14:04:24 -0400858 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800859 main.log.error( self.name + ": EOF exception found" )
860 main.log.error( self.name + ": " + self.handle.before )
andrewonlab95ca1462014-10-09 14:04:24 -0400861 main.cleanup()
862 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800863 except Exception:
864 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ca1462014-10-09 14:04:24 -0400865 main.cleanup()
866 main.exit()
867
kelvin-onlabd3b64892015-01-20 13:26:24 -0800868 def verifyCell( self ):
kelvin8ec71442015-01-15 16:57:00 -0800869 """
andrewonlabc03bf6c2014-10-09 14:56:18 -0400870 Calls 'onos-verify-cell' to check for cell installation
kelvin8ec71442015-01-15 16:57:00 -0800871 """
872 # TODO: Add meaningful expect value
andrewonlab8d0d7d72014-10-09 16:33:15 -0400873
andrewonlabc03bf6c2014-10-09 14:56:18 -0400874 try:
kelvin8ec71442015-01-15 16:57:00 -0800875 # Clean handle by sending empty and expecting $
876 self.handle.sendline( "" )
877 self.handle.expect( "\$" )
878 self.handle.sendline( "onos-verify-cell" )
879 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800880 handleBefore = self.handle.before
881 handleAfter = self.handle.after
kelvin-onlabd3b64892015-01-20 13:26:24 -0800882 main.log.info( "Verify cell returned: " + handleBefore +
Jon Hall3b489db2015-10-05 14:38:37 -0700883 handleAfter )
andrewonlabc03bf6c2014-10-09 14:56:18 -0400884 return main.TRUE
Jon Halla5cb6172015-02-23 09:28:28 -0800885 except pexpect.ExceptionPexpect as e:
Jon Hall3b489db2015-10-05 14:38:37 -0700886 main.log.exception( self.name + ": Pexpect exception found: " )
kelvin8ec71442015-01-15 16:57:00 -0800887 main.log.error( self.name + ": " + self.handle.before )
Jon Hall7993bfc2014-10-09 16:30:14 -0400888 main.cleanup()
889 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800890 except Exception:
891 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall7993bfc2014-10-09 16:30:14 -0400892 main.cleanup()
893 main.exit()
894
jenkins1e99e7b2015-04-02 18:15:39 -0700895 def onosCfgSet( self, ONOSIp, configName, configParam ):
896 """
897 Uses 'onos <node-ip> cfg set' to change a parameter value of an
Jon Hall4ba53f02015-07-29 13:07:41 -0700898 application.
899
jenkins1e99e7b2015-04-02 18:15:39 -0700900 ex)
901 onos 10.0.0.1 cfg set org.onosproject.myapp appSetting 1
jenkins1e99e7b2015-04-02 18:15:39 -0700902 ONOSIp = '10.0.0.1'
903 configName = 'org.onosproject.myapp'
904 configParam = 'appSetting 1'
jenkins1e99e7b2015-04-02 18:15:39 -0700905 """
Jon Hall72280bc2016-01-25 14:29:05 -0800906 try:
907 cfgStr = "onos {} cfg set {} {}".format( ONOSIp,
908 configName,
909 configParam )
910 self.handle.sendline( "" )
911 self.handle.expect( ":~" )
912 self.handle.sendline( cfgStr )
913 self.handle.expect("cfg set")
914 self.handle.expect( ":~" )
jenkins1e99e7b2015-04-02 18:15:39 -0700915
Jon Hall72280bc2016-01-25 14:29:05 -0800916 paramValue = configParam.split(" ")[1]
917 paramName = configParam.split(" ")[0]
Jon Hall4ba53f02015-07-29 13:07:41 -0700918
Jon Hall72280bc2016-01-25 14:29:05 -0800919 checkStr = 'onos {} cfg get " {} {} " '.format( ONOSIp, configName, paramName )
Jon Hall4ba53f02015-07-29 13:07:41 -0700920
Jon Hall72280bc2016-01-25 14:29:05 -0800921 self.handle.sendline( checkStr )
922 self.handle.expect( ":~" )
jenkins1e99e7b2015-04-02 18:15:39 -0700923
Jon Hall72280bc2016-01-25 14:29:05 -0800924 if "value=" + paramValue + "," in self.handle.before:
925 main.log.info("cfg " + configName + " successfully set to " + configParam)
926 return main.TRUE
927 except pexpect.ExceptionPexpect as e:
928 main.log.exception( self.name + ": Pexpect exception found: " )
929 main.log.error( self.name + ": " + self.handle.before )
930 main.cleanup()
931 main.exit()
932 except Exception:
933 main.log.exception( self.name + ": Uncaught exception!" )
934 main.cleanup()
935 main.exit()
Jon Hall4ba53f02015-07-29 13:07:41 -0700936
kelvin-onlabd3b64892015-01-20 13:26:24 -0800937 def onosCli( self, ONOSIp, cmdstr ):
kelvin8ec71442015-01-15 16:57:00 -0800938 """
andrewonlab05e362f2014-10-10 00:40:57 -0400939 Uses 'onos' command to send various ONOS CLI arguments.
940 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800941 * ONOSIp: specify the ip of the cell machine
andrewonlab94282092014-10-10 13:00:11 -0400942 * cmdstr: specify the command string to send
kelvin8ec71442015-01-15 16:57:00 -0800943
944 This function is intended to expose the entire karaf
andrewonlab6e20c342014-10-10 18:08:48 -0400945 CLI commands for ONOS. Try to use this function first
946 before attempting to write a ONOS CLI specific driver
kelvin8ec71442015-01-15 16:57:00 -0800947 function.
948 You can see a list of available 'cmdstr' arguments
andrewonlab6e20c342014-10-10 18:08:48 -0400949 by starting onos, and typing in 'onos' to enter the
950 onos> CLI. Then, type 'help' to see the list of
kelvin8ec71442015-01-15 16:57:00 -0800951 available commands.
952 """
andrewonlab05e362f2014-10-10 00:40:57 -0400953 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800954 if not ONOSIp:
kelvin8ec71442015-01-15 16:57:00 -0800955 main.log.error( "You must specify the IP address" )
andrewonlab05e362f2014-10-10 00:40:57 -0400956 return main.FALSE
957 if not cmdstr:
kelvin8ec71442015-01-15 16:57:00 -0800958 main.log.error( "You must specify the command string" )
andrewonlab05e362f2014-10-10 00:40:57 -0400959 return main.FALSE
960
kelvin8ec71442015-01-15 16:57:00 -0800961 cmdstr = str( cmdstr )
962 self.handle.sendline( "" )
963 self.handle.expect( "\$" )
andrewonlab05e362f2014-10-10 00:40:57 -0400964
kelvin-onlabd3b64892015-01-20 13:26:24 -0800965 self.handle.sendline( "onos -w " + ONOSIp + " " + cmdstr )
kelvin8ec71442015-01-15 16:57:00 -0800966 self.handle.expect( "\$" )
andrewonlab05e362f2014-10-10 00:40:57 -0400967
kelvin-onlabd3b64892015-01-20 13:26:24 -0800968 handleBefore = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -0800969 main.log.info( "Command sent successfully" )
kelvin8ec71442015-01-15 16:57:00 -0800970 # Obtain return handle that consists of result from
971 # the onos command. The string may need to be
972 # configured further.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800973 returnString = handleBefore
kelvin-onlabd3b64892015-01-20 13:26:24 -0800974 return returnString
andrewonlab05e362f2014-10-10 00:40:57 -0400975 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800976 main.log.error( self.name + ": EOF exception found" )
977 main.log.error( self.name + ": " + self.handle.before )
andrewonlab05e362f2014-10-10 00:40:57 -0400978 main.cleanup()
979 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800980 except Exception:
981 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab05e362f2014-10-10 00:40:57 -0400982 main.cleanup()
983 main.exit()
Jon Hall7993bfc2014-10-09 16:30:14 -0400984
Pier88189b62016-09-07 17:01:53 -0700985 def onosSecureSSH( self, userName="onos", userPWD="rocks", node=""):
986 """
987 Enables secure access to ONOS console
988 by removing default users & keys.
989
990 onos-secure-ssh -u onos -p rocks node
991
992 Returns: main.TRUE on success and main.FALSE on failure
993 """
994
995 try:
Chiyu Chengef109502016-11-21 15:51:38 -0800996 self.handle.sendline( "" )
997 self.handle.expect( "\$" )
Pier88189b62016-09-07 17:01:53 -0700998 self.handle.sendline( " onos-secure-ssh -u " + userName + " -p " + userPWD + " " + node )
999
1000 # NOTE: this timeout may need to change depending on the network
1001 # and size of ONOS
1002 # TODO: Handle the other possible error
1003 i = self.handle.expect([ "Network\sis\sunreachable",
1004 "\$",
1005 pexpect.TIMEOUT ], timeout=180 )
1006 if i == 0:
1007 # can't reach ONOS node
1008 main.log.warn( "Network is unreachable" )
1009 self.handle.expect( "\$" )
1010 return main.FALSE
1011 elif i == 1:
1012 # Process started
1013 main.log.info(
1014 "Secure SSH performed on " +
1015 node)
1016 return main.TRUE
1017 except pexpect.EOF:
1018 main.log.error( self.name + ": EOF exception found" )
1019 main.log.error( self.name + ": " + self.handle.before )
1020 main.cleanup()
1021 main.exit()
1022 except Exception:
1023 main.log.exception( self.name + ": Uncaught exception!" )
1024 main.cleanup()
1025 main.exit()
1026
1027
kelvin-onlabd3b64892015-01-20 13:26:24 -08001028 def onosInstall( self, options="-f", node="" ):
kelvin8ec71442015-01-15 16:57:00 -08001029 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001030 Installs ONOS bits on the designated cell machine.
kelvin8ec71442015-01-15 16:57:00 -08001031 If -f option is provided, it also forces an uninstall.
1032 Presently, install also includes onos-push-bits and
Jon Hall7993bfc2014-10-09 16:30:14 -04001033 onos-config within.
kelvin8ec71442015-01-15 16:57:00 -08001034 The node option allows you to selectively only push the jar
Jon Hall7993bfc2014-10-09 16:30:14 -04001035 files to certain onos nodes
1036
1037 Returns: main.TRUE on success and main.FALSE on failure
kelvin8ec71442015-01-15 16:57:00 -08001038 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001039 try:
andrewonlab114768a2014-11-14 12:44:44 -05001040 if options:
kelvin8ec71442015-01-15 16:57:00 -08001041 self.handle.sendline( "onos-install " + options + " " + node )
andrewonlab114768a2014-11-14 12:44:44 -05001042 else:
kelvin8ec71442015-01-15 16:57:00 -08001043 self.handle.sendline( "onos-install " + node )
1044 self.handle.expect( "onos-install " )
1045 # NOTE: this timeout may need to change depending on the network
1046 # and size of ONOS
1047 i = self.handle.expect( [ "Network\sis\sunreachable",
kelvin-onlabd3b64892015-01-20 13:26:24 -08001048 "onos\sstart/running,\sprocess",
kelvin8ec71442015-01-15 16:57:00 -08001049 "ONOS\sis\salready\sinstalled",
Jeremyc72b2582016-02-26 18:27:38 -08001050 "already\sup-to-date",
Jon Hall3576f572016-08-23 10:01:07 -07001051 "does not exist",
Jeremyc72b2582016-02-26 18:27:38 -08001052 "\$",
Jon Hall6c44c0b2016-04-20 15:21:00 -07001053 pexpect.TIMEOUT ], timeout=180 )
Jon Hall7993bfc2014-10-09 16:30:14 -04001054 if i == 0:
Jon Hall3576f572016-08-23 10:01:07 -07001055 # can't reach ONOS node
kelvin8ec71442015-01-15 16:57:00 -08001056 main.log.warn( "Network is unreachable" )
Jon Hall3b489db2015-10-05 14:38:37 -07001057 self.handle.expect( "\$" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001058 return main.FALSE
1059 elif i == 1:
Jon Hall3576f572016-08-23 10:01:07 -07001060 # Process started
kelvin8ec71442015-01-15 16:57:00 -08001061 main.log.info(
1062 "ONOS was installed on " +
1063 node +
1064 " and started" )
Jon Hall3b489db2015-10-05 14:38:37 -07001065 self.handle.expect( "\$" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001066 return main.TRUE
Jon Hall3576f572016-08-23 10:01:07 -07001067 elif i == 2 or i == 3:
1068 # same bits are already on ONOS node
Jeremyc72b2582016-02-26 18:27:38 -08001069 main.log.info( "ONOS is already installed on " + node )
1070 self.handle.expect( "\$" )
1071 return main.TRUE
1072 elif i == 4:
Jon Hall3576f572016-08-23 10:01:07 -07001073 # onos not packaged
1074 main.log.error( "ONOS package not found." )
1075 self.handle.expect( "\$" )
1076 return main.FALSE
1077 elif i == 5:
1078 # prompt
Jeremyc72b2582016-02-26 18:27:38 -08001079 main.log.info( "ONOS was installed on " + node )
1080 return main.TRUE
Jon Hall3576f572016-08-23 10:01:07 -07001081 elif i == 6:
1082 # timeout
kelvin8ec71442015-01-15 16:57:00 -08001083 main.log.info(
1084 "Installation of ONOS on " +
1085 node +
1086 " timed out" )
Jon Hall3b489db2015-10-05 14:38:37 -07001087 self.handle.expect( "\$" )
Jon Hall53c5e662016-04-13 16:06:56 -07001088 main.log.warn( self.handle.before )
Jon Hall7993bfc2014-10-09 16:30:14 -04001089 return main.FALSE
andrewonlabc03bf6c2014-10-09 14:56:18 -04001090 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001091 main.log.error( self.name + ": EOF exception found" )
1092 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc03bf6c2014-10-09 14:56:18 -04001093 main.cleanup()
1094 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001095 except Exception:
1096 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc03bf6c2014-10-09 14:56:18 -04001097 main.cleanup()
1098 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -04001099
kelvin-onlabd3b64892015-01-20 13:26:24 -08001100 def onosStart( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001101 """
andrewonlab8d0d7d72014-10-09 16:33:15 -04001102 Calls onos command: 'onos-service [<node-ip>] start'
andrewonlabe8e56fd2014-10-09 17:12:44 -04001103 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -08001104 """
andrewonlab8d0d7d72014-10-09 16:33:15 -04001105 try:
kelvin8ec71442015-01-15 16:57:00 -08001106 self.handle.sendline( "" )
1107 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001108 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001109 " start" )
1110 i = self.handle.expect( [
andrewonlab8d0d7d72014-10-09 16:33:15 -04001111 "Job\sis\salready\srunning",
1112 "start/running",
Jeremyd0e9a6d2016-03-02 11:28:52 -08001113 "\$",
andrewonlab8d0d7d72014-10-09 16:33:15 -04001114 "Unknown\sinstance",
Jeremy Songster14c13572016-04-21 17:34:03 -07001115 pexpect.TIMEOUT ], timeout=180 )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001116 if i == 0:
Jon Halleab7a242016-03-04 10:20:43 -08001117 self.handle.expect( "\$" )
kelvin8ec71442015-01-15 16:57:00 -08001118 main.log.info( "Service is already running" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001119 return main.TRUE
1120 elif i == 1:
Jon Halleab7a242016-03-04 10:20:43 -08001121 self.handle.expect( "\$" )
kelvin8ec71442015-01-15 16:57:00 -08001122 main.log.info( "ONOS service started" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001123 return main.TRUE
Jeremyd0e9a6d2016-03-02 11:28:52 -08001124 elif i == 2:
1125 main.log.info( "ONOS service started" )
1126 return main.TRUE
andrewonlab8d0d7d72014-10-09 16:33:15 -04001127 else:
Jon Halleab7a242016-03-04 10:20:43 -08001128 self.handle.expect( "\$" )
kelvin8ec71442015-01-15 16:57:00 -08001129 main.log.error( "ONOS service failed to start" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001130 main.cleanup()
1131 main.exit()
andrewonlab8d0d7d72014-10-09 16:33:15 -04001132 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001133 main.log.error( self.name + ": EOF exception found" )
1134 main.log.error( self.name + ": " + self.handle.before )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001135 main.cleanup()
1136 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001137 except Exception:
1138 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001139 main.cleanup()
1140 main.exit()
1141
kelvin-onlabd3b64892015-01-20 13:26:24 -08001142 def onosStop( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001143 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001144 Calls onos command: 'onos-service [<node-ip>] stop'
andrewonlabe8e56fd2014-10-09 17:12:44 -04001145 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -08001146 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001147 try:
kelvin8ec71442015-01-15 16:57:00 -08001148 self.handle.sendline( "" )
1149 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001150 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001151 " stop" )
1152 i = self.handle.expect( [
andrewonlab2b30bd32014-10-09 16:48:55 -04001153 "stop/waiting",
Jon Hall61282e32015-03-19 11:34:11 -07001154 "Could not resolve hostname",
andrewonlab2b30bd32014-10-09 16:48:55 -04001155 "Unknown\sinstance",
YPZhang77badfc2016-03-09 10:28:59 -08001156 "\$",
Jeremy Songster14c13572016-04-21 17:34:03 -07001157 pexpect.TIMEOUT ], timeout=180 )
andrewonlab2b30bd32014-10-09 16:48:55 -04001158 if i == 0:
YPZhang77badfc2016-03-09 10:28:59 -08001159 self.handle.expect( "\$" )
kelvin8ec71442015-01-15 16:57:00 -08001160 main.log.info( "ONOS service stopped" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001161 return main.TRUE
1162 elif i == 1:
YPZhang77badfc2016-03-09 10:28:59 -08001163 self.handle.expect( "\$" )
Jon Hall65844a32015-03-09 19:09:37 -07001164 main.log.info( "onosStop() Unknown ONOS instance specified: " +
kelvin-onlabd3b64892015-01-20 13:26:24 -08001165 str( nodeIp ) )
andrewonlab2b30bd32014-10-09 16:48:55 -04001166 return main.FALSE
Jon Hall61282e32015-03-19 11:34:11 -07001167 elif i == 2:
YPZhang77badfc2016-03-09 10:28:59 -08001168 self.handle.expect( "\$" )
Jon Hall61282e32015-03-19 11:34:11 -07001169 main.log.warn( "ONOS wasn't running" )
1170 return main.TRUE
YPZhang77badfc2016-03-09 10:28:59 -08001171 elif i == 3:
1172 main.log.info( "ONOS service stopped" )
1173 return main.TRUE
andrewonlab2b30bd32014-10-09 16:48:55 -04001174 else:
kelvin8ec71442015-01-15 16:57:00 -08001175 main.log.error( "ONOS service failed to stop" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001176 return main.FALSE
andrewonlab2b30bd32014-10-09 16:48:55 -04001177 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001178 main.log.error( self.name + ": EOF exception found" )
1179 main.log.error( self.name + ": " + self.handle.before )
andrewonlab2b30bd32014-10-09 16:48:55 -04001180 main.cleanup()
1181 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001182 except Exception:
1183 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001184 main.cleanup()
1185 main.exit()
kelvin8ec71442015-01-15 16:57:00 -08001186
kelvin-onlabd3b64892015-01-20 13:26:24 -08001187 def onosUninstall( self, nodeIp="" ):
kelvin8ec71442015-01-15 16:57:00 -08001188 """
andrewonlabc8d47972014-10-09 16:52:36 -04001189 Calls the command: 'onos-uninstall'
kelvin8ec71442015-01-15 16:57:00 -08001190 Uninstalls ONOS from the designated cell machine, stopping
andrewonlabe8e56fd2014-10-09 17:12:44 -04001191 if needed
kelvin8ec71442015-01-15 16:57:00 -08001192 """
andrewonlabc8d47972014-10-09 16:52:36 -04001193 try:
kelvin8ec71442015-01-15 16:57:00 -08001194 self.handle.sendline( "" )
Jeremy Songster14c13572016-04-21 17:34:03 -07001195 self.handle.expect( "\$", timeout=180 )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001196 self.handle.sendline( "onos-uninstall " + str( nodeIp ) )
Jeremy Songster14c13572016-04-21 17:34:03 -07001197 self.handle.expect( "\$", timeout=180 )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001198 main.log.info( "ONOS " + nodeIp + " was uninstalled" )
kelvin8ec71442015-01-15 16:57:00 -08001199 # onos-uninstall command does not return any text
andrewonlabc8d47972014-10-09 16:52:36 -04001200 return main.TRUE
pingping-lin763ee042015-05-20 17:45:30 -07001201 except pexpect.TIMEOUT:
1202 main.log.exception( self.name + ": Timeout in onosUninstall" )
1203 return main.FALSE
andrewonlabc8d47972014-10-09 16:52:36 -04001204 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001205 main.log.error( self.name + ": EOF exception found" )
1206 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc8d47972014-10-09 16:52:36 -04001207 main.cleanup()
1208 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001209 except Exception:
1210 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc8d47972014-10-09 16:52:36 -04001211 main.cleanup()
1212 main.exit()
andrewonlab2b30bd32014-10-09 16:48:55 -04001213
kelvin-onlabd3b64892015-01-20 13:26:24 -08001214 def onosDie( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001215 """
andrewonlabaedc8332014-12-04 12:43:03 -05001216 Issues the command 'onos-die <node-ip>'
1217 This command calls onos-kill and also stops the node
kelvin8ec71442015-01-15 16:57:00 -08001218 """
andrewonlabaedc8332014-12-04 12:43:03 -05001219 try:
kelvin8ec71442015-01-15 16:57:00 -08001220 self.handle.sendline( "" )
1221 self.handle.expect( "\$" )
Jeremyf0aecdb2016-03-30 13:19:57 -07001222 cmdStr = "onos-die " + str( nodeIp )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001223 self.handle.sendline( cmdStr )
kelvin8ec71442015-01-15 16:57:00 -08001224 i = self.handle.expect( [
andrewonlabaedc8332014-12-04 12:43:03 -05001225 "Killing\sONOS",
1226 "ONOS\sprocess\sis\snot\srunning",
Jeremy Songster14c13572016-04-21 17:34:03 -07001227 pexpect.TIMEOUT ], timeout=60 )
andrewonlabaedc8332014-12-04 12:43:03 -05001228 if i == 0:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001229 main.log.info( "ONOS instance " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001230 " was killed and stopped" )
Jon Hall53c5e662016-04-13 16:06:56 -07001231 self.handle.sendline( "" )
1232 self.handle.expect( "\$" )
andrewonlabaedc8332014-12-04 12:43:03 -05001233 return main.TRUE
1234 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001235 main.log.info( "ONOS process was not running" )
Jon Hall53c5e662016-04-13 16:06:56 -07001236 self.handle.sendline( "" )
1237 self.handle.expect( "\$" )
andrewonlabaedc8332014-12-04 12:43:03 -05001238 return main.FALSE
1239 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001240 main.log.error( self.name + ": EOF exception found" )
1241 main.log.error( self.name + ": " + self.handle.before )
andrewonlabaedc8332014-12-04 12:43:03 -05001242 main.cleanup()
1243 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001244 except Exception:
1245 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabaedc8332014-12-04 12:43:03 -05001246 main.cleanup()
1247 main.exit()
1248
kelvin-onlabd3b64892015-01-20 13:26:24 -08001249 def onosKill( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001250 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001251 Calls the command: 'onos-kill [<node-ip>]'
1252 "Remotely, and unceremoniously kills the ONOS instance running on
1253 the specified cell machine" - Tom V
kelvin8ec71442015-01-15 16:57:00 -08001254 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001255 try:
kelvin8ec71442015-01-15 16:57:00 -08001256 self.handle.sendline( "" )
1257 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001258 self.handle.sendline( "onos-kill " + str( nodeIp ) )
kelvin8ec71442015-01-15 16:57:00 -08001259 i = self.handle.expect( [
andrewonlabe8e56fd2014-10-09 17:12:44 -04001260 "\$",
1261 "No\sroute\sto\shost",
1262 "password:",
Jeremy Songster14c13572016-04-21 17:34:03 -07001263 pexpect.TIMEOUT ], timeout=60 )
kelvin8ec71442015-01-15 16:57:00 -08001264
andrewonlabe8e56fd2014-10-09 17:12:44 -04001265 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001266 main.log.info(
1267 "ONOS instance " + str(
kelvin-onlabd3b64892015-01-20 13:26:24 -08001268 nodeIp ) + " was killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001269 return main.TRUE
1270 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001271 main.log.info( "No route to host" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001272 return main.FALSE
1273 elif i == 2:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001274 main.log.info(
1275 "Passwordless login for host: " +
1276 str( nodeIp ) +
1277 " not configured" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001278 return main.FALSE
1279 else:
Jon Hallefbd9792015-03-05 16:11:36 -08001280 main.log.info( "ONOS instance was not killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001281 return main.FALSE
kelvin8ec71442015-01-15 16:57:00 -08001282
andrewonlabe8e56fd2014-10-09 17:12:44 -04001283 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001284 main.log.error( self.name + ": EOF exception found" )
1285 main.log.error( self.name + ": " + self.handle.before )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001286 main.cleanup()
1287 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001288 except Exception:
1289 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001290 main.cleanup()
1291 main.exit()
1292
kelvin-onlabd3b64892015-01-20 13:26:24 -08001293 def onosRemoveRaftLogs( self ):
kelvin8ec71442015-01-15 16:57:00 -08001294 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001295 Removes Raft / Copy cat files from ONOS to ensure
Jon Hallfcc88622014-11-25 13:09:54 -05001296 a cleaner environment.
1297
andrewonlab19fbdca2014-11-14 12:55:59 -05001298 Description:
Jon Hallfcc88622014-11-25 13:09:54 -05001299 Stops all ONOS defined in the cell,
andrewonlab19fbdca2014-11-14 12:55:59 -05001300 wipes the raft / copycat log files
kelvin8ec71442015-01-15 16:57:00 -08001301 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001302 try:
kelvin8ec71442015-01-15 16:57:00 -08001303 self.handle.sendline( "" )
1304 self.handle.expect( "\$" )
1305 self.handle.sendline( "onos-remove-raft-logs" )
1306 # Sometimes this command hangs
1307 i = self.handle.expect( [ "\$", pexpect.TIMEOUT ],
1308 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001309 if i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001310 i = self.handle.expect( [ "\$", pexpect.TIMEOUT ],
1311 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001312 if i == 1:
1313 return main.FALSE
andrewonlab19fbdca2014-11-14 12:55:59 -05001314 return main.TRUE
andrewonlab19fbdca2014-11-14 12:55:59 -05001315 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001316 main.log.error( self.name + ": EOF exception found" )
1317 main.log.error( self.name + ": " + self.handle.before )
andrewonlab19fbdca2014-11-14 12:55:59 -05001318 main.cleanup()
1319 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001320 except Exception:
1321 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab19fbdca2014-11-14 12:55:59 -05001322 main.cleanup()
1323 main.exit()
Jon Hallfcc88622014-11-25 13:09:54 -05001324
kelvin-onlabd3b64892015-01-20 13:26:24 -08001325 def onosStartNetwork( self, mntopo ):
kelvin8ec71442015-01-15 16:57:00 -08001326 """
1327 Calls the command 'onos-start-network [ <mininet-topo> ]
1328 "remotely starts the specified topology on the cell's
andrewonlab94282092014-10-10 13:00:11 -04001329 mininet machine against all controllers configured in the
kelvin8ec71442015-01-15 16:57:00 -08001330 cell."
andrewonlab94282092014-10-10 13:00:11 -04001331 * Specify mininet topology file name for mntopo
1332 * Topo files should be placed at:
1333 ~/<your-onos-directory>/tools/test/topos
kelvin8ec71442015-01-15 16:57:00 -08001334
andrewonlab94282092014-10-10 13:00:11 -04001335 NOTE: This function will take you to the mininet prompt
kelvin8ec71442015-01-15 16:57:00 -08001336 """
andrewonlab94282092014-10-10 13:00:11 -04001337 try:
1338 if not mntopo:
kelvin8ec71442015-01-15 16:57:00 -08001339 main.log.error( "You must specify a topo file to execute" )
andrewonlab94282092014-10-10 13:00:11 -04001340 return main.FALSE
andrewonlab94282092014-10-10 13:00:11 -04001341
kelvin8ec71442015-01-15 16:57:00 -08001342 mntopo = str( mntopo )
1343 self.handle.sendline( "" )
1344 self.handle.expect( "\$" )
andrewonlab94282092014-10-10 13:00:11 -04001345
kelvin8ec71442015-01-15 16:57:00 -08001346 self.handle.sendline( "onos-start-network " + mntopo )
1347 self.handle.expect( "mininet>" )
1348 main.log.info( "Network started, entered mininet prompt" )
1349
1350 # TODO: Think about whether return is necessary or not
andrewonlab94282092014-10-10 13:00:11 -04001351
1352 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001353 main.log.error( self.name + ": EOF exception found" )
1354 main.log.error( self.name + ": " + self.handle.before )
andrewonlab94282092014-10-10 13:00:11 -04001355 main.cleanup()
1356 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001357 except Exception:
1358 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab94282092014-10-10 13:00:11 -04001359 main.cleanup()
1360 main.exit()
1361
Jeremy Songster14c13572016-04-21 17:34:03 -07001362 def isup( self, node="", timeout=240 ):
kelvin8ec71442015-01-15 16:57:00 -08001363 """
1364 Run's onos-wait-for-start which only returns once ONOS is at run
Cameron Franke9c94fb02015-01-21 10:20:20 -08001365 level 100(ready for use)
andrewonlab8d0d7d72014-10-09 16:33:15 -04001366
Jon Hall7993bfc2014-10-09 16:30:14 -04001367 Returns: main.TRUE if ONOS is running and main.FALSE on timeout
kelvin8ec71442015-01-15 16:57:00 -08001368 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001369 try:
Jon Hall3b489db2015-10-05 14:38:37 -07001370 self.handle.sendline( "onos-wait-for-start " + node )
1371 self.handle.expect( "onos-wait-for-start" )
kelvin8ec71442015-01-15 16:57:00 -08001372 # NOTE: this timeout is arbitrary"
Cameron Franke9c94fb02015-01-21 10:20:20 -08001373 i = self.handle.expect(["\$", pexpect.TIMEOUT], timeout)
Jon Hall7993bfc2014-10-09 16:30:14 -04001374 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001375 main.log.info( self.name + ": " + node + " is up" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001376 return main.TRUE
1377 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001378 # NOTE: since this function won't return until ONOS is ready,
Jon Hall7993bfc2014-10-09 16:30:14 -04001379 # we will kill it on timeout
kelvin8ec71442015-01-15 16:57:00 -08001380 main.log.error( "ONOS has not started yet" )
1381 self.handle.send( "\x03" ) # Control-C
1382 self.handle.expect( "\$" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001383 return main.FALSE
1384 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001385 main.log.error( self.name + ": EOF exception found" )
1386 main.log.error( self.name + ": " + self.handle.before )
Jon Hall7993bfc2014-10-09 16:30:14 -04001387 main.cleanup()
1388 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001389 except Exception:
1390 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001391 main.cleanup()
1392 main.exit()
andrewonlab05e362f2014-10-10 00:40:57 -04001393
kelvin-onlabd3b64892015-01-20 13:26:24 -08001394 def pushTestIntentsShell(
1395 self,
1396 dpidSrc,
1397 dpidDst,
1398 numIntents,
1399 dirFile,
1400 onosIp,
1401 numMult="",
1402 appId="",
1403 report=True,
1404 options="" ):
kelvin8ec71442015-01-15 16:57:00 -08001405 """
andrewonlabb66dfa12014-12-02 15:51:10 -05001406 Description:
kelvin8ec71442015-01-15 16:57:00 -08001407 Use the linux prompt to push test intents to
andrewonlabb66dfa12014-12-02 15:51:10 -05001408 better parallelize the results than the CLI
1409 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001410 * dpidSrc: specify source dpid
1411 * dpidDst: specify destination dpid
1412 * numIntents: specify number of intents to push
1413 * dirFile: specify directory and file name to save
andrewonlabb66dfa12014-12-02 15:51:10 -05001414 results
kelvin-onlabd3b64892015-01-20 13:26:24 -08001415 * onosIp: specify the IP of ONOS to install on
kelvin8ec71442015-01-15 16:57:00 -08001416 NOTE:
andrewonlabb66dfa12014-12-02 15:51:10 -05001417 You must invoke this command at linux shell prompt
kelvin8ec71442015-01-15 16:57:00 -08001418 """
1419 try:
1420 # Create the string to sendline
andrewonlabaedc8332014-12-04 12:43:03 -05001421 if options:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001422 baseCmd = "onos " + str( onosIp ) + " push-test-intents " +\
kelvin8ec71442015-01-15 16:57:00 -08001423 options + " "
andrewonlabaedc8332014-12-04 12:43:03 -05001424 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001425 baseCmd = "onos " + str( onosIp ) + " push-test-intents "
kelvin8ec71442015-01-15 16:57:00 -08001426
kelvin-onlabd3b64892015-01-20 13:26:24 -08001427 addDpid = baseCmd + str( dpidSrc ) + " " + str( dpidDst )
1428 if not numMult:
1429 addIntents = addDpid + " " + str( numIntents )
1430 elif numMult:
1431 addIntents = addDpid + " " + str( numIntents ) + " " +\
1432 str( numMult )
1433 if appId:
1434 addApp = addIntents + " " + str( appId )
andrewonlabb66dfa12014-12-02 15:51:10 -05001435 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001436 addApp = addIntents
andrewonlabb66dfa12014-12-02 15:51:10 -05001437
andrewonlabaedc8332014-12-04 12:43:03 -05001438 if report:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001439 sendCmd = addApp + " > " + str( dirFile ) + " &"
andrewonlabaedc8332014-12-04 12:43:03 -05001440 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001441 sendCmd = addApp + " &"
1442 main.log.info( "Send cmd: " + sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001443
kelvin-onlabd3b64892015-01-20 13:26:24 -08001444 self.handle.sendline( sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001445
1446 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001447 main.log.error( self.name + ": EOF exception found" )
1448 main.log.error( self.name + ": " + self.handle.before )
andrewonlabb66dfa12014-12-02 15:51:10 -05001449 main.cleanup()
1450 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001451 except Exception:
1452 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabb66dfa12014-12-02 15:51:10 -05001453 main.cleanup()
kelvin8ec71442015-01-15 16:57:00 -08001454 main.exit()
andrewonlab05e362f2014-10-10 00:40:57 -04001455
kelvin-onlabd3b64892015-01-20 13:26:24 -08001456 def tsharkPcap( self, interface, dirFile ):
kelvin8ec71442015-01-15 16:57:00 -08001457 """
andrewonlab970399c2014-11-07 13:09:32 -05001458 Capture all packet activity and store in specified
1459 directory/file
1460
1461 Required:
1462 * interface: interface to capture
1463 * dir: directory/filename to store pcap
kelvin8ec71442015-01-15 16:57:00 -08001464 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001465 try:
1466 self.handle.sendline( "" )
1467 self.handle.expect( "\$" )
andrewonlab970399c2014-11-07 13:09:32 -05001468
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001469 self.handle.sendline( "tshark -i " + str( interface ) + " -t e -w " + str( dirFile ) + " &" )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001470 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001471 self.handle.expect( "Capturing on" )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001472 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001473 self.handle.expect( "\$" )
andrewonlab970399c2014-11-07 13:09:32 -05001474
Jon Hallfebb1c72015-03-05 13:30:09 -08001475 main.log.info( "Tshark started capturing files on " +
1476 str( interface ) + " and saving to directory: " +
1477 str( dirFile ) )
1478 except pexpect.EOF:
1479 main.log.error( self.name + ": EOF exception found" )
1480 main.log.error( self.name + ": " + self.handle.before )
1481 main.cleanup()
1482 main.exit()
1483 except Exception:
1484 main.log.exception( self.name + ": Uncaught exception!" )
1485 main.cleanup()
1486 main.exit()
Shreya Shaha73aaad2014-10-27 18:03:09 -04001487
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001488 def onosTopoCfg( self, onosIp, jsonFile ):
kelvin8ec71442015-01-15 16:57:00 -08001489 """
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001490 Description:
1491 Execute onos-topo-cfg command
1492 Required:
1493 onosIp - IP of the onos node you want to send the json to
1494 jsonFile - File path of the json file
1495 Return:
1496 Returns main.TRUE if the command is successfull; Returns
1497 main.FALSE if there was an error
kelvin8ec71442015-01-15 16:57:00 -08001498 """
shahshreyae6c7cf42014-11-26 16:39:01 -08001499 try:
kelvin8ec71442015-01-15 16:57:00 -08001500 self.handle.sendline( "" )
1501 self.handle.expect( "\$" )
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001502 cmd = "onos-topo-cfg "
1503 self.handle.sendline( cmd + str( onosIp ) + " " + jsonFile )
1504 handle = self.handle.before
1505 print handle
1506 if "Error" in handle:
1507 main.log.error( self.name + ": " + self.handle.before )
1508 return main.FALSE
1509 else:
1510 self.handle.expect( "\$" )
1511 return main.TRUE
1512
Jon Hallfebb1c72015-03-05 13:30:09 -08001513 except pexpect.EOF:
1514 main.log.error( self.name + ": EOF exception found" )
1515 main.log.error( self.name + ": " + self.handle.before )
1516 main.cleanup()
1517 main.exit()
1518 except Exception:
1519 main.log.exception( self.name + ": Uncaught exception!" )
1520 main.cleanup()
1521 main.exit()
kelvin8ec71442015-01-15 16:57:00 -08001522
jenkins1e99e7b2015-04-02 18:15:39 -07001523 def tsharkGrep( self, grep, directory, interface='eth0', grepOptions='' ):
kelvin8ec71442015-01-15 16:57:00 -08001524 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001525 Required:
kelvin8ec71442015-01-15 16:57:00 -08001526 * grep string
andrewonlabba44bcf2014-10-16 16:54:41 -04001527 * directory to store results
1528 Optional:
1529 * interface - default: eth0
Jon Hall4ba53f02015-07-29 13:07:41 -07001530 * grepOptions - options for grep
andrewonlabba44bcf2014-10-16 16:54:41 -04001531 Description:
1532 Uses tshark command to grep specific group of packets
1533 and stores the results to specified directory.
kelvin8ec71442015-01-15 16:57:00 -08001534 The timestamp is hardcoded to be in epoch
1535 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001536 try:
1537 self.handle.sendline( "" )
1538 self.handle.expect( "\$" )
1539 self.handle.sendline( "" )
jenkins1e99e7b2015-04-02 18:15:39 -07001540 if grepOptions:
1541 grepStr = "grep "+str(grepOptions)
1542 else:
1543 grepStr = "grep"
Jon Hall4ba53f02015-07-29 13:07:41 -07001544
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001545 cmd = (
1546 "sudo tshark -i " +
Jon Hallfebb1c72015-03-05 13:30:09 -08001547 str( interface ) +
jenkins1e99e7b2015-04-02 18:15:39 -07001548 " -t e | " +
1549 grepStr + " --line-buffered \"" +
Jon Hallfebb1c72015-03-05 13:30:09 -08001550 str(grep) +
1551 "\" >" +
1552 directory +
1553 " &" )
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001554 self.handle.sendline(cmd)
1555 main.log.info(cmd)
Jon Hallfebb1c72015-03-05 13:30:09 -08001556 self.handle.expect( "Capturing on" )
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001557 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001558 self.handle.expect( "\$" )
1559 except pexpect.EOF:
1560 main.log.error( self.name + ": EOF exception found" )
1561 main.log.error( self.name + ": " + self.handle.before )
1562 main.cleanup()
1563 main.exit()
1564 except Exception:
1565 main.log.exception( self.name + ": Uncaught exception!" )
1566 main.cleanup()
1567 main.exit()
1568
kelvin-onlabd3b64892015-01-20 13:26:24 -08001569 def tsharkStop( self ):
kelvin8ec71442015-01-15 16:57:00 -08001570 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001571 Removes wireshark files from /tmp and kills all tshark processes
kelvin8ec71442015-01-15 16:57:00 -08001572 """
1573 # Remove all pcap from previous captures
Jon Hallfebb1c72015-03-05 13:30:09 -08001574 try:
1575 self.execute( cmd="sudo rm /tmp/wireshark*" )
1576 self.handle.sendline( "" )
Jon Hallefbd9792015-03-05 16:11:36 -08001577 self.handle.sendline( "sudo kill -9 `ps -ef | grep \"tshark -i\"" +
1578 " | grep -v grep | awk '{print $2}'`" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001579 self.handle.sendline( "" )
1580 main.log.info( "Tshark stopped" )
1581 except pexpect.EOF:
1582 main.log.error( self.name + ": EOF exception found" )
1583 main.log.error( self.name + ": " + self.handle.before )
1584 main.cleanup()
1585 main.exit()
1586 except Exception:
1587 main.log.exception( self.name + ": Uncaught exception!" )
1588 main.cleanup()
1589 main.exit()
1590
kelvin8ec71442015-01-15 16:57:00 -08001591 def ptpd( self, args ):
1592 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001593 Initiate ptp with user-specified args.
1594 Required:
1595 * args: specify string of args after command
1596 'sudo ptpd'
kelvin8ec71442015-01-15 16:57:00 -08001597 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001598 try:
kelvin8ec71442015-01-15 16:57:00 -08001599 self.handle.sendline( "sudo ptpd " + str( args ) )
1600 i = self.handle.expect( [
andrewonlab0c38a4a2014-10-28 18:35:35 -04001601 "Multiple",
1602 "Error",
kelvin8ec71442015-01-15 16:57:00 -08001603 "\$" ] )
1604 self.handle.expect( "\$" )
andrewonlabba44bcf2014-10-16 16:54:41 -04001605
andrewonlab0c38a4a2014-10-28 18:35:35 -04001606 if i == 0:
1607 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001608 main.log.info( "ptpd returned an error: " +
1609 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001610 return handle
1611 elif i == 1:
1612 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001613 main.log.error( "ptpd returned an error: " +
1614 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001615 return handle
1616 else:
1617 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -08001618
andrewonlab0c38a4a2014-10-28 18:35:35 -04001619 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001620 main.log.error( self.name + ": EOF exception found" )
1621 main.log.error( self.name + ": " + self.handle.before )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001622 main.cleanup()
1623 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001624 except Exception:
1625 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001626 main.cleanup()
1627 main.exit()
andrewonlabba44bcf2014-10-16 16:54:41 -04001628
Pier50f0bc62016-09-07 17:53:40 -07001629 def dumpONOSCmd(self, ONOSIp, CMD, destDir, filename, options=""):
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001630 """
Pier50f0bc62016-09-07 17:53:40 -07001631 Dump Cmd to a desired directory.
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001632 For debugging purposes, you may want to use
Pier50f0bc62016-09-07 17:53:40 -07001633 this function to capture Cmd at a given point in time.
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001634 Localtime will be attached to the filename
1635
1636 Required:
1637 * ONOSIp: the IP of the target ONOS instance
Pier50f0bc62016-09-07 17:53:40 -07001638 * CMD: the command to dump;
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001639 * destDir: specify directory to copy to.
1640 ex ) /tmp/
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001641 * fileName: Name of the file
Pier50f0bc62016-09-07 17:53:40 -07001642 * options: Options for ONOS command
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001643 """
1644
1645 localtime = time.strftime( '%x %X' )
1646 localtime = localtime.replace( "/", "" )
1647 localtime = localtime.replace( " ", "_" )
1648 localtime = localtime.replace( ":", "" )
1649 if destDir[ -1: ] != "/":
1650 destDir += "/"
Pier50f0bc62016-09-07 17:53:40 -07001651 cmd=CMD + " " + options + " > " + str( destDir ) + str( filename ) + localtime
1652 return self.onosCli(ONOSIp, cmd)
Flavio Castrob7718952016-05-18 08:53:41 -07001653
kelvin-onlabd3b64892015-01-20 13:26:24 -08001654 def cpLogsToDir( self, logToCopy,
Jon Hallefbd9792015-03-05 16:11:36 -08001655 destDir, copyFileName="" ):
kelvin8ec71442015-01-15 16:57:00 -08001656 """
1657 Copies logs to a desired directory.
andrewonlab5d7a8f32014-11-10 13:07:56 -05001658 Current implementation of ONOS deletes its karaf
1659 logs on every iteration. For debugging purposes,
kelvin8ec71442015-01-15 16:57:00 -08001660 you may want to use this function to capture
1661 certain karaf logs. ( or any other logs if needed )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001662 Localtime will be attached to the filename
1663
1664 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001665 * logToCopy: specify directory and log name to
andrewonlab5d7a8f32014-11-10 13:07:56 -05001666 copy.
kelvin8ec71442015-01-15 16:57:00 -08001667 ex ) /opt/onos/log/karaf.log.1
kelvin-onlabd3b64892015-01-20 13:26:24 -08001668 For copying multiple files, leave copyFileName
1669 empty and only specify destDir -
kelvin8ec71442015-01-15 16:57:00 -08001670 ex ) /opt/onos/log/karaf*
kelvin-onlabd3b64892015-01-20 13:26:24 -08001671 * destDir: specify directory to copy to.
kelvin8ec71442015-01-15 16:57:00 -08001672 ex ) /tmp/
1673 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001674 * copyFileName: If you want to rename the log
1675 file, specify copyFileName. This will not work
andrewonlab5d7a8f32014-11-10 13:07:56 -05001676 with multiple file copying
kelvin8ec71442015-01-15 16:57:00 -08001677 """
andrewonlab5d7a8f32014-11-10 13:07:56 -05001678 try:
Flavio Castro09ab59d2016-05-25 17:01:35 -07001679 localtime = time.strftime( '%H %M' )
kelvin8ec71442015-01-15 16:57:00 -08001680 localtime = localtime.replace( "/", "" )
1681 localtime = localtime.replace( " ", "_" )
1682 localtime = localtime.replace( ":", "" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001683 if destDir[ -1: ] != "/":
1684 destDir += "/"
andrewonlab5d7a8f32014-11-10 13:07:56 -05001685
kelvin-onlabd3b64892015-01-20 13:26:24 -08001686 if copyFileName:
Jon Hallfebb1c72015-03-05 13:30:09 -08001687 self.handle.sendline( "cp " + str( logToCopy ) + " " +
1688 str( destDir ) + str( copyFileName ) +
1689 localtime )
kelvin8ec71442015-01-15 16:57:00 -08001690 self.handle.expect( "cp" )
1691 self.handle.expect( "\$" )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001692 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001693 self.handle.sendline( "cp " + str( logToCopy ) +
1694 " " + str( destDir ) )
kelvin8ec71442015-01-15 16:57:00 -08001695 self.handle.expect( "cp" )
1696 self.handle.expect( "\$" )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001697
kelvin8ec71442015-01-15 16:57:00 -08001698 return self.handle.before
1699
1700 except pexpect.EOF:
1701 main.log.error( "Copying files failed" )
1702 main.log.error( self.name + ": EOF exception found" )
1703 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001704 except Exception:
1705 main.log.exception( "Copying files failed" )
1706
Jon Hall16b72c42015-05-20 10:23:36 -07001707 def checkLogs( self, onosIp, restart=False):
kelvin8ec71442015-01-15 16:57:00 -08001708 """
Jon Hall94fd0472014-12-08 11:52:42 -08001709 runs onos-check-logs on the given onos node
Jon Hall80daded2015-05-27 16:07:00 -07001710 If restart is True, use the old version of onos-check-logs which
1711 does not print the full stacktrace, but shows the entire log file,
1712 including across restarts
Jon Hall94fd0472014-12-08 11:52:42 -08001713 returns the response
kelvin8ec71442015-01-15 16:57:00 -08001714 """
Jon Hall94fd0472014-12-08 11:52:42 -08001715 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001716 cmd = "onos-check-logs " + str( onosIp )
Jon Hall16b72c42015-05-20 10:23:36 -07001717 if restart:
1718 cmd += " old"
kelvin8ec71442015-01-15 16:57:00 -08001719 self.handle.sendline( cmd )
1720 self.handle.expect( cmd )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001721 self.handle.expect( "\$ " )
Jon Hall94fd0472014-12-08 11:52:42 -08001722 response = self.handle.before
1723 return response
1724 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001725 main.log.error( "Lost ssh connection" )
1726 main.log.error( self.name + ": EOF exception found" )
1727 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001728 except Exception:
1729 main.log.exception( self.name + ": Uncaught exception!" )
1730 main.cleanup()
1731 main.exit()
Jon Hall94fd0472014-12-08 11:52:42 -08001732
kelvin-onlabd3b64892015-01-20 13:26:24 -08001733 def onosStatus( self, node="" ):
kelvin8ec71442015-01-15 16:57:00 -08001734 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001735 Calls onos command: 'onos-service [<node-ip>] status'
kelvin8ec71442015-01-15 16:57:00 -08001736 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001737 try:
kelvin8ec71442015-01-15 16:57:00 -08001738 self.handle.sendline( "" )
1739 self.handle.expect( "\$" )
1740 self.handle.sendline( "onos-service " + str( node ) +
1741 " status" )
1742 i = self.handle.expect( [
You Wangef1e6572016-03-08 12:53:18 -08001743 "start/running",
You Wang7bd83062016-03-01 11:50:00 -08001744 "Running ...",
You Wangef1e6572016-03-08 12:53:18 -08001745 "stop/waiting",
You Wang7bd83062016-03-01 11:50:00 -08001746 "Not Running ...",
kelvin8ec71442015-01-15 16:57:00 -08001747 pexpect.TIMEOUT ], timeout=120 )
YPZhangfebf7302016-05-24 16:45:56 -07001748 self.handle.sendline( "" )
1749 self.handle.expect( "\$" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001750
You Wangef1e6572016-03-08 12:53:18 -08001751 if i == 0 or i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001752 main.log.info( "ONOS is running" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001753 return main.TRUE
You Wangef1e6572016-03-08 12:53:18 -08001754 elif i == 2 or i == 3:
kelvin8ec71442015-01-15 16:57:00 -08001755 main.log.info( "ONOS is stopped" )
kelvin8ec71442015-01-15 16:57:00 -08001756 main.log.error( "ONOS service failed to check the status" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001757 main.cleanup()
1758 main.exit()
1759 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001760 main.log.error( self.name + ": EOF exception found" )
1761 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001762 main.cleanup()
1763 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001764 except Exception:
1765 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001766 main.cleanup()
1767 main.exit()
Jon Hall21270ac2015-02-16 17:59:55 -08001768
Jon Hall63604932015-02-26 17:09:50 -08001769 def setIpTables( self, ip, port='', action='add', packet_type='',
1770 direction='INPUT', rule='DROP', states=True ):
Jon Hallefbd9792015-03-05 16:11:36 -08001771 """
Jon Hall21270ac2015-02-16 17:59:55 -08001772 Description:
1773 add or remove iptables rule to DROP (default) packets from
1774 specific IP and PORT
1775 Usage:
1776 * specify action ('add' or 'remove')
1777 when removing, pass in the same argument as you would add. It will
1778 delete that specific rule.
1779 * specify the ip to block
1780 * specify the destination port to block (defaults to all ports)
1781 * optional packet type to block (default tcp)
1782 * optional iptables rule (default DROP)
1783 * optional direction to block (default 'INPUT')
Jon Hall63604932015-02-26 17:09:50 -08001784 * States boolean toggles adding all supported tcp states to the
1785 firewall rule
Jon Hall21270ac2015-02-16 17:59:55 -08001786 Returns:
1787 main.TRUE on success or
1788 main.FALSE if given invalid input or
1789 main.ERROR if there is an error in response from iptables
1790 WARNING:
1791 * This function uses root privilege iptables command which may result
1792 in unwanted network errors. USE WITH CAUTION
Jon Hallefbd9792015-03-05 16:11:36 -08001793 """
Jon Hall21270ac2015-02-16 17:59:55 -08001794
1795 # NOTE*********
1796 # The strict checking methods of this driver function is intentional
1797 # to discourage any misuse or error of iptables, which can cause
1798 # severe network errors
1799 # *************
1800
1801 # NOTE: Sleep needed to give some time for rule to be added and
1802 # registered to the instance. If you are calling this function
1803 # multiple times this sleep will prevent any errors.
1804 # DO NOT REMOVE
Jon Hall63604932015-02-26 17:09:50 -08001805 # time.sleep( 5 )
Jon Hall21270ac2015-02-16 17:59:55 -08001806 try:
1807 # input validation
1808 action_type = action.lower()
1809 rule = rule.upper()
1810 direction = direction.upper()
1811 if action_type != 'add' and action_type != 'remove':
1812 main.log.error( "Invalid action type. Use 'add' or "
1813 "'remove' table rule" )
1814 if rule != 'DROP' and rule != 'ACCEPT' and rule != 'LOG':
1815 # NOTE Currently only supports rules DROP, ACCEPT, and LOG
1816 main.log.error( "Invalid rule. Valid rules are 'DROP' or "
1817 "'ACCEPT' or 'LOG' only." )
1818 if direction != 'INPUT' and direction != 'OUTPUT':
1819 # NOTE currently only supports rules INPUT and OUPTUT
1820 main.log.error( "Invalid rule. Valid directions are"
1821 " 'OUTPUT' or 'INPUT'" )
1822 return main.FALSE
1823 return main.FALSE
1824 return main.FALSE
1825 if action_type == 'add':
1826 # -A is the 'append' action of iptables
1827 actionFlag = '-A'
1828 elif action_type == 'remove':
1829 # -D is the 'delete' rule of iptables
1830 actionFlag = '-D'
1831 self.handle.sendline( "" )
1832 self.handle.expect( "\$" )
1833 cmd = "sudo iptables " + actionFlag + " " +\
1834 direction +\
Jon Hall21270ac2015-02-16 17:59:55 -08001835 " -s " + str( ip )
Jon Hall63604932015-02-26 17:09:50 -08001836 # " -p " + str( packet_type ) +\
1837 if packet_type:
1838 cmd += " -p " + str( packet_type )
Jon Hall21270ac2015-02-16 17:59:55 -08001839 if port:
1840 cmd += " --dport " + str( port )
Jon Hall63604932015-02-26 17:09:50 -08001841 if states:
1842 cmd += " -m state --state="
1843 #FIXME- Allow user to configure which states to block
1844 cmd += "INVALID,ESTABLISHED,NEW,RELATED,UNTRACKED"
Jon Hall21270ac2015-02-16 17:59:55 -08001845 cmd += " -j " + str( rule )
1846
1847 self.handle.sendline( cmd )
1848 self.handle.expect( "\$" )
1849 main.log.warn( self.handle.before )
1850
1851 info_string = "On " + str( self.name )
1852 info_string += " " + str( action_type )
1853 info_string += " iptable rule [ "
1854 info_string += " IP: " + str( ip )
1855 info_string += " Port: " + str( port )
1856 info_string += " Rule: " + str( rule )
1857 info_string += " Direction: " + str( direction ) + " ]"
1858 main.log.info( info_string )
1859 return main.TRUE
1860 except pexpect.TIMEOUT:
1861 main.log.exception( self.name + ": Timeout exception in "
1862 "setIpTables function" )
1863 return main.ERROR
1864 except pexpect.EOF:
1865 main.log.error( self.name + ": EOF exception found" )
1866 main.log.error( self.name + ": " + self.handle.before )
1867 main.cleanup()
1868 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001869 except Exception:
1870 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall21270ac2015-02-16 17:59:55 -08001871 main.cleanup()
1872 main.exit()
1873
Jon Hall0468b042015-02-19 19:08:21 -08001874 def detailed_status(self, log_filename):
Jon Hallefbd9792015-03-05 16:11:36 -08001875 """
Jon Hall0468b042015-02-19 19:08:21 -08001876 This method is used by STS to check the status of the controller
1877 Reports RUNNING, STARTING, STOPPED, FROZEN, ERROR (and reason)
Jon Hallefbd9792015-03-05 16:11:36 -08001878 """
Jon Hall0468b042015-02-19 19:08:21 -08001879 import re
1880 try:
1881 self.handle.sendline( "" )
1882 self.handle.expect( "\$" )
1883 self.handle.sendline( "cd " + self.home )
1884 self.handle.expect( "\$" )
1885 self.handle.sendline( "service onos status" )
1886 self.handle.expect( "\$" )
1887 response = self.handle.before
1888 if re.search( "onos start/running", response ):
1889 # onos start/running, process 10457
1890 return 'RUNNING'
1891 # FIXME: Implement this case
1892 # elif re.search( pattern, response ):
1893 # return 'STARTING'
1894 elif re.search( "onos stop/", response ):
1895 # onos stop/waiting
1896 # FIXME handle this differently?: onos stop/pre-stop
1897 return 'STOPPED'
1898 # FIXME: Implement this case
1899 # elif re.search( pattern, response ):
1900 # return 'FROZEN'
1901 else:
1902 main.log.warn( self.name +
Jon Hallefbd9792015-03-05 16:11:36 -08001903 " WARNING: status received unknown response" )
Jon Hall0468b042015-02-19 19:08:21 -08001904 main.log.warn( response )
1905 return 'ERROR', "Unknown response: %s" % response
1906 except pexpect.TIMEOUT:
1907 main.log.exception( self.name + ": Timeout exception in "
1908 "setIpTables function" )
1909 return 'ERROR', "Pexpect Timeout"
1910 except pexpect.EOF:
1911 main.log.error( self.name + ": EOF exception found" )
1912 main.log.error( self.name + ": " + self.handle.before )
1913 main.cleanup()
1914 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001915 except Exception:
1916 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall0468b042015-02-19 19:08:21 -08001917 main.cleanup()
1918 main.exit()
1919
andrew@onlab.us3b087132015-03-11 15:00:08 -07001920 def createLinkGraphFile( self, benchIp, ONOSIpList, deviceCount):
1921 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07001922 Create/formats the LinkGraph.cfg file based on arguments
1923 -only creates a linear topology and connects islands
1924 -evenly distributes devices
andrew@onlab.us3b087132015-03-11 15:00:08 -07001925 -must be called by ONOSbench
1926
Jon Hall4ba53f02015-07-29 13:07:41 -07001927 ONOSIpList - list of all of the node IPs to be used
1928
1929 deviceCount - number of switches to be assigned
andrew@onlab.us3b087132015-03-11 15:00:08 -07001930 '''
Jon Hall6509dbf2016-06-21 17:01:17 -07001931 main.log.info("Creating link graph configuration file." )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001932 linkGraphPath = self.home + "/tools/package/etc/linkGraph.cfg"
Jon Hall4ba53f02015-07-29 13:07:41 -07001933 tempFile = "/tmp/linkGraph.cfg"
andrew@onlab.us3b087132015-03-11 15:00:08 -07001934
1935 linkGraph = open(tempFile, 'w+')
1936 linkGraph.write("# NullLinkProvider topology description (config file).\n")
1937 linkGraph.write("# The NodeId is only added if the destination is another node's device.\n")
1938 linkGraph.write("# Bugs: Comments cannot be appended to a line to be read.\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07001939
andrew@onlab.us3b087132015-03-11 15:00:08 -07001940 clusterCount = len(ONOSIpList)
Jon Hall4ba53f02015-07-29 13:07:41 -07001941
1942 if type(deviceCount) is int or type(deviceCount) is str:
andrew@onlab.us3b087132015-03-11 15:00:08 -07001943 deviceCount = int(deviceCount)
1944 switchList = [0]*(clusterCount+1)
1945 baselineSwitchCount = deviceCount/clusterCount
Jon Hall4ba53f02015-07-29 13:07:41 -07001946
andrew@onlab.us3b087132015-03-11 15:00:08 -07001947 for node in range(1, clusterCount + 1):
1948 switchList[node] = baselineSwitchCount
1949
1950 for node in range(1, (deviceCount%clusterCount)+1):
1951 switchList[node] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001952
andrew@onlab.us3b087132015-03-11 15:00:08 -07001953 if type(deviceCount) is list:
1954 main.log.info("Using provided device distribution")
1955 switchList = [0]
1956 for i in deviceCount:
1957 switchList.append(int(i))
1958
1959 tempList = ['0']
1960 tempList.extend(ONOSIpList)
1961 ONOSIpList = tempList
1962
1963 myPort = 6
1964 lastSwitch = 0
1965 for node in range(1, clusterCount+1):
1966 if switchList[node] == 0:
1967 continue
1968
1969 linkGraph.write("graph " + ONOSIpList[node] + " {\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07001970
andrew@onlab.us3b087132015-03-11 15:00:08 -07001971 if node > 1:
1972 #connect to last device on previous node
Jon Hall4ba53f02015-07-29 13:07:41 -07001973 line = ("\t0:5 -> " + str(lastSwitch) + ":6:" + lastIp + "\n") #ONOSIpList[node-1]
1974 linkGraph.write(line)
1975
1976 lastSwitch = 0
1977 for switch in range (0, switchList[node]-1):
andrew@onlab.us3b087132015-03-11 15:00:08 -07001978 line = ""
1979 line = ("\t" + str(switch) + ":" + str(myPort))
1980 line += " -- "
1981 line += (str(switch+1) + ":" + str(myPort-1) + "\n")
1982 linkGraph.write(line)
Jon Hall4ba53f02015-07-29 13:07:41 -07001983 lastSwitch = switch+1
andrew@onlab.us3b087132015-03-11 15:00:08 -07001984 lastIp = ONOSIpList[node]
Jon Hall4ba53f02015-07-29 13:07:41 -07001985
andrew@onlab.us3b087132015-03-11 15:00:08 -07001986 #lastSwitch += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001987 if node < (clusterCount):
andrew@onlab.us3b087132015-03-11 15:00:08 -07001988 #connect to first device on the next node
Jon Hall4ba53f02015-07-29 13:07:41 -07001989 line = ("\t" + str(lastSwitch) + ":6 -> 0:5:" + ONOSIpList[node+1] + "\n")
andrew@onlab.us3b087132015-03-11 15:00:08 -07001990 linkGraph.write(line)
Jon Hall4ba53f02015-07-29 13:07:41 -07001991
andrew@onlab.us3b087132015-03-11 15:00:08 -07001992 linkGraph.write("}\n")
1993 linkGraph.close()
1994
1995 #SCP
Jon Hall4ba53f02015-07-29 13:07:41 -07001996 os.system( "scp " + tempFile + " " + self.user_name + "@" + benchIp + ":" + linkGraphPath)
andrew@onlab.us3b087132015-03-11 15:00:08 -07001997 main.log.info("linkGraph.cfg creation complete")
1998
cameron@onlab.us75900962015-03-30 13:22:49 -07001999 def configNullDev( self, ONOSIpList, deviceCount, numPorts=10):
Jon Hall4ba53f02015-07-29 13:07:41 -07002000
andrew@onlab.us3b087132015-03-11 15:00:08 -07002001 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07002002 ONOSIpList = list of Ip addresses of nodes switches will be devided amongst
2003 deviceCount = number of switches to distribute, or list of values to use as custom distribution
cameron@onlab.us75900962015-03-30 13:22:49 -07002004 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 -07002005 '''
2006
Jon Hall6509dbf2016-06-21 17:01:17 -07002007 main.log.info("Configuring Null Device Provider" )
andrew@onlab.us3b087132015-03-11 15:00:08 -07002008 clusterCount = len(ONOSIpList)
2009
Jon Hall4ba53f02015-07-29 13:07:41 -07002010 try:
2011
cameron@onlab.us75900962015-03-30 13:22:49 -07002012 if type(deviceCount) is int or type(deviceCount) is str:
Jon Hall6509dbf2016-06-21 17:01:17 -07002013 main.log.info("Creating device distribution")
cameron@onlab.us75900962015-03-30 13:22:49 -07002014 deviceCount = int(deviceCount)
2015 switchList = [0]*(clusterCount+1)
2016 baselineSwitchCount = deviceCount/clusterCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07002017
cameron@onlab.us75900962015-03-30 13:22:49 -07002018 for node in range(1, clusterCount + 1):
2019 switchList[node] = baselineSwitchCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07002020
cameron@onlab.us75900962015-03-30 13:22:49 -07002021 for node in range(1, (deviceCount%clusterCount)+1):
2022 switchList[node] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07002023
2024 if type(deviceCount) is list:
2025 main.log.info("Using provided device distribution")
2026
2027 if len(deviceCount) == clusterCount:
cameron@onlab.us75900962015-03-30 13:22:49 -07002028 switchList = ['0']
2029 switchList.extend(deviceCount)
Jon Hall4ba53f02015-07-29 13:07:41 -07002030
2031 if len(deviceCount) == (clusterCount + 1):
2032 if deviceCount[0] == '0' or deviceCount[0] == 0:
cameron@onlab.us75900962015-03-30 13:22:49 -07002033 switchList = deviceCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07002034
cameron@onlab.us75900962015-03-30 13:22:49 -07002035 assert len(switchList) == (clusterCount + 1)
Jon Hall4ba53f02015-07-29 13:07:41 -07002036
cameron@onlab.us75900962015-03-30 13:22:49 -07002037 except AssertionError:
Jon Hall4ba53f02015-07-29 13:07:41 -07002038 main.log.error( "Bad device/Ip list match")
cameron@onlab.us75900962015-03-30 13:22:49 -07002039 except TypeError:
2040 main.log.exception( self.name + ": Object not as expected" )
2041 return None
Jon Hall77ba41c2015-04-06 10:25:40 -07002042 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002043 main.log.exception( self.name + ": Uncaught exception!" )
2044 main.cleanup()
2045 main.exit()
2046
andrew@onlab.us3b087132015-03-11 15:00:08 -07002047
2048 ONOSIp = [0]
2049 ONOSIp.extend(ONOSIpList)
Jon Hall4ba53f02015-07-29 13:07:41 -07002050
andrew@onlab.us3b087132015-03-11 15:00:08 -07002051 devicesString = "devConfigs = "
2052 for node in range(1, len(ONOSIp)):
2053 devicesString += (ONOSIp[node] + ":" + str(switchList[node] ))
2054 if node < clusterCount:
2055 devicesString += (",")
Jon Hall4ba53f02015-07-29 13:07:41 -07002056
2057 try:
cameron@onlab.us75900962015-03-30 13:22:49 -07002058 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider devConfigs " + devicesString )
2059 self.handle.expect(":~")
2060 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider numPorts " + str(numPorts) )
2061 self.handle.expect(":~")
andrew@onlab.us3b087132015-03-11 15:00:08 -07002062
cameron@onlab.us75900962015-03-30 13:22:49 -07002063 for i in range(10):
2064 self.handle.sendline("onos $OC1 cfg get org.onosproject.provider.nil.device.impl.NullDeviceProvider")
2065 self.handle.expect(":~")
2066 verification = self.handle.before
2067 if (" value=" + str(numPorts)) in verification and (" value=" + devicesString) in verification:
2068 break
2069 else:
2070 time.sleep(1)
andrew@onlab.us3b087132015-03-11 15:00:08 -07002071
cameron@onlab.us2cc8bf12015-04-02 14:12:30 -07002072 assert ("value=" + str(numPorts)) in verification and (" value=" + devicesString) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002073
cameron@onlab.us75900962015-03-30 13:22:49 -07002074 except AssertionError:
2075 main.log.error("Incorrect Config settings: " + verification)
Jon Hall77ba41c2015-04-06 10:25:40 -07002076 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002077 main.log.exception( self.name + ": Uncaught exception!" )
2078 main.cleanup()
2079 main.exit()
2080
Jon Hall4ba53f02015-07-29 13:07:41 -07002081 def configNullLink( self,fileName="/opt/onos/apache-karaf-3.0.3/etc/linkGraph.cfg", eventRate=0):
andrew@onlab.us3b087132015-03-11 15:00:08 -07002082 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07002083 fileName default is currently the same as the default on ONOS, specify alternate file if
cameron@onlab.us75900962015-03-30 13:22:49 -07002084 you want to use a different topology file than linkGraph.cfg
andrew@onlab.us3b087132015-03-11 15:00:08 -07002085 '''
2086
Jon Hall4ba53f02015-07-29 13:07:41 -07002087
2088 try:
2089 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider eventRate " + str(eventRate))
2090 self.handle.expect(":~")
cameron@onlab.us75900962015-03-30 13:22:49 -07002091 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider cfgFile " + fileName )
2092 self.handle.expect(":~")
Jon Hall4ba53f02015-07-29 13:07:41 -07002093
2094 for i in range(10):
2095 self.handle.sendline("onos $OC1 cfg get org.onosproject.provider.nil.link.impl.NullLinkProvider")
cameron@onlab.us75900962015-03-30 13:22:49 -07002096 self.handle.expect(":~")
2097 verification = self.handle.before
Jon Hall4ba53f02015-07-29 13:07:41 -07002098 if (" value=" + str(eventRate)) in verification and (" value=" + fileName) in verification:
cameron@onlab.us75900962015-03-30 13:22:49 -07002099 break
Jon Hall4ba53f02015-07-29 13:07:41 -07002100 else:
cameron@onlab.us75900962015-03-30 13:22:49 -07002101 time.sleep(1)
Jon Hall4ba53f02015-07-29 13:07:41 -07002102
cameron@onlab.us75900962015-03-30 13:22:49 -07002103 assert ("value=" + str(eventRate)) in verification and (" value=" + fileName) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002104
cameron@onlab.us75900962015-03-30 13:22:49 -07002105 except pexpect.EOF:
2106 main.log.error( self.name + ": EOF exception found" )
2107 main.log.error( self.name + ": " + self.handle.before )
2108 main.cleanup()
2109 main.exit()
cameron@onlab.us75900962015-03-30 13:22:49 -07002110 except AssertionError:
2111 main.log.info("Settings did not post to ONOS")
Jon Hall4ba53f02015-07-29 13:07:41 -07002112 main.log.error(varification)
Jon Hall77ba41c2015-04-06 10:25:40 -07002113 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002114 main.log.exception( self.name + ": Uncaught exception!" )
2115 main.log.error(varification)
2116 main.cleanup()
2117 main.exit()
andrew@onlab.us3b087132015-03-11 15:00:08 -07002118
kelvin-onlaba4074292015-07-09 15:19:49 -07002119 def getOnosIps( self ):
2120 """
2121 Get all onos IPs stored in
2122 """
cameron@onlab.us59d29d92015-05-11 14:31:54 -07002123
kelvin-onlaba4074292015-07-09 15:19:49 -07002124 return sorted( self.onosIps.values() )
cameron@onlab.us59d29d92015-05-11 14:31:54 -07002125
Chiyu Chengec63bde2016-11-17 18:11:36 -08002126 def listLog( self, nodeIp ):
2127 """
2128 Get a list of all the karaf log names
2129 """
2130 try:
2131 cmd = "onos-ssh " + nodeIp + " ls -tr /opt/onos/log"
2132 self.handle.sendline( cmd )
2133 self.handle.expect( ":~" )
2134 before = self.handle.before.splitlines()
2135 logNames = []
2136 for word in before:
2137 if 'karaf.log' in word:
2138 logNames.append( word )
2139 return logNames
2140 except pexpect.EOF:
2141 main.log.error( self.name + ": EOF exception found" )
2142 main.log.error( self.name + ": " + self.handle.before )
2143 main.cleanup()
2144 main.exit()
2145 except pexpect.TIMEOUT:
2146 main.log.error( self.name + ": TIMEOUT exception found" )
2147 main.log.error( self.name + ": " + self.handle.before )
2148 main.cleanup()
2149 main.exit()
2150 except Exception:
2151 main.log.exception( self.name + ": Uncaught exception!" )
2152 main.cleanup()
2153 main.exit()
2154
kelvin-onlaba4074292015-07-09 15:19:49 -07002155 def logReport( self, nodeIp, searchTerms, outputMode="s" ):
Jon Hallb4242222016-01-25 17:07:04 -08002156 """
2157 Searches the latest ONOS log file for the given search terms and
2158 prints the total occurances of each term. Returns to combined total of
2159 all occurances.
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002160
Jon Hallb4242222016-01-25 17:07:04 -08002161 Arguments:
2162 * nodeIp - The ip of the ONOS node where the log is located
2163 * searchTerms - A string to grep for or a list of strings to grep
2164 for in the ONOS log. Will print out the number of
2165 occurances for each term.
2166 Optional Arguments:
2167 * outputMode - 's' or 'd'. If 'd' will print the last 5 lines
2168 containing each search term as well as the total
2169 number of occurances of each term. Defaults to 's',
2170 which prints the simple output of just the number
2171 of occurances for each term.
2172 """
2173 try:
2174 main.log.info( " Log Report for {} ".format( nodeIp ).center( 70, '=' ) )
2175 if type( searchTerms ) is str:
2176 searchTerms = [searchTerms]
2177 numTerms = len( searchTerms )
2178 outputMode = outputMode.lower()
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002179
Jon Hallb4242222016-01-25 17:07:04 -08002180 totalHits = 0
2181 logLines = []
2182 for termIndex in range( numTerms ):
2183 term = searchTerms[termIndex]
2184 logLines.append( [term] )
2185 cmd = "onos-ssh " + nodeIp + " cat /opt/onos/log/karaf.log | grep " + term
2186 self.handle.sendline( cmd )
2187 self.handle.expect( ":~" )
2188 before = self.handle.before.splitlines()
2189 count = 0
2190 for line in before:
2191 if term in line and "grep" not in line:
2192 count += 1
2193 if before.index( line ) > ( len( before ) - 7 ):
2194 logLines[termIndex].append( line )
2195 main.log.info( "{}: {}".format( term, count ) )
2196 totalHits += count
2197 if termIndex == numTerms - 1:
2198 print "\n"
2199 if outputMode != "s":
2200 outputString = ""
2201 for term in logLines:
2202 outputString = term[0] + ": \n"
2203 for line in range( 1, len( term ) ):
2204 outputString += ( "\t" + term[line] + "\n" )
2205 if outputString != ( term[0] + ": \n" ):
2206 main.log.info( outputString )
2207 main.log.info( "=" * 70 )
2208 return totalHits
2209 except pexpect.EOF:
2210 main.log.error( self.name + ": EOF exception found" )
2211 main.log.error( self.name + ": " + self.handle.before )
2212 main.cleanup()
2213 main.exit()
2214 except pexpect.TIMEOUT:
2215 main.log.error( self.name + ": TIMEOUT exception found" )
2216 main.log.error( self.name + ": " + self.handle.before )
2217 main.cleanup()
2218 main.exit()
2219 except Exception:
2220 main.log.exception( self.name + ": Uncaught exception!" )
2221 main.cleanup()
2222 main.exit()
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002223
2224 def copyMininetFile( self, fileName, localPath, userName, ip,
2225 mnPath='~/mininet/custom/', timeout = 60 ):
2226 """
2227 Description:
2228 Copy mininet topology file from dependency folder in the test folder
2229 and paste it to the mininet machine's mininet/custom folder
2230 Required:
2231 fileName - Name of the topology file to copy
2232 localPath - File path of the mininet topology file
2233 userName - User name of the mininet machine to send the file to
2234 ip - Ip address of the mininet machine
2235 Optional:
2236 mnPath - of the mininet directory to send the file to
2237 Return:
2238 Return main.TRUE if successfully copied the file otherwise
2239 return main.FALSE
2240 """
2241
2242 try:
2243 cmd = "scp " + localPath + fileName + " " + userName + "@" + \
2244 str( ip ) + ":" + mnPath + fileName
2245
2246 self.handle.sendline( "" )
2247 self.handle.expect( "\$" )
2248
2249 main.log.info( self.name + ": Execute: " + cmd )
2250
2251 self.handle.sendline( cmd )
2252
2253 i = self.handle.expect( [ 'No such file',
2254 "100%",
2255 pexpect.TIMEOUT ] )
2256
2257 if i == 0:
2258 main.log.error( self.name + ": File " + fileName +
2259 " does not exist!" )
2260 return main.FALSE
2261
2262 if i == 1:
2263 main.log.info( self.name + ": File " + fileName +
2264 " has been copied!" )
2265 self.handle.sendline( "" )
2266 self.handle.expect( "\$" )
2267 return main.TRUE
2268
2269 except pexpect.EOF:
2270 main.log.error( self.name + ": EOF exception found" )
2271 main.log.error( self.name + ": " + self.handle.before )
2272 main.cleanup()
2273 main.exit()
2274 except pexpect.TIMEOUT:
2275 main.log.error( self.name + ": TIMEOUT exception found" )
2276 main.log.error( self.name + ": " + self.handle.before )
2277 main.cleanup()
2278 main.exit()
cameron@onlab.us78b89652015-07-08 15:21:03 -07002279
2280 def jvmSet(self, memory=8):
Jon Hall4ba53f02015-07-29 13:07:41 -07002281
cameron@onlab.us78b89652015-07-08 15:21:03 -07002282 import os
2283
2284 homeDir = os.path.expanduser('~')
2285 filename = "/onos/tools/package/bin/onos-service"
2286
2287 serviceConfig = open(homeDir + filename, 'w+')
2288 serviceConfig.write("#!/bin/bash\n ")
2289 serviceConfig.write("#------------------------------------- \n ")
2290 serviceConfig.write("# Starts ONOS Apache Karaf container\n ")
2291 serviceConfig.write("#------------------------------------- \n ")
2292 serviceConfig.write("#export JAVA_HOME=${JAVA_HOME:-/usr/lib/jvm/java-7-openjdk-amd64/}\n ")
2293 serviceConfig.write("""export JAVA_OPTS="${JAVA_OPTS:--Xms""" + str(memory) + "G -Xmx" + str(memory) + """G}" \n """)
2294 serviceConfig.write("[ -d $ONOS_HOME ] && cd $ONOS_HOME || ONOS_HOME=$(dirname $0)/..\n")
2295 serviceConfig.write("""${ONOS_HOME}/apache-karaf-$KARAF_VERSION/bin/karaf "$@" \n """)
2296 serviceConfig.close()
2297
Jon Hall6c44c0b2016-04-20 15:21:00 -07002298 def createDBFile( self, testData ):
Jon Hall4ba53f02015-07-29 13:07:41 -07002299
cameron@onlab.us78b89652015-07-08 15:21:03 -07002300 filename = main.TEST + "DB"
2301 DBString = ""
Jon Hall4ba53f02015-07-29 13:07:41 -07002302
cameron@onlab.us78b89652015-07-08 15:21:03 -07002303 for item in testData:
Jon Hall6c44c0b2016-04-20 15:21:00 -07002304 if type( item ) is string:
cameron@onlab.us78b89652015-07-08 15:21:03 -07002305 item = "'" + item + "'"
Jon Hall6c44c0b2016-04-20 15:21:00 -07002306 if testData.index( item ) < len( testData - 1 ):
cameron@onlab.us78b89652015-07-08 15:21:03 -07002307 item += ","
Jon Hall6c44c0b2016-04-20 15:21:00 -07002308 DBString += str( item )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002309
Jon Hall6c44c0b2016-04-20 15:21:00 -07002310 DBFile = open( filename, "a" )
2311 DBFile.write( DBString )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002312 DBFile.close()
2313
Jon Hall6c44c0b2016-04-20 15:21:00 -07002314 def verifySummary( self, ONOSIp, *deviceCount ):
cameron@onlab.us78b89652015-07-08 15:21:03 -07002315
Jon Hall6c44c0b2016-04-20 15:21:00 -07002316 self.handle.sendline( "onos " + ONOSIp + " summary" )
2317 self.handle.expect( ":~" )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002318
2319 summaryStr = self.handle.before
2320 print "\nSummary\n==============\n" + summaryStr + "\n\n"
2321
2322 #passed = "SCC(s)=1" in summaryStr
2323 #if deviceCount:
2324 # passed = "devices=" + str(deviceCount) + "," not in summaryStr
2325
GlennRC772363b2015-08-25 13:05:57 -07002326 passed = False
cameron@onlab.us78b89652015-07-08 15:21:03 -07002327 if "SCC(s)=1," in summaryStr:
2328 passed = True
Jon Hall6c44c0b2016-04-20 15:21:00 -07002329 print "Summary is verifed"
Jon Hall4ba53f02015-07-29 13:07:41 -07002330 else:
Jon Hall6c44c0b2016-04-20 15:21:00 -07002331 print "Summary failed"
cameron@onlab.us78b89652015-07-08 15:21:03 -07002332
2333 if deviceCount:
2334 print" ============================="
Jon Hall6c44c0b2016-04-20 15:21:00 -07002335 checkStr = "devices=" + str( deviceCount[0] ) + ","
cameron@onlab.us78b89652015-07-08 15:21:03 -07002336 print "Checkstr: " + checkStr
2337 if checkStr not in summaryStr:
2338 passed = False
Jon Hall6c44c0b2016-04-20 15:21:00 -07002339 print "Device count failed"
Jon Hall4ba53f02015-07-29 13:07:41 -07002340 else:
2341 print "device count verified"
cameron@onlab.us78b89652015-07-08 15:21:03 -07002342
2343 return passed
Jon Hall6c44c0b2016-04-20 15:21:00 -07002344
Jon Hall8f6d4622016-05-23 15:27:18 -07002345 def getIpAddr( self, iface=None ):
Jon Hall6c44c0b2016-04-20 15:21:00 -07002346 """
2347 Update self.ip_address with numerical ip address. If multiple IP's are
2348 located on the device, will attempt to use self.nicAddr to choose the
2349 right one. Defaults to 127.0.0.1 if no other address is found or cannot
2350 determine the correct address.
2351
2352 ONLY WORKS WITH IPV4 ADDRESSES
2353 """
2354 try:
Jon Hall8f6d4622016-05-23 15:27:18 -07002355 LOCALHOST = "127.0.0.1"
Jon Hall6c44c0b2016-04-20 15:21:00 -07002356 ipPat = "\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"
2357 pattern = re.compile( ipPat )
2358 match = re.search( pattern, self.ip_address )
2359 if self.nicAddr:
2360 nicPat = self.nicAddr.replace( ".", "\." ).replace( "\*", r"\d{1,3}" )
2361 nicPat = re.compile( nicPat )
2362 else:
2363 nicPat = None
2364 # IF self.ip_address is an ip address and matches
2365 # self.nicAddr: return self.ip_address
2366 if match:
2367 curIp = match.group(0)
2368 if nicPat:
2369 nicMatch = re.search( nicPat, curIp )
2370 if nicMatch:
2371 return self.ip_address
Jon Hall8f6d4622016-05-23 15:27:18 -07002372 # ELSE: IF iface, return ip of interface
2373 cmd = "ifconfig"
2374 ifPat = re.compile( "inet addr:({})".format( ipPat ) )
2375 if iface:
2376 cmd += " " + str( iface )
2377 raw = subprocess.check_output( cmd.split() )
Jon Hall6c44c0b2016-04-20 15:21:00 -07002378 ifPat = re.compile( "inet addr:({})".format( ipPat ) )
2379 ips = re.findall( ifPat, raw )
Jon Hall8f6d4622016-05-23 15:27:18 -07002380 if iface:
2381 if ips:
2382 ip = ips[0]
2383 self.ip_address = ip
2384 return ip
2385 else:
2386 main.log.error( "Error finding ip, ifconfig output:".format( raw ) )
2387 # ELSE: attempt to get address matching nicPat.
Jon Hall6c44c0b2016-04-20 15:21:00 -07002388 if nicPat:
2389 for ip in ips:
2390 curMatch = re.search( nicPat, ip )
2391 if curMatch:
2392 self.ip_address = ip
2393 return ip
Jon Hall8f6d4622016-05-23 15:27:18 -07002394 else: # If only one non-localhost ip, return that
2395 tmpList = [ ip for ip in ips if ip is not LOCALHOST ]
Jon Hall6c44c0b2016-04-20 15:21:00 -07002396 if len(tmpList) == 1:
2397 curIp = tmpList[0]
2398 self.ip_address = curIp
2399 return curIp
Jon Hall8f6d4622016-05-23 15:27:18 -07002400 # Either no non-localhost IPs, or more than 1
Jon Hallebccd352016-05-20 15:17:17 -07002401 main.log.warn( "getIpAddr failed to find a public IP address" )
Jon Hall8f6d4622016-05-23 15:27:18 -07002402 return LOCALHOST
Jon Halle1790952016-05-23 15:51:46 -07002403 except subprocess.CalledProcessError:
Jon Hall8f6d4622016-05-23 15:27:18 -07002404 main.log.exception( "Error executing ifconfig" )
2405 except IndexError:
2406 main.log.exception( "Error getting IP Address" )
Jon Hall6c44c0b2016-04-20 15:21:00 -07002407 except Exception:
2408 main.log.exception( "Uncaught exception" )
suibin zhang116647a2016-05-06 16:30:09 -07002409
You Wangc669d212017-01-25 11:09:48 -08002410 def startBasicONOS( self, nodeList, opSleep=60, onosStartupSleep=30 ):
suibin zhang116647a2016-05-06 16:30:09 -07002411 '''
2412 Start onos cluster with defined nodes, but only with drivers app
suibin zhang116647a2016-05-06 16:30:09 -07002413 '''
2414 import time
2415
2416 self.createCellFile( self.ip_address,
2417 "temp",
2418 self.ip_address,
2419 "drivers",
2420 nodeList )
2421
2422 main.log.info( self.name + ": Apply cell to environment" )
2423 cellResult = self.setCell( "temp" )
2424 verifyResult = self.verifyCell()
2425
2426 main.log.info( self.name + ": Creating ONOS package" )
You Wangd1bcaca2016-10-24 15:23:26 -07002427 packageResult = self.buckBuild( timeout=opSleep )
suibin zhang116647a2016-05-06 16:30:09 -07002428
You Wangc669d212017-01-25 11:09:48 -08002429 main.log.info( self.name + ": Uninstalling ONOS" )
2430 for nd in nodeList:
2431 self.onosUninstall( nodeIp=nd )
2432
suibin zhang116647a2016-05-06 16:30:09 -07002433 main.log.info( self.name + ": Installing ONOS package" )
2434 for nd in nodeList:
You Wangc669d212017-01-25 11:09:48 -08002435 self.onosInstall( node=nd )
2436
2437 main.log.info( self.name + ": Set up ONOS secure SSH" )
2438 for nd in nodeList:
2439 self.onosSecureSSH( node=nd )
suibin zhang116647a2016-05-06 16:30:09 -07002440
2441 main.log.info( self.name + ": Starting ONOS service" )
2442 time.sleep( onosStartupSleep )
2443
2444 onosStatus = True
2445 for nd in nodeList:
2446 onosStatus = onosStatus & self.isup( node = nd )
2447 #print "onosStatus is: " + str( onosStatus )
2448
2449 return main.TRUE if onosStatus else main.FALSE
2450
Jeremy Songster5665f1b2016-06-20 14:38:22 -07002451 def onosNetCfg( self, controllerIps, path, fileName ):
2452 """
2453 Push a specified json file to ONOS through the onos-netcfg service
2454
2455 Required:
2456 controllerIps - the Ips of the ONOS nodes in the cluster
2457 path - the location of the file to be sent
2458 fileName - name of the json file to be sent
2459
2460 Returns main.TRUE on successfully sending json file, and main.FALSE if
2461 there is an error.
2462 """
2463 try:
2464 cmd = "onos-netcfg {0} {1}{2}.json".format( controllerIps, path, fileName )
2465 main.log.info( "Sending: " + cmd )
2466 main.ONOSbench.handle.sendline( cmd )
2467 handle = self.handle.before
2468 print handle
2469 if "Error" in handle:
2470 main.log.error( self.name + ": " + self.handle.before )
2471 return main.FALSE
2472 else:
2473 self.handle.expect( "\$" )
2474 return main.TRUE
2475 except pexpect.EOF:
2476 main.log.error( self.name + ": EOF exception found" )
2477 main.log.error( self.name + ": " + self.handle.before )
2478 main.cleanup()
2479 main.exit()
2480 except Exception:
2481 main.log.exception( self.name + ": Uncaught exception!" )
2482 main.cleanup()
Jeremy Songsterae01bba2016-07-11 15:39:17 -07002483 main.exit()