blob: 2f38e29d42b95081ec5ea84150deee4f837b9f41 [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,
Pier88189b62016-09-07 17:01:53 -0700730 appString, onosIpAddrs, onosUser="sdn", useSSH=False ):
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 """
748 # Variable initialization
Jon Hall6801cda2015-07-15 14:13:45 -0700749 cellDirectory = self.home + "/tools/test/cells/"
kelvin8ec71442015-01-15 16:57:00 -0800750 # We want to create the cell file in the dependencies directory
751 # of TestON first, then copy over to ONOS bench
kelvin-onlabd3b64892015-01-20 13:26:24 -0800752 tempDirectory = "/tmp/"
kelvin8ec71442015-01-15 16:57:00 -0800753 # Create the cell file in the directory for writing ( w+ )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800754 cellFile = open( tempDirectory + fileName, 'w+' )
Jon Hall6801cda2015-07-15 14:13:45 -0700755 if isinstance( onosIpAddrs, types.StringType ):
756 onosIpAddrs = [ onosIpAddrs ]
kelvin8ec71442015-01-15 16:57:00 -0800757
cameron@onlab.us75900962015-03-30 13:22:49 -0700758 # App string is hardcoded environment variables
kelvin8ec71442015-01-15 16:57:00 -0800759 # That you may wish to use by default on startup.
cameron@onlab.us75900962015-03-30 13:22:49 -0700760 # Note that you may not want certain apps listed
kelvin8ec71442015-01-15 16:57:00 -0800761 # on here.
cameron@onlab.us75900962015-03-30 13:22:49 -0700762 appString = "export ONOS_APPS=" + appString
Flavio Castrocc38a542016-03-03 13:15:46 -0800763 onosGroup = "export ONOS_GROUP=" + onosUser
764 onosUser = "export ONOS_USER=" + onosUser
Pier88189b62016-09-07 17:01:53 -0700765 if useSSH:
766 onosUseSSH = "export ONOS_USE_SSH=true"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800767 mnString = "export OCN="
kelvin-onlabf70fd542015-05-07 18:41:40 -0700768 if mnIpAddrs == "":
769 mnString = ""
kelvin-onlabd3b64892015-01-20 13:26:24 -0800770 onosString = "export OC"
771 tempCount = 1
kelvin8ec71442015-01-15 16:57:00 -0800772
kelvin-onlabd3b64892015-01-20 13:26:24 -0800773 # Create ONOSNIC ip address prefix
kelvin-onlaba4074292015-07-09 15:19:49 -0700774 tempOnosIp = str( onosIpAddrs[ 0 ] )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800775 tempList = []
776 tempList = tempOnosIp.split( "." )
kelvin8ec71442015-01-15 16:57:00 -0800777 # Omit last element of list to format for NIC
kelvin-onlabd3b64892015-01-20 13:26:24 -0800778 tempList = tempList[ :-1 ]
kelvin8ec71442015-01-15 16:57:00 -0800779 # Structure the nic string ip
kelvin-onlabd3b64892015-01-20 13:26:24 -0800780 nicAddr = ".".join( tempList ) + ".*"
Jon Hall6c44c0b2016-04-20 15:21:00 -0700781 self.nicAddr = nicAddr
kelvin-onlabd3b64892015-01-20 13:26:24 -0800782 onosNicString = "export ONOS_NIC=" + nicAddr
andrewonlab94282092014-10-10 13:00:11 -0400783
784 try:
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:
996 self.handle.sendline( " onos-secure-ssh -u " + userName + " -p " + userPWD + " " + node )
997
998 # NOTE: this timeout may need to change depending on the network
999 # and size of ONOS
1000 # TODO: Handle the other possible error
1001 i = self.handle.expect([ "Network\sis\sunreachable",
1002 "\$",
1003 pexpect.TIMEOUT ], timeout=180 )
1004 if i == 0:
1005 # can't reach ONOS node
1006 main.log.warn( "Network is unreachable" )
1007 self.handle.expect( "\$" )
1008 return main.FALSE
1009 elif i == 1:
1010 # Process started
1011 main.log.info(
1012 "Secure SSH performed on " +
1013 node)
1014 return main.TRUE
1015 except pexpect.EOF:
1016 main.log.error( self.name + ": EOF exception found" )
1017 main.log.error( self.name + ": " + self.handle.before )
1018 main.cleanup()
1019 main.exit()
1020 except Exception:
1021 main.log.exception( self.name + ": Uncaught exception!" )
1022 main.cleanup()
1023 main.exit()
1024
1025
kelvin-onlabd3b64892015-01-20 13:26:24 -08001026 def onosInstall( self, options="-f", node="" ):
kelvin8ec71442015-01-15 16:57:00 -08001027 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001028 Installs ONOS bits on the designated cell machine.
kelvin8ec71442015-01-15 16:57:00 -08001029 If -f option is provided, it also forces an uninstall.
1030 Presently, install also includes onos-push-bits and
Jon Hall7993bfc2014-10-09 16:30:14 -04001031 onos-config within.
kelvin8ec71442015-01-15 16:57:00 -08001032 The node option allows you to selectively only push the jar
Jon Hall7993bfc2014-10-09 16:30:14 -04001033 files to certain onos nodes
1034
1035 Returns: main.TRUE on success and main.FALSE on failure
kelvin8ec71442015-01-15 16:57:00 -08001036 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001037 try:
andrewonlab114768a2014-11-14 12:44:44 -05001038 if options:
kelvin8ec71442015-01-15 16:57:00 -08001039 self.handle.sendline( "onos-install " + options + " " + node )
andrewonlab114768a2014-11-14 12:44:44 -05001040 else:
kelvin8ec71442015-01-15 16:57:00 -08001041 self.handle.sendline( "onos-install " + node )
1042 self.handle.expect( "onos-install " )
1043 # NOTE: this timeout may need to change depending on the network
1044 # and size of ONOS
1045 i = self.handle.expect( [ "Network\sis\sunreachable",
kelvin-onlabd3b64892015-01-20 13:26:24 -08001046 "onos\sstart/running,\sprocess",
kelvin8ec71442015-01-15 16:57:00 -08001047 "ONOS\sis\salready\sinstalled",
Jeremyc72b2582016-02-26 18:27:38 -08001048 "already\sup-to-date",
Jon Hall3576f572016-08-23 10:01:07 -07001049 "does not exist",
Jeremyc72b2582016-02-26 18:27:38 -08001050 "\$",
Jon Hall6c44c0b2016-04-20 15:21:00 -07001051 pexpect.TIMEOUT ], timeout=180 )
Jon Hall7993bfc2014-10-09 16:30:14 -04001052 if i == 0:
Jon Hall3576f572016-08-23 10:01:07 -07001053 # can't reach ONOS node
kelvin8ec71442015-01-15 16:57:00 -08001054 main.log.warn( "Network is unreachable" )
Jon Hall3b489db2015-10-05 14:38:37 -07001055 self.handle.expect( "\$" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001056 return main.FALSE
1057 elif i == 1:
Jon Hall3576f572016-08-23 10:01:07 -07001058 # Process started
kelvin8ec71442015-01-15 16:57:00 -08001059 main.log.info(
1060 "ONOS was installed on " +
1061 node +
1062 " and started" )
Jon Hall3b489db2015-10-05 14:38:37 -07001063 self.handle.expect( "\$" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001064 return main.TRUE
Jon Hall3576f572016-08-23 10:01:07 -07001065 elif i == 2 or i == 3:
1066 # same bits are already on ONOS node
Jeremyc72b2582016-02-26 18:27:38 -08001067 main.log.info( "ONOS is already installed on " + node )
1068 self.handle.expect( "\$" )
1069 return main.TRUE
1070 elif i == 4:
Jon Hall3576f572016-08-23 10:01:07 -07001071 # onos not packaged
1072 main.log.error( "ONOS package not found." )
1073 self.handle.expect( "\$" )
1074 return main.FALSE
1075 elif i == 5:
1076 # prompt
Jeremyc72b2582016-02-26 18:27:38 -08001077 main.log.info( "ONOS was installed on " + node )
1078 return main.TRUE
Jon Hall3576f572016-08-23 10:01:07 -07001079 elif i == 6:
1080 # timeout
kelvin8ec71442015-01-15 16:57:00 -08001081 main.log.info(
1082 "Installation of ONOS on " +
1083 node +
1084 " timed out" )
Jon Hall3b489db2015-10-05 14:38:37 -07001085 self.handle.expect( "\$" )
Jon Hall53c5e662016-04-13 16:06:56 -07001086 main.log.warn( self.handle.before )
Jon Hall7993bfc2014-10-09 16:30:14 -04001087 return main.FALSE
andrewonlabc03bf6c2014-10-09 14:56:18 -04001088 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001089 main.log.error( self.name + ": EOF exception found" )
1090 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc03bf6c2014-10-09 14:56:18 -04001091 main.cleanup()
1092 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001093 except Exception:
1094 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc03bf6c2014-10-09 14:56:18 -04001095 main.cleanup()
1096 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -04001097
kelvin-onlabd3b64892015-01-20 13:26:24 -08001098 def onosStart( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001099 """
andrewonlab8d0d7d72014-10-09 16:33:15 -04001100 Calls onos command: 'onos-service [<node-ip>] start'
andrewonlabe8e56fd2014-10-09 17:12:44 -04001101 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -08001102 """
andrewonlab8d0d7d72014-10-09 16:33:15 -04001103 try:
kelvin8ec71442015-01-15 16:57:00 -08001104 self.handle.sendline( "" )
1105 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001106 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001107 " start" )
1108 i = self.handle.expect( [
andrewonlab8d0d7d72014-10-09 16:33:15 -04001109 "Job\sis\salready\srunning",
1110 "start/running",
Jeremyd0e9a6d2016-03-02 11:28:52 -08001111 "\$",
andrewonlab8d0d7d72014-10-09 16:33:15 -04001112 "Unknown\sinstance",
Jeremy Songster14c13572016-04-21 17:34:03 -07001113 pexpect.TIMEOUT ], timeout=180 )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001114 if i == 0:
Jon Halleab7a242016-03-04 10:20:43 -08001115 self.handle.expect( "\$" )
kelvin8ec71442015-01-15 16:57:00 -08001116 main.log.info( "Service is already running" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001117 return main.TRUE
1118 elif i == 1:
Jon Halleab7a242016-03-04 10:20:43 -08001119 self.handle.expect( "\$" )
kelvin8ec71442015-01-15 16:57:00 -08001120 main.log.info( "ONOS service started" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001121 return main.TRUE
Jeremyd0e9a6d2016-03-02 11:28:52 -08001122 elif i == 2:
1123 main.log.info( "ONOS service started" )
1124 return main.TRUE
andrewonlab8d0d7d72014-10-09 16:33:15 -04001125 else:
Jon Halleab7a242016-03-04 10:20:43 -08001126 self.handle.expect( "\$" )
kelvin8ec71442015-01-15 16:57:00 -08001127 main.log.error( "ONOS service failed to start" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001128 main.cleanup()
1129 main.exit()
andrewonlab8d0d7d72014-10-09 16:33:15 -04001130 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001131 main.log.error( self.name + ": EOF exception found" )
1132 main.log.error( self.name + ": " + self.handle.before )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001133 main.cleanup()
1134 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001135 except Exception:
1136 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001137 main.cleanup()
1138 main.exit()
1139
kelvin-onlabd3b64892015-01-20 13:26:24 -08001140 def onosStop( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001141 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001142 Calls onos command: 'onos-service [<node-ip>] stop'
andrewonlabe8e56fd2014-10-09 17:12:44 -04001143 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -08001144 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001145 try:
kelvin8ec71442015-01-15 16:57:00 -08001146 self.handle.sendline( "" )
1147 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001148 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001149 " stop" )
1150 i = self.handle.expect( [
andrewonlab2b30bd32014-10-09 16:48:55 -04001151 "stop/waiting",
Jon Hall61282e32015-03-19 11:34:11 -07001152 "Could not resolve hostname",
andrewonlab2b30bd32014-10-09 16:48:55 -04001153 "Unknown\sinstance",
YPZhang77badfc2016-03-09 10:28:59 -08001154 "\$",
Jeremy Songster14c13572016-04-21 17:34:03 -07001155 pexpect.TIMEOUT ], timeout=180 )
andrewonlab2b30bd32014-10-09 16:48:55 -04001156 if i == 0:
YPZhang77badfc2016-03-09 10:28:59 -08001157 self.handle.expect( "\$" )
kelvin8ec71442015-01-15 16:57:00 -08001158 main.log.info( "ONOS service stopped" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001159 return main.TRUE
1160 elif i == 1:
YPZhang77badfc2016-03-09 10:28:59 -08001161 self.handle.expect( "\$" )
Jon Hall65844a32015-03-09 19:09:37 -07001162 main.log.info( "onosStop() Unknown ONOS instance specified: " +
kelvin-onlabd3b64892015-01-20 13:26:24 -08001163 str( nodeIp ) )
andrewonlab2b30bd32014-10-09 16:48:55 -04001164 return main.FALSE
Jon Hall61282e32015-03-19 11:34:11 -07001165 elif i == 2:
YPZhang77badfc2016-03-09 10:28:59 -08001166 self.handle.expect( "\$" )
Jon Hall61282e32015-03-19 11:34:11 -07001167 main.log.warn( "ONOS wasn't running" )
1168 return main.TRUE
YPZhang77badfc2016-03-09 10:28:59 -08001169 elif i == 3:
1170 main.log.info( "ONOS service stopped" )
1171 return main.TRUE
andrewonlab2b30bd32014-10-09 16:48:55 -04001172 else:
kelvin8ec71442015-01-15 16:57:00 -08001173 main.log.error( "ONOS service failed to stop" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001174 return main.FALSE
andrewonlab2b30bd32014-10-09 16:48:55 -04001175 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001176 main.log.error( self.name + ": EOF exception found" )
1177 main.log.error( self.name + ": " + self.handle.before )
andrewonlab2b30bd32014-10-09 16:48:55 -04001178 main.cleanup()
1179 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001180 except Exception:
1181 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001182 main.cleanup()
1183 main.exit()
kelvin8ec71442015-01-15 16:57:00 -08001184
kelvin-onlabd3b64892015-01-20 13:26:24 -08001185 def onosUninstall( self, nodeIp="" ):
kelvin8ec71442015-01-15 16:57:00 -08001186 """
andrewonlabc8d47972014-10-09 16:52:36 -04001187 Calls the command: 'onos-uninstall'
kelvin8ec71442015-01-15 16:57:00 -08001188 Uninstalls ONOS from the designated cell machine, stopping
andrewonlabe8e56fd2014-10-09 17:12:44 -04001189 if needed
kelvin8ec71442015-01-15 16:57:00 -08001190 """
andrewonlabc8d47972014-10-09 16:52:36 -04001191 try:
kelvin8ec71442015-01-15 16:57:00 -08001192 self.handle.sendline( "" )
Jeremy Songster14c13572016-04-21 17:34:03 -07001193 self.handle.expect( "\$", timeout=180 )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001194 self.handle.sendline( "onos-uninstall " + str( nodeIp ) )
Jeremy Songster14c13572016-04-21 17:34:03 -07001195 self.handle.expect( "\$", timeout=180 )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001196 main.log.info( "ONOS " + nodeIp + " was uninstalled" )
kelvin8ec71442015-01-15 16:57:00 -08001197 # onos-uninstall command does not return any text
andrewonlabc8d47972014-10-09 16:52:36 -04001198 return main.TRUE
pingping-lin763ee042015-05-20 17:45:30 -07001199 except pexpect.TIMEOUT:
1200 main.log.exception( self.name + ": Timeout in onosUninstall" )
1201 return main.FALSE
andrewonlabc8d47972014-10-09 16:52:36 -04001202 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001203 main.log.error( self.name + ": EOF exception found" )
1204 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc8d47972014-10-09 16:52:36 -04001205 main.cleanup()
1206 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001207 except Exception:
1208 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc8d47972014-10-09 16:52:36 -04001209 main.cleanup()
1210 main.exit()
andrewonlab2b30bd32014-10-09 16:48:55 -04001211
kelvin-onlabd3b64892015-01-20 13:26:24 -08001212 def onosDie( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001213 """
andrewonlabaedc8332014-12-04 12:43:03 -05001214 Issues the command 'onos-die <node-ip>'
1215 This command calls onos-kill and also stops the node
kelvin8ec71442015-01-15 16:57:00 -08001216 """
andrewonlabaedc8332014-12-04 12:43:03 -05001217 try:
kelvin8ec71442015-01-15 16:57:00 -08001218 self.handle.sendline( "" )
1219 self.handle.expect( "\$" )
Jeremyf0aecdb2016-03-30 13:19:57 -07001220 cmdStr = "onos-die " + str( nodeIp )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001221 self.handle.sendline( cmdStr )
kelvin8ec71442015-01-15 16:57:00 -08001222 i = self.handle.expect( [
andrewonlabaedc8332014-12-04 12:43:03 -05001223 "Killing\sONOS",
1224 "ONOS\sprocess\sis\snot\srunning",
Jeremy Songster14c13572016-04-21 17:34:03 -07001225 pexpect.TIMEOUT ], timeout=60 )
andrewonlabaedc8332014-12-04 12:43:03 -05001226 if i == 0:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001227 main.log.info( "ONOS instance " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001228 " was killed and stopped" )
Jon Hall53c5e662016-04-13 16:06:56 -07001229 self.handle.sendline( "" )
1230 self.handle.expect( "\$" )
andrewonlabaedc8332014-12-04 12:43:03 -05001231 return main.TRUE
1232 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001233 main.log.info( "ONOS process was not running" )
Jon Hall53c5e662016-04-13 16:06:56 -07001234 self.handle.sendline( "" )
1235 self.handle.expect( "\$" )
andrewonlabaedc8332014-12-04 12:43:03 -05001236 return main.FALSE
1237 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001238 main.log.error( self.name + ": EOF exception found" )
1239 main.log.error( self.name + ": " + self.handle.before )
andrewonlabaedc8332014-12-04 12:43:03 -05001240 main.cleanup()
1241 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001242 except Exception:
1243 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabaedc8332014-12-04 12:43:03 -05001244 main.cleanup()
1245 main.exit()
1246
kelvin-onlabd3b64892015-01-20 13:26:24 -08001247 def onosKill( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001248 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001249 Calls the command: 'onos-kill [<node-ip>]'
1250 "Remotely, and unceremoniously kills the ONOS instance running on
1251 the specified cell machine" - Tom V
kelvin8ec71442015-01-15 16:57:00 -08001252 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001253 try:
kelvin8ec71442015-01-15 16:57:00 -08001254 self.handle.sendline( "" )
1255 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001256 self.handle.sendline( "onos-kill " + str( nodeIp ) )
kelvin8ec71442015-01-15 16:57:00 -08001257 i = self.handle.expect( [
andrewonlabe8e56fd2014-10-09 17:12:44 -04001258 "\$",
1259 "No\sroute\sto\shost",
1260 "password:",
Jeremy Songster14c13572016-04-21 17:34:03 -07001261 pexpect.TIMEOUT ], timeout=60 )
kelvin8ec71442015-01-15 16:57:00 -08001262
andrewonlabe8e56fd2014-10-09 17:12:44 -04001263 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001264 main.log.info(
1265 "ONOS instance " + str(
kelvin-onlabd3b64892015-01-20 13:26:24 -08001266 nodeIp ) + " was killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001267 return main.TRUE
1268 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001269 main.log.info( "No route to host" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001270 return main.FALSE
1271 elif i == 2:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001272 main.log.info(
1273 "Passwordless login for host: " +
1274 str( nodeIp ) +
1275 " not configured" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001276 return main.FALSE
1277 else:
Jon Hallefbd9792015-03-05 16:11:36 -08001278 main.log.info( "ONOS instance was not killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001279 return main.FALSE
kelvin8ec71442015-01-15 16:57:00 -08001280
andrewonlabe8e56fd2014-10-09 17:12:44 -04001281 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001282 main.log.error( self.name + ": EOF exception found" )
1283 main.log.error( self.name + ": " + self.handle.before )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001284 main.cleanup()
1285 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001286 except Exception:
1287 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001288 main.cleanup()
1289 main.exit()
1290
kelvin-onlabd3b64892015-01-20 13:26:24 -08001291 def onosRemoveRaftLogs( self ):
kelvin8ec71442015-01-15 16:57:00 -08001292 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001293 Removes Raft / Copy cat files from ONOS to ensure
Jon Hallfcc88622014-11-25 13:09:54 -05001294 a cleaner environment.
1295
andrewonlab19fbdca2014-11-14 12:55:59 -05001296 Description:
Jon Hallfcc88622014-11-25 13:09:54 -05001297 Stops all ONOS defined in the cell,
andrewonlab19fbdca2014-11-14 12:55:59 -05001298 wipes the raft / copycat log files
kelvin8ec71442015-01-15 16:57:00 -08001299 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001300 try:
kelvin8ec71442015-01-15 16:57:00 -08001301 self.handle.sendline( "" )
1302 self.handle.expect( "\$" )
1303 self.handle.sendline( "onos-remove-raft-logs" )
1304 # Sometimes this command hangs
1305 i = self.handle.expect( [ "\$", pexpect.TIMEOUT ],
1306 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001307 if i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001308 i = self.handle.expect( [ "\$", pexpect.TIMEOUT ],
1309 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001310 if i == 1:
1311 return main.FALSE
andrewonlab19fbdca2014-11-14 12:55:59 -05001312 return main.TRUE
andrewonlab19fbdca2014-11-14 12:55:59 -05001313 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001314 main.log.error( self.name + ": EOF exception found" )
1315 main.log.error( self.name + ": " + self.handle.before )
andrewonlab19fbdca2014-11-14 12:55:59 -05001316 main.cleanup()
1317 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001318 except Exception:
1319 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab19fbdca2014-11-14 12:55:59 -05001320 main.cleanup()
1321 main.exit()
Jon Hallfcc88622014-11-25 13:09:54 -05001322
kelvin-onlabd3b64892015-01-20 13:26:24 -08001323 def onosStartNetwork( self, mntopo ):
kelvin8ec71442015-01-15 16:57:00 -08001324 """
1325 Calls the command 'onos-start-network [ <mininet-topo> ]
1326 "remotely starts the specified topology on the cell's
andrewonlab94282092014-10-10 13:00:11 -04001327 mininet machine against all controllers configured in the
kelvin8ec71442015-01-15 16:57:00 -08001328 cell."
andrewonlab94282092014-10-10 13:00:11 -04001329 * Specify mininet topology file name for mntopo
1330 * Topo files should be placed at:
1331 ~/<your-onos-directory>/tools/test/topos
kelvin8ec71442015-01-15 16:57:00 -08001332
andrewonlab94282092014-10-10 13:00:11 -04001333 NOTE: This function will take you to the mininet prompt
kelvin8ec71442015-01-15 16:57:00 -08001334 """
andrewonlab94282092014-10-10 13:00:11 -04001335 try:
1336 if not mntopo:
kelvin8ec71442015-01-15 16:57:00 -08001337 main.log.error( "You must specify a topo file to execute" )
andrewonlab94282092014-10-10 13:00:11 -04001338 return main.FALSE
andrewonlab94282092014-10-10 13:00:11 -04001339
kelvin8ec71442015-01-15 16:57:00 -08001340 mntopo = str( mntopo )
1341 self.handle.sendline( "" )
1342 self.handle.expect( "\$" )
andrewonlab94282092014-10-10 13:00:11 -04001343
kelvin8ec71442015-01-15 16:57:00 -08001344 self.handle.sendline( "onos-start-network " + mntopo )
1345 self.handle.expect( "mininet>" )
1346 main.log.info( "Network started, entered mininet prompt" )
1347
1348 # TODO: Think about whether return is necessary or not
andrewonlab94282092014-10-10 13:00:11 -04001349
1350 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001351 main.log.error( self.name + ": EOF exception found" )
1352 main.log.error( self.name + ": " + self.handle.before )
andrewonlab94282092014-10-10 13:00:11 -04001353 main.cleanup()
1354 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001355 except Exception:
1356 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab94282092014-10-10 13:00:11 -04001357 main.cleanup()
1358 main.exit()
1359
Jeremy Songster14c13572016-04-21 17:34:03 -07001360 def isup( self, node="", timeout=240 ):
kelvin8ec71442015-01-15 16:57:00 -08001361 """
1362 Run's onos-wait-for-start which only returns once ONOS is at run
Cameron Franke9c94fb02015-01-21 10:20:20 -08001363 level 100(ready for use)
andrewonlab8d0d7d72014-10-09 16:33:15 -04001364
Jon Hall7993bfc2014-10-09 16:30:14 -04001365 Returns: main.TRUE if ONOS is running and main.FALSE on timeout
kelvin8ec71442015-01-15 16:57:00 -08001366 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001367 try:
Jon Hall3b489db2015-10-05 14:38:37 -07001368 self.handle.sendline( "onos-wait-for-start " + node )
1369 self.handle.expect( "onos-wait-for-start" )
kelvin8ec71442015-01-15 16:57:00 -08001370 # NOTE: this timeout is arbitrary"
Cameron Franke9c94fb02015-01-21 10:20:20 -08001371 i = self.handle.expect(["\$", pexpect.TIMEOUT], timeout)
Jon Hall7993bfc2014-10-09 16:30:14 -04001372 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001373 main.log.info( self.name + ": " + node + " is up" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001374 return main.TRUE
1375 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001376 # NOTE: since this function won't return until ONOS is ready,
Jon Hall7993bfc2014-10-09 16:30:14 -04001377 # we will kill it on timeout
kelvin8ec71442015-01-15 16:57:00 -08001378 main.log.error( "ONOS has not started yet" )
1379 self.handle.send( "\x03" ) # Control-C
1380 self.handle.expect( "\$" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001381 return main.FALSE
1382 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001383 main.log.error( self.name + ": EOF exception found" )
1384 main.log.error( self.name + ": " + self.handle.before )
Jon Hall7993bfc2014-10-09 16:30:14 -04001385 main.cleanup()
1386 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001387 except Exception:
1388 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001389 main.cleanup()
1390 main.exit()
andrewonlab05e362f2014-10-10 00:40:57 -04001391
kelvin-onlabd3b64892015-01-20 13:26:24 -08001392 def pushTestIntentsShell(
1393 self,
1394 dpidSrc,
1395 dpidDst,
1396 numIntents,
1397 dirFile,
1398 onosIp,
1399 numMult="",
1400 appId="",
1401 report=True,
1402 options="" ):
kelvin8ec71442015-01-15 16:57:00 -08001403 """
andrewonlabb66dfa12014-12-02 15:51:10 -05001404 Description:
kelvin8ec71442015-01-15 16:57:00 -08001405 Use the linux prompt to push test intents to
andrewonlabb66dfa12014-12-02 15:51:10 -05001406 better parallelize the results than the CLI
1407 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001408 * dpidSrc: specify source dpid
1409 * dpidDst: specify destination dpid
1410 * numIntents: specify number of intents to push
1411 * dirFile: specify directory and file name to save
andrewonlabb66dfa12014-12-02 15:51:10 -05001412 results
kelvin-onlabd3b64892015-01-20 13:26:24 -08001413 * onosIp: specify the IP of ONOS to install on
kelvin8ec71442015-01-15 16:57:00 -08001414 NOTE:
andrewonlabb66dfa12014-12-02 15:51:10 -05001415 You must invoke this command at linux shell prompt
kelvin8ec71442015-01-15 16:57:00 -08001416 """
1417 try:
1418 # Create the string to sendline
andrewonlabaedc8332014-12-04 12:43:03 -05001419 if options:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001420 baseCmd = "onos " + str( onosIp ) + " push-test-intents " +\
kelvin8ec71442015-01-15 16:57:00 -08001421 options + " "
andrewonlabaedc8332014-12-04 12:43:03 -05001422 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001423 baseCmd = "onos " + str( onosIp ) + " push-test-intents "
kelvin8ec71442015-01-15 16:57:00 -08001424
kelvin-onlabd3b64892015-01-20 13:26:24 -08001425 addDpid = baseCmd + str( dpidSrc ) + " " + str( dpidDst )
1426 if not numMult:
1427 addIntents = addDpid + " " + str( numIntents )
1428 elif numMult:
1429 addIntents = addDpid + " " + str( numIntents ) + " " +\
1430 str( numMult )
1431 if appId:
1432 addApp = addIntents + " " + str( appId )
andrewonlabb66dfa12014-12-02 15:51:10 -05001433 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001434 addApp = addIntents
andrewonlabb66dfa12014-12-02 15:51:10 -05001435
andrewonlabaedc8332014-12-04 12:43:03 -05001436 if report:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001437 sendCmd = addApp + " > " + str( dirFile ) + " &"
andrewonlabaedc8332014-12-04 12:43:03 -05001438 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001439 sendCmd = addApp + " &"
1440 main.log.info( "Send cmd: " + sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001441
kelvin-onlabd3b64892015-01-20 13:26:24 -08001442 self.handle.sendline( sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001443
1444 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001445 main.log.error( self.name + ": EOF exception found" )
1446 main.log.error( self.name + ": " + self.handle.before )
andrewonlabb66dfa12014-12-02 15:51:10 -05001447 main.cleanup()
1448 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001449 except Exception:
1450 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabb66dfa12014-12-02 15:51:10 -05001451 main.cleanup()
kelvin8ec71442015-01-15 16:57:00 -08001452 main.exit()
andrewonlab05e362f2014-10-10 00:40:57 -04001453
kelvin-onlabd3b64892015-01-20 13:26:24 -08001454 def tsharkPcap( self, interface, dirFile ):
kelvin8ec71442015-01-15 16:57:00 -08001455 """
andrewonlab970399c2014-11-07 13:09:32 -05001456 Capture all packet activity and store in specified
1457 directory/file
1458
1459 Required:
1460 * interface: interface to capture
1461 * dir: directory/filename to store pcap
kelvin8ec71442015-01-15 16:57:00 -08001462 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001463 try:
1464 self.handle.sendline( "" )
1465 self.handle.expect( "\$" )
andrewonlab970399c2014-11-07 13:09:32 -05001466
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001467 self.handle.sendline( "tshark -i " + str( interface ) + " -t e -w " + str( dirFile ) + " &" )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001468 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001469 self.handle.expect( "Capturing on" )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001470 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001471 self.handle.expect( "\$" )
andrewonlab970399c2014-11-07 13:09:32 -05001472
Jon Hallfebb1c72015-03-05 13:30:09 -08001473 main.log.info( "Tshark started capturing files on " +
1474 str( interface ) + " and saving to directory: " +
1475 str( dirFile ) )
1476 except pexpect.EOF:
1477 main.log.error( self.name + ": EOF exception found" )
1478 main.log.error( self.name + ": " + self.handle.before )
1479 main.cleanup()
1480 main.exit()
1481 except Exception:
1482 main.log.exception( self.name + ": Uncaught exception!" )
1483 main.cleanup()
1484 main.exit()
Shreya Shaha73aaad2014-10-27 18:03:09 -04001485
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001486 def onosTopoCfg( self, onosIp, jsonFile ):
kelvin8ec71442015-01-15 16:57:00 -08001487 """
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001488 Description:
1489 Execute onos-topo-cfg command
1490 Required:
1491 onosIp - IP of the onos node you want to send the json to
1492 jsonFile - File path of the json file
1493 Return:
1494 Returns main.TRUE if the command is successfull; Returns
1495 main.FALSE if there was an error
kelvin8ec71442015-01-15 16:57:00 -08001496 """
shahshreyae6c7cf42014-11-26 16:39:01 -08001497 try:
kelvin8ec71442015-01-15 16:57:00 -08001498 self.handle.sendline( "" )
1499 self.handle.expect( "\$" )
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001500 cmd = "onos-topo-cfg "
1501 self.handle.sendline( cmd + str( onosIp ) + " " + jsonFile )
1502 handle = self.handle.before
1503 print handle
1504 if "Error" in handle:
1505 main.log.error( self.name + ": " + self.handle.before )
1506 return main.FALSE
1507 else:
1508 self.handle.expect( "\$" )
1509 return main.TRUE
1510
Jon Hallfebb1c72015-03-05 13:30:09 -08001511 except pexpect.EOF:
1512 main.log.error( self.name + ": EOF exception found" )
1513 main.log.error( self.name + ": " + self.handle.before )
1514 main.cleanup()
1515 main.exit()
1516 except Exception:
1517 main.log.exception( self.name + ": Uncaught exception!" )
1518 main.cleanup()
1519 main.exit()
kelvin8ec71442015-01-15 16:57:00 -08001520
jenkins1e99e7b2015-04-02 18:15:39 -07001521 def tsharkGrep( self, grep, directory, interface='eth0', grepOptions='' ):
kelvin8ec71442015-01-15 16:57:00 -08001522 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001523 Required:
kelvin8ec71442015-01-15 16:57:00 -08001524 * grep string
andrewonlabba44bcf2014-10-16 16:54:41 -04001525 * directory to store results
1526 Optional:
1527 * interface - default: eth0
Jon Hall4ba53f02015-07-29 13:07:41 -07001528 * grepOptions - options for grep
andrewonlabba44bcf2014-10-16 16:54:41 -04001529 Description:
1530 Uses tshark command to grep specific group of packets
1531 and stores the results to specified directory.
kelvin8ec71442015-01-15 16:57:00 -08001532 The timestamp is hardcoded to be in epoch
1533 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001534 try:
1535 self.handle.sendline( "" )
1536 self.handle.expect( "\$" )
1537 self.handle.sendline( "" )
jenkins1e99e7b2015-04-02 18:15:39 -07001538 if grepOptions:
1539 grepStr = "grep "+str(grepOptions)
1540 else:
1541 grepStr = "grep"
Jon Hall4ba53f02015-07-29 13:07:41 -07001542
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001543 cmd = (
1544 "sudo tshark -i " +
Jon Hallfebb1c72015-03-05 13:30:09 -08001545 str( interface ) +
jenkins1e99e7b2015-04-02 18:15:39 -07001546 " -t e | " +
1547 grepStr + " --line-buffered \"" +
Jon Hallfebb1c72015-03-05 13:30:09 -08001548 str(grep) +
1549 "\" >" +
1550 directory +
1551 " &" )
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001552 self.handle.sendline(cmd)
1553 main.log.info(cmd)
Jon Hallfebb1c72015-03-05 13:30:09 -08001554 self.handle.expect( "Capturing on" )
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001555 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001556 self.handle.expect( "\$" )
1557 except pexpect.EOF:
1558 main.log.error( self.name + ": EOF exception found" )
1559 main.log.error( self.name + ": " + self.handle.before )
1560 main.cleanup()
1561 main.exit()
1562 except Exception:
1563 main.log.exception( self.name + ": Uncaught exception!" )
1564 main.cleanup()
1565 main.exit()
1566
kelvin-onlabd3b64892015-01-20 13:26:24 -08001567 def tsharkStop( self ):
kelvin8ec71442015-01-15 16:57:00 -08001568 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001569 Removes wireshark files from /tmp and kills all tshark processes
kelvin8ec71442015-01-15 16:57:00 -08001570 """
1571 # Remove all pcap from previous captures
Jon Hallfebb1c72015-03-05 13:30:09 -08001572 try:
1573 self.execute( cmd="sudo rm /tmp/wireshark*" )
1574 self.handle.sendline( "" )
Jon Hallefbd9792015-03-05 16:11:36 -08001575 self.handle.sendline( "sudo kill -9 `ps -ef | grep \"tshark -i\"" +
1576 " | grep -v grep | awk '{print $2}'`" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001577 self.handle.sendline( "" )
1578 main.log.info( "Tshark stopped" )
1579 except pexpect.EOF:
1580 main.log.error( self.name + ": EOF exception found" )
1581 main.log.error( self.name + ": " + self.handle.before )
1582 main.cleanup()
1583 main.exit()
1584 except Exception:
1585 main.log.exception( self.name + ": Uncaught exception!" )
1586 main.cleanup()
1587 main.exit()
1588
kelvin8ec71442015-01-15 16:57:00 -08001589 def ptpd( self, args ):
1590 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001591 Initiate ptp with user-specified args.
1592 Required:
1593 * args: specify string of args after command
1594 'sudo ptpd'
kelvin8ec71442015-01-15 16:57:00 -08001595 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001596 try:
kelvin8ec71442015-01-15 16:57:00 -08001597 self.handle.sendline( "sudo ptpd " + str( args ) )
1598 i = self.handle.expect( [
andrewonlab0c38a4a2014-10-28 18:35:35 -04001599 "Multiple",
1600 "Error",
kelvin8ec71442015-01-15 16:57:00 -08001601 "\$" ] )
1602 self.handle.expect( "\$" )
andrewonlabba44bcf2014-10-16 16:54:41 -04001603
andrewonlab0c38a4a2014-10-28 18:35:35 -04001604 if i == 0:
1605 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001606 main.log.info( "ptpd returned an error: " +
1607 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001608 return handle
1609 elif i == 1:
1610 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001611 main.log.error( "ptpd returned an error: " +
1612 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001613 return handle
1614 else:
1615 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -08001616
andrewonlab0c38a4a2014-10-28 18:35:35 -04001617 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001618 main.log.error( self.name + ": EOF exception found" )
1619 main.log.error( self.name + ": " + self.handle.before )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001620 main.cleanup()
1621 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001622 except Exception:
1623 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001624 main.cleanup()
1625 main.exit()
andrewonlabba44bcf2014-10-16 16:54:41 -04001626
Pier50f0bc62016-09-07 17:53:40 -07001627 def dumpONOSCmd(self, ONOSIp, CMD, destDir, filename, options=""):
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001628 """
Pier50f0bc62016-09-07 17:53:40 -07001629 Dump Cmd to a desired directory.
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001630 For debugging purposes, you may want to use
Pier50f0bc62016-09-07 17:53:40 -07001631 this function to capture Cmd at a given point in time.
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001632 Localtime will be attached to the filename
1633
1634 Required:
1635 * ONOSIp: the IP of the target ONOS instance
Pier50f0bc62016-09-07 17:53:40 -07001636 * CMD: the command to dump;
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001637 * destDir: specify directory to copy to.
1638 ex ) /tmp/
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001639 * fileName: Name of the file
Pier50f0bc62016-09-07 17:53:40 -07001640 * options: Options for ONOS command
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001641 """
1642
1643 localtime = time.strftime( '%x %X' )
1644 localtime = localtime.replace( "/", "" )
1645 localtime = localtime.replace( " ", "_" )
1646 localtime = localtime.replace( ":", "" )
1647 if destDir[ -1: ] != "/":
1648 destDir += "/"
Pier50f0bc62016-09-07 17:53:40 -07001649 cmd=CMD + " " + options + " > " + str( destDir ) + str( filename ) + localtime
1650 return self.onosCli(ONOSIp, cmd)
Flavio Castrob7718952016-05-18 08:53:41 -07001651
kelvin-onlabd3b64892015-01-20 13:26:24 -08001652 def cpLogsToDir( self, logToCopy,
Jon Hallefbd9792015-03-05 16:11:36 -08001653 destDir, copyFileName="" ):
kelvin8ec71442015-01-15 16:57:00 -08001654 """
1655 Copies logs to a desired directory.
andrewonlab5d7a8f32014-11-10 13:07:56 -05001656 Current implementation of ONOS deletes its karaf
1657 logs on every iteration. For debugging purposes,
kelvin8ec71442015-01-15 16:57:00 -08001658 you may want to use this function to capture
1659 certain karaf logs. ( or any other logs if needed )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001660 Localtime will be attached to the filename
1661
1662 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001663 * logToCopy: specify directory and log name to
andrewonlab5d7a8f32014-11-10 13:07:56 -05001664 copy.
kelvin8ec71442015-01-15 16:57:00 -08001665 ex ) /opt/onos/log/karaf.log.1
kelvin-onlabd3b64892015-01-20 13:26:24 -08001666 For copying multiple files, leave copyFileName
1667 empty and only specify destDir -
kelvin8ec71442015-01-15 16:57:00 -08001668 ex ) /opt/onos/log/karaf*
kelvin-onlabd3b64892015-01-20 13:26:24 -08001669 * destDir: specify directory to copy to.
kelvin8ec71442015-01-15 16:57:00 -08001670 ex ) /tmp/
1671 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001672 * copyFileName: If you want to rename the log
1673 file, specify copyFileName. This will not work
andrewonlab5d7a8f32014-11-10 13:07:56 -05001674 with multiple file copying
kelvin8ec71442015-01-15 16:57:00 -08001675 """
andrewonlab5d7a8f32014-11-10 13:07:56 -05001676 try:
Flavio Castro09ab59d2016-05-25 17:01:35 -07001677 localtime = time.strftime( '%H %M' )
kelvin8ec71442015-01-15 16:57:00 -08001678 localtime = localtime.replace( "/", "" )
1679 localtime = localtime.replace( " ", "_" )
1680 localtime = localtime.replace( ":", "" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001681 if destDir[ -1: ] != "/":
1682 destDir += "/"
andrewonlab5d7a8f32014-11-10 13:07:56 -05001683
kelvin-onlabd3b64892015-01-20 13:26:24 -08001684 if copyFileName:
Jon Hallfebb1c72015-03-05 13:30:09 -08001685 self.handle.sendline( "cp " + str( logToCopy ) + " " +
1686 str( destDir ) + str( copyFileName ) +
1687 localtime )
kelvin8ec71442015-01-15 16:57:00 -08001688 self.handle.expect( "cp" )
1689 self.handle.expect( "\$" )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001690 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001691 self.handle.sendline( "cp " + str( logToCopy ) +
1692 " " + str( destDir ) )
kelvin8ec71442015-01-15 16:57:00 -08001693 self.handle.expect( "cp" )
1694 self.handle.expect( "\$" )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001695
kelvin8ec71442015-01-15 16:57:00 -08001696 return self.handle.before
1697
1698 except pexpect.EOF:
1699 main.log.error( "Copying files failed" )
1700 main.log.error( self.name + ": EOF exception found" )
1701 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001702 except Exception:
1703 main.log.exception( "Copying files failed" )
1704
Jon Hall16b72c42015-05-20 10:23:36 -07001705 def checkLogs( self, onosIp, restart=False):
kelvin8ec71442015-01-15 16:57:00 -08001706 """
Jon Hall94fd0472014-12-08 11:52:42 -08001707 runs onos-check-logs on the given onos node
Jon Hall80daded2015-05-27 16:07:00 -07001708 If restart is True, use the old version of onos-check-logs which
1709 does not print the full stacktrace, but shows the entire log file,
1710 including across restarts
Jon Hall94fd0472014-12-08 11:52:42 -08001711 returns the response
kelvin8ec71442015-01-15 16:57:00 -08001712 """
Jon Hall94fd0472014-12-08 11:52:42 -08001713 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001714 cmd = "onos-check-logs " + str( onosIp )
Jon Hall16b72c42015-05-20 10:23:36 -07001715 if restart:
1716 cmd += " old"
kelvin8ec71442015-01-15 16:57:00 -08001717 self.handle.sendline( cmd )
1718 self.handle.expect( cmd )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001719 self.handle.expect( "\$ " )
Jon Hall94fd0472014-12-08 11:52:42 -08001720 response = self.handle.before
1721 return response
1722 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001723 main.log.error( "Lost ssh connection" )
1724 main.log.error( self.name + ": EOF exception found" )
1725 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001726 except Exception:
1727 main.log.exception( self.name + ": Uncaught exception!" )
1728 main.cleanup()
1729 main.exit()
Jon Hall94fd0472014-12-08 11:52:42 -08001730
kelvin-onlabd3b64892015-01-20 13:26:24 -08001731 def onosStatus( self, node="" ):
kelvin8ec71442015-01-15 16:57:00 -08001732 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001733 Calls onos command: 'onos-service [<node-ip>] status'
kelvin8ec71442015-01-15 16:57:00 -08001734 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001735 try:
kelvin8ec71442015-01-15 16:57:00 -08001736 self.handle.sendline( "" )
1737 self.handle.expect( "\$" )
1738 self.handle.sendline( "onos-service " + str( node ) +
1739 " status" )
1740 i = self.handle.expect( [
You Wangef1e6572016-03-08 12:53:18 -08001741 "start/running",
You Wang7bd83062016-03-01 11:50:00 -08001742 "Running ...",
You Wangef1e6572016-03-08 12:53:18 -08001743 "stop/waiting",
You Wang7bd83062016-03-01 11:50:00 -08001744 "Not Running ...",
kelvin8ec71442015-01-15 16:57:00 -08001745 pexpect.TIMEOUT ], timeout=120 )
YPZhangfebf7302016-05-24 16:45:56 -07001746 self.handle.sendline( "" )
1747 self.handle.expect( "\$" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001748
You Wangef1e6572016-03-08 12:53:18 -08001749 if i == 0 or i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001750 main.log.info( "ONOS is running" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001751 return main.TRUE
You Wangef1e6572016-03-08 12:53:18 -08001752 elif i == 2 or i == 3:
kelvin8ec71442015-01-15 16:57:00 -08001753 main.log.info( "ONOS is stopped" )
kelvin8ec71442015-01-15 16:57:00 -08001754 main.log.error( "ONOS service failed to check the status" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001755 main.cleanup()
1756 main.exit()
1757 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001758 main.log.error( self.name + ": EOF exception found" )
1759 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001760 main.cleanup()
1761 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001762 except Exception:
1763 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001764 main.cleanup()
1765 main.exit()
Jon Hall21270ac2015-02-16 17:59:55 -08001766
Jon Hall63604932015-02-26 17:09:50 -08001767 def setIpTables( self, ip, port='', action='add', packet_type='',
1768 direction='INPUT', rule='DROP', states=True ):
Jon Hallefbd9792015-03-05 16:11:36 -08001769 """
Jon Hall21270ac2015-02-16 17:59:55 -08001770 Description:
1771 add or remove iptables rule to DROP (default) packets from
1772 specific IP and PORT
1773 Usage:
1774 * specify action ('add' or 'remove')
1775 when removing, pass in the same argument as you would add. It will
1776 delete that specific rule.
1777 * specify the ip to block
1778 * specify the destination port to block (defaults to all ports)
1779 * optional packet type to block (default tcp)
1780 * optional iptables rule (default DROP)
1781 * optional direction to block (default 'INPUT')
Jon Hall63604932015-02-26 17:09:50 -08001782 * States boolean toggles adding all supported tcp states to the
1783 firewall rule
Jon Hall21270ac2015-02-16 17:59:55 -08001784 Returns:
1785 main.TRUE on success or
1786 main.FALSE if given invalid input or
1787 main.ERROR if there is an error in response from iptables
1788 WARNING:
1789 * This function uses root privilege iptables command which may result
1790 in unwanted network errors. USE WITH CAUTION
Jon Hallefbd9792015-03-05 16:11:36 -08001791 """
Jon Hall21270ac2015-02-16 17:59:55 -08001792
1793 # NOTE*********
1794 # The strict checking methods of this driver function is intentional
1795 # to discourage any misuse or error of iptables, which can cause
1796 # severe network errors
1797 # *************
1798
1799 # NOTE: Sleep needed to give some time for rule to be added and
1800 # registered to the instance. If you are calling this function
1801 # multiple times this sleep will prevent any errors.
1802 # DO NOT REMOVE
Jon Hall63604932015-02-26 17:09:50 -08001803 # time.sleep( 5 )
Jon Hall21270ac2015-02-16 17:59:55 -08001804 try:
1805 # input validation
1806 action_type = action.lower()
1807 rule = rule.upper()
1808 direction = direction.upper()
1809 if action_type != 'add' and action_type != 'remove':
1810 main.log.error( "Invalid action type. Use 'add' or "
1811 "'remove' table rule" )
1812 if rule != 'DROP' and rule != 'ACCEPT' and rule != 'LOG':
1813 # NOTE Currently only supports rules DROP, ACCEPT, and LOG
1814 main.log.error( "Invalid rule. Valid rules are 'DROP' or "
1815 "'ACCEPT' or 'LOG' only." )
1816 if direction != 'INPUT' and direction != 'OUTPUT':
1817 # NOTE currently only supports rules INPUT and OUPTUT
1818 main.log.error( "Invalid rule. Valid directions are"
1819 " 'OUTPUT' or 'INPUT'" )
1820 return main.FALSE
1821 return main.FALSE
1822 return main.FALSE
1823 if action_type == 'add':
1824 # -A is the 'append' action of iptables
1825 actionFlag = '-A'
1826 elif action_type == 'remove':
1827 # -D is the 'delete' rule of iptables
1828 actionFlag = '-D'
1829 self.handle.sendline( "" )
1830 self.handle.expect( "\$" )
1831 cmd = "sudo iptables " + actionFlag + " " +\
1832 direction +\
Jon Hall21270ac2015-02-16 17:59:55 -08001833 " -s " + str( ip )
Jon Hall63604932015-02-26 17:09:50 -08001834 # " -p " + str( packet_type ) +\
1835 if packet_type:
1836 cmd += " -p " + str( packet_type )
Jon Hall21270ac2015-02-16 17:59:55 -08001837 if port:
1838 cmd += " --dport " + str( port )
Jon Hall63604932015-02-26 17:09:50 -08001839 if states:
1840 cmd += " -m state --state="
1841 #FIXME- Allow user to configure which states to block
1842 cmd += "INVALID,ESTABLISHED,NEW,RELATED,UNTRACKED"
Jon Hall21270ac2015-02-16 17:59:55 -08001843 cmd += " -j " + str( rule )
1844
1845 self.handle.sendline( cmd )
1846 self.handle.expect( "\$" )
1847 main.log.warn( self.handle.before )
1848
1849 info_string = "On " + str( self.name )
1850 info_string += " " + str( action_type )
1851 info_string += " iptable rule [ "
1852 info_string += " IP: " + str( ip )
1853 info_string += " Port: " + str( port )
1854 info_string += " Rule: " + str( rule )
1855 info_string += " Direction: " + str( direction ) + " ]"
1856 main.log.info( info_string )
1857 return main.TRUE
1858 except pexpect.TIMEOUT:
1859 main.log.exception( self.name + ": Timeout exception in "
1860 "setIpTables function" )
1861 return main.ERROR
1862 except pexpect.EOF:
1863 main.log.error( self.name + ": EOF exception found" )
1864 main.log.error( self.name + ": " + self.handle.before )
1865 main.cleanup()
1866 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001867 except Exception:
1868 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall21270ac2015-02-16 17:59:55 -08001869 main.cleanup()
1870 main.exit()
1871
Jon Hall0468b042015-02-19 19:08:21 -08001872 def detailed_status(self, log_filename):
Jon Hallefbd9792015-03-05 16:11:36 -08001873 """
Jon Hall0468b042015-02-19 19:08:21 -08001874 This method is used by STS to check the status of the controller
1875 Reports RUNNING, STARTING, STOPPED, FROZEN, ERROR (and reason)
Jon Hallefbd9792015-03-05 16:11:36 -08001876 """
Jon Hall0468b042015-02-19 19:08:21 -08001877 import re
1878 try:
1879 self.handle.sendline( "" )
1880 self.handle.expect( "\$" )
1881 self.handle.sendline( "cd " + self.home )
1882 self.handle.expect( "\$" )
1883 self.handle.sendline( "service onos status" )
1884 self.handle.expect( "\$" )
1885 response = self.handle.before
1886 if re.search( "onos start/running", response ):
1887 # onos start/running, process 10457
1888 return 'RUNNING'
1889 # FIXME: Implement this case
1890 # elif re.search( pattern, response ):
1891 # return 'STARTING'
1892 elif re.search( "onos stop/", response ):
1893 # onos stop/waiting
1894 # FIXME handle this differently?: onos stop/pre-stop
1895 return 'STOPPED'
1896 # FIXME: Implement this case
1897 # elif re.search( pattern, response ):
1898 # return 'FROZEN'
1899 else:
1900 main.log.warn( self.name +
Jon Hallefbd9792015-03-05 16:11:36 -08001901 " WARNING: status received unknown response" )
Jon Hall0468b042015-02-19 19:08:21 -08001902 main.log.warn( response )
1903 return 'ERROR', "Unknown response: %s" % response
1904 except pexpect.TIMEOUT:
1905 main.log.exception( self.name + ": Timeout exception in "
1906 "setIpTables function" )
1907 return 'ERROR', "Pexpect Timeout"
1908 except pexpect.EOF:
1909 main.log.error( self.name + ": EOF exception found" )
1910 main.log.error( self.name + ": " + self.handle.before )
1911 main.cleanup()
1912 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001913 except Exception:
1914 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall0468b042015-02-19 19:08:21 -08001915 main.cleanup()
1916 main.exit()
1917
andrew@onlab.us3b087132015-03-11 15:00:08 -07001918 def createLinkGraphFile( self, benchIp, ONOSIpList, deviceCount):
1919 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07001920 Create/formats the LinkGraph.cfg file based on arguments
1921 -only creates a linear topology and connects islands
1922 -evenly distributes devices
andrew@onlab.us3b087132015-03-11 15:00:08 -07001923 -must be called by ONOSbench
1924
Jon Hall4ba53f02015-07-29 13:07:41 -07001925 ONOSIpList - list of all of the node IPs to be used
1926
1927 deviceCount - number of switches to be assigned
andrew@onlab.us3b087132015-03-11 15:00:08 -07001928 '''
Jon Hall6509dbf2016-06-21 17:01:17 -07001929 main.log.info("Creating link graph configuration file." )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001930 linkGraphPath = self.home + "/tools/package/etc/linkGraph.cfg"
Jon Hall4ba53f02015-07-29 13:07:41 -07001931 tempFile = "/tmp/linkGraph.cfg"
andrew@onlab.us3b087132015-03-11 15:00:08 -07001932
1933 linkGraph = open(tempFile, 'w+')
1934 linkGraph.write("# NullLinkProvider topology description (config file).\n")
1935 linkGraph.write("# The NodeId is only added if the destination is another node's device.\n")
1936 linkGraph.write("# Bugs: Comments cannot be appended to a line to be read.\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07001937
andrew@onlab.us3b087132015-03-11 15:00:08 -07001938 clusterCount = len(ONOSIpList)
Jon Hall4ba53f02015-07-29 13:07:41 -07001939
1940 if type(deviceCount) is int or type(deviceCount) is str:
andrew@onlab.us3b087132015-03-11 15:00:08 -07001941 deviceCount = int(deviceCount)
1942 switchList = [0]*(clusterCount+1)
1943 baselineSwitchCount = deviceCount/clusterCount
Jon Hall4ba53f02015-07-29 13:07:41 -07001944
andrew@onlab.us3b087132015-03-11 15:00:08 -07001945 for node in range(1, clusterCount + 1):
1946 switchList[node] = baselineSwitchCount
1947
1948 for node in range(1, (deviceCount%clusterCount)+1):
1949 switchList[node] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001950
andrew@onlab.us3b087132015-03-11 15:00:08 -07001951 if type(deviceCount) is list:
1952 main.log.info("Using provided device distribution")
1953 switchList = [0]
1954 for i in deviceCount:
1955 switchList.append(int(i))
1956
1957 tempList = ['0']
1958 tempList.extend(ONOSIpList)
1959 ONOSIpList = tempList
1960
1961 myPort = 6
1962 lastSwitch = 0
1963 for node in range(1, clusterCount+1):
1964 if switchList[node] == 0:
1965 continue
1966
1967 linkGraph.write("graph " + ONOSIpList[node] + " {\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07001968
andrew@onlab.us3b087132015-03-11 15:00:08 -07001969 if node > 1:
1970 #connect to last device on previous node
Jon Hall4ba53f02015-07-29 13:07:41 -07001971 line = ("\t0:5 -> " + str(lastSwitch) + ":6:" + lastIp + "\n") #ONOSIpList[node-1]
1972 linkGraph.write(line)
1973
1974 lastSwitch = 0
1975 for switch in range (0, switchList[node]-1):
andrew@onlab.us3b087132015-03-11 15:00:08 -07001976 line = ""
1977 line = ("\t" + str(switch) + ":" + str(myPort))
1978 line += " -- "
1979 line += (str(switch+1) + ":" + str(myPort-1) + "\n")
1980 linkGraph.write(line)
Jon Hall4ba53f02015-07-29 13:07:41 -07001981 lastSwitch = switch+1
andrew@onlab.us3b087132015-03-11 15:00:08 -07001982 lastIp = ONOSIpList[node]
Jon Hall4ba53f02015-07-29 13:07:41 -07001983
andrew@onlab.us3b087132015-03-11 15:00:08 -07001984 #lastSwitch += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001985 if node < (clusterCount):
andrew@onlab.us3b087132015-03-11 15:00:08 -07001986 #connect to first device on the next node
Jon Hall4ba53f02015-07-29 13:07:41 -07001987 line = ("\t" + str(lastSwitch) + ":6 -> 0:5:" + ONOSIpList[node+1] + "\n")
andrew@onlab.us3b087132015-03-11 15:00:08 -07001988 linkGraph.write(line)
Jon Hall4ba53f02015-07-29 13:07:41 -07001989
andrew@onlab.us3b087132015-03-11 15:00:08 -07001990 linkGraph.write("}\n")
1991 linkGraph.close()
1992
1993 #SCP
Jon Hall4ba53f02015-07-29 13:07:41 -07001994 os.system( "scp " + tempFile + " " + self.user_name + "@" + benchIp + ":" + linkGraphPath)
andrew@onlab.us3b087132015-03-11 15:00:08 -07001995 main.log.info("linkGraph.cfg creation complete")
1996
cameron@onlab.us75900962015-03-30 13:22:49 -07001997 def configNullDev( self, ONOSIpList, deviceCount, numPorts=10):
Jon Hall4ba53f02015-07-29 13:07:41 -07001998
andrew@onlab.us3b087132015-03-11 15:00:08 -07001999 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07002000 ONOSIpList = list of Ip addresses of nodes switches will be devided amongst
2001 deviceCount = number of switches to distribute, or list of values to use as custom distribution
cameron@onlab.us75900962015-03-30 13:22:49 -07002002 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 -07002003 '''
2004
Jon Hall6509dbf2016-06-21 17:01:17 -07002005 main.log.info("Configuring Null Device Provider" )
andrew@onlab.us3b087132015-03-11 15:00:08 -07002006 clusterCount = len(ONOSIpList)
2007
Jon Hall4ba53f02015-07-29 13:07:41 -07002008 try:
2009
cameron@onlab.us75900962015-03-30 13:22:49 -07002010 if type(deviceCount) is int or type(deviceCount) is str:
Jon Hall6509dbf2016-06-21 17:01:17 -07002011 main.log.info("Creating device distribution")
cameron@onlab.us75900962015-03-30 13:22:49 -07002012 deviceCount = int(deviceCount)
2013 switchList = [0]*(clusterCount+1)
2014 baselineSwitchCount = deviceCount/clusterCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07002015
cameron@onlab.us75900962015-03-30 13:22:49 -07002016 for node in range(1, clusterCount + 1):
2017 switchList[node] = baselineSwitchCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07002018
cameron@onlab.us75900962015-03-30 13:22:49 -07002019 for node in range(1, (deviceCount%clusterCount)+1):
2020 switchList[node] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07002021
2022 if type(deviceCount) is list:
2023 main.log.info("Using provided device distribution")
2024
2025 if len(deviceCount) == clusterCount:
cameron@onlab.us75900962015-03-30 13:22:49 -07002026 switchList = ['0']
2027 switchList.extend(deviceCount)
Jon Hall4ba53f02015-07-29 13:07:41 -07002028
2029 if len(deviceCount) == (clusterCount + 1):
2030 if deviceCount[0] == '0' or deviceCount[0] == 0:
cameron@onlab.us75900962015-03-30 13:22:49 -07002031 switchList = deviceCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07002032
cameron@onlab.us75900962015-03-30 13:22:49 -07002033 assert len(switchList) == (clusterCount + 1)
Jon Hall4ba53f02015-07-29 13:07:41 -07002034
cameron@onlab.us75900962015-03-30 13:22:49 -07002035 except AssertionError:
Jon Hall4ba53f02015-07-29 13:07:41 -07002036 main.log.error( "Bad device/Ip list match")
cameron@onlab.us75900962015-03-30 13:22:49 -07002037 except TypeError:
2038 main.log.exception( self.name + ": Object not as expected" )
2039 return None
Jon Hall77ba41c2015-04-06 10:25:40 -07002040 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002041 main.log.exception( self.name + ": Uncaught exception!" )
2042 main.cleanup()
2043 main.exit()
2044
andrew@onlab.us3b087132015-03-11 15:00:08 -07002045
2046 ONOSIp = [0]
2047 ONOSIp.extend(ONOSIpList)
Jon Hall4ba53f02015-07-29 13:07:41 -07002048
andrew@onlab.us3b087132015-03-11 15:00:08 -07002049 devicesString = "devConfigs = "
2050 for node in range(1, len(ONOSIp)):
2051 devicesString += (ONOSIp[node] + ":" + str(switchList[node] ))
2052 if node < clusterCount:
2053 devicesString += (",")
Jon Hall4ba53f02015-07-29 13:07:41 -07002054
2055 try:
cameron@onlab.us75900962015-03-30 13:22:49 -07002056 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider devConfigs " + devicesString )
2057 self.handle.expect(":~")
2058 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider numPorts " + str(numPorts) )
2059 self.handle.expect(":~")
andrew@onlab.us3b087132015-03-11 15:00:08 -07002060
cameron@onlab.us75900962015-03-30 13:22:49 -07002061 for i in range(10):
2062 self.handle.sendline("onos $OC1 cfg get org.onosproject.provider.nil.device.impl.NullDeviceProvider")
2063 self.handle.expect(":~")
2064 verification = self.handle.before
2065 if (" value=" + str(numPorts)) in verification and (" value=" + devicesString) in verification:
2066 break
2067 else:
2068 time.sleep(1)
andrew@onlab.us3b087132015-03-11 15:00:08 -07002069
cameron@onlab.us2cc8bf12015-04-02 14:12:30 -07002070 assert ("value=" + str(numPorts)) in verification and (" value=" + devicesString) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002071
cameron@onlab.us75900962015-03-30 13:22:49 -07002072 except AssertionError:
2073 main.log.error("Incorrect Config settings: " + verification)
Jon Hall77ba41c2015-04-06 10:25:40 -07002074 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002075 main.log.exception( self.name + ": Uncaught exception!" )
2076 main.cleanup()
2077 main.exit()
2078
Jon Hall4ba53f02015-07-29 13:07:41 -07002079 def configNullLink( self,fileName="/opt/onos/apache-karaf-3.0.3/etc/linkGraph.cfg", eventRate=0):
andrew@onlab.us3b087132015-03-11 15:00:08 -07002080 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07002081 fileName default is currently the same as the default on ONOS, specify alternate file if
cameron@onlab.us75900962015-03-30 13:22:49 -07002082 you want to use a different topology file than linkGraph.cfg
andrew@onlab.us3b087132015-03-11 15:00:08 -07002083 '''
2084
Jon Hall4ba53f02015-07-29 13:07:41 -07002085
2086 try:
2087 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider eventRate " + str(eventRate))
2088 self.handle.expect(":~")
cameron@onlab.us75900962015-03-30 13:22:49 -07002089 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider cfgFile " + fileName )
2090 self.handle.expect(":~")
Jon Hall4ba53f02015-07-29 13:07:41 -07002091
2092 for i in range(10):
2093 self.handle.sendline("onos $OC1 cfg get org.onosproject.provider.nil.link.impl.NullLinkProvider")
cameron@onlab.us75900962015-03-30 13:22:49 -07002094 self.handle.expect(":~")
2095 verification = self.handle.before
Jon Hall4ba53f02015-07-29 13:07:41 -07002096 if (" value=" + str(eventRate)) in verification and (" value=" + fileName) in verification:
cameron@onlab.us75900962015-03-30 13:22:49 -07002097 break
Jon Hall4ba53f02015-07-29 13:07:41 -07002098 else:
cameron@onlab.us75900962015-03-30 13:22:49 -07002099 time.sleep(1)
Jon Hall4ba53f02015-07-29 13:07:41 -07002100
cameron@onlab.us75900962015-03-30 13:22:49 -07002101 assert ("value=" + str(eventRate)) in verification and (" value=" + fileName) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002102
cameron@onlab.us75900962015-03-30 13:22:49 -07002103 except pexpect.EOF:
2104 main.log.error( self.name + ": EOF exception found" )
2105 main.log.error( self.name + ": " + self.handle.before )
2106 main.cleanup()
2107 main.exit()
cameron@onlab.us75900962015-03-30 13:22:49 -07002108 except AssertionError:
2109 main.log.info("Settings did not post to ONOS")
Jon Hall4ba53f02015-07-29 13:07:41 -07002110 main.log.error(varification)
Jon Hall77ba41c2015-04-06 10:25:40 -07002111 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002112 main.log.exception( self.name + ": Uncaught exception!" )
2113 main.log.error(varification)
2114 main.cleanup()
2115 main.exit()
andrew@onlab.us3b087132015-03-11 15:00:08 -07002116
kelvin-onlaba4074292015-07-09 15:19:49 -07002117 def getOnosIps( self ):
2118 """
2119 Get all onos IPs stored in
2120 """
cameron@onlab.us59d29d92015-05-11 14:31:54 -07002121
kelvin-onlaba4074292015-07-09 15:19:49 -07002122 return sorted( self.onosIps.values() )
cameron@onlab.us59d29d92015-05-11 14:31:54 -07002123
kelvin-onlaba4074292015-07-09 15:19:49 -07002124 def logReport( self, nodeIp, searchTerms, outputMode="s" ):
Jon Hallb4242222016-01-25 17:07:04 -08002125 """
2126 Searches the latest ONOS log file for the given search terms and
2127 prints the total occurances of each term. Returns to combined total of
2128 all occurances.
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002129
Jon Hallb4242222016-01-25 17:07:04 -08002130 Arguments:
2131 * nodeIp - The ip of the ONOS node where the log is located
2132 * searchTerms - A string to grep for or a list of strings to grep
2133 for in the ONOS log. Will print out the number of
2134 occurances for each term.
2135 Optional Arguments:
2136 * outputMode - 's' or 'd'. If 'd' will print the last 5 lines
2137 containing each search term as well as the total
2138 number of occurances of each term. Defaults to 's',
2139 which prints the simple output of just the number
2140 of occurances for each term.
2141 """
2142 try:
2143 main.log.info( " Log Report for {} ".format( nodeIp ).center( 70, '=' ) )
2144 if type( searchTerms ) is str:
2145 searchTerms = [searchTerms]
2146 numTerms = len( searchTerms )
2147 outputMode = outputMode.lower()
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002148
Jon Hallb4242222016-01-25 17:07:04 -08002149 totalHits = 0
2150 logLines = []
2151 for termIndex in range( numTerms ):
2152 term = searchTerms[termIndex]
2153 logLines.append( [term] )
2154 cmd = "onos-ssh " + nodeIp + " cat /opt/onos/log/karaf.log | grep " + term
2155 self.handle.sendline( cmd )
2156 self.handle.expect( ":~" )
2157 before = self.handle.before.splitlines()
2158 count = 0
2159 for line in before:
2160 if term in line and "grep" not in line:
2161 count += 1
2162 if before.index( line ) > ( len( before ) - 7 ):
2163 logLines[termIndex].append( line )
2164 main.log.info( "{}: {}".format( term, count ) )
2165 totalHits += count
2166 if termIndex == numTerms - 1:
2167 print "\n"
2168 if outputMode != "s":
2169 outputString = ""
2170 for term in logLines:
2171 outputString = term[0] + ": \n"
2172 for line in range( 1, len( term ) ):
2173 outputString += ( "\t" + term[line] + "\n" )
2174 if outputString != ( term[0] + ": \n" ):
2175 main.log.info( outputString )
2176 main.log.info( "=" * 70 )
2177 return totalHits
2178 except pexpect.EOF:
2179 main.log.error( self.name + ": EOF exception found" )
2180 main.log.error( self.name + ": " + self.handle.before )
2181 main.cleanup()
2182 main.exit()
2183 except pexpect.TIMEOUT:
2184 main.log.error( self.name + ": TIMEOUT exception found" )
2185 main.log.error( self.name + ": " + self.handle.before )
2186 main.cleanup()
2187 main.exit()
2188 except Exception:
2189 main.log.exception( self.name + ": Uncaught exception!" )
2190 main.cleanup()
2191 main.exit()
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002192
2193 def copyMininetFile( self, fileName, localPath, userName, ip,
2194 mnPath='~/mininet/custom/', timeout = 60 ):
2195 """
2196 Description:
2197 Copy mininet topology file from dependency folder in the test folder
2198 and paste it to the mininet machine's mininet/custom folder
2199 Required:
2200 fileName - Name of the topology file to copy
2201 localPath - File path of the mininet topology file
2202 userName - User name of the mininet machine to send the file to
2203 ip - Ip address of the mininet machine
2204 Optional:
2205 mnPath - of the mininet directory to send the file to
2206 Return:
2207 Return main.TRUE if successfully copied the file otherwise
2208 return main.FALSE
2209 """
2210
2211 try:
2212 cmd = "scp " + localPath + fileName + " " + userName + "@" + \
2213 str( ip ) + ":" + mnPath + fileName
2214
2215 self.handle.sendline( "" )
2216 self.handle.expect( "\$" )
2217
2218 main.log.info( self.name + ": Execute: " + cmd )
2219
2220 self.handle.sendline( cmd )
2221
2222 i = self.handle.expect( [ 'No such file',
2223 "100%",
2224 pexpect.TIMEOUT ] )
2225
2226 if i == 0:
2227 main.log.error( self.name + ": File " + fileName +
2228 " does not exist!" )
2229 return main.FALSE
2230
2231 if i == 1:
2232 main.log.info( self.name + ": File " + fileName +
2233 " has been copied!" )
2234 self.handle.sendline( "" )
2235 self.handle.expect( "\$" )
2236 return main.TRUE
2237
2238 except pexpect.EOF:
2239 main.log.error( self.name + ": EOF exception found" )
2240 main.log.error( self.name + ": " + self.handle.before )
2241 main.cleanup()
2242 main.exit()
2243 except pexpect.TIMEOUT:
2244 main.log.error( self.name + ": TIMEOUT exception found" )
2245 main.log.error( self.name + ": " + self.handle.before )
2246 main.cleanup()
2247 main.exit()
cameron@onlab.us78b89652015-07-08 15:21:03 -07002248
2249 def jvmSet(self, memory=8):
Jon Hall4ba53f02015-07-29 13:07:41 -07002250
cameron@onlab.us78b89652015-07-08 15:21:03 -07002251 import os
2252
2253 homeDir = os.path.expanduser('~')
2254 filename = "/onos/tools/package/bin/onos-service"
2255
2256 serviceConfig = open(homeDir + filename, 'w+')
2257 serviceConfig.write("#!/bin/bash\n ")
2258 serviceConfig.write("#------------------------------------- \n ")
2259 serviceConfig.write("# Starts ONOS Apache Karaf container\n ")
2260 serviceConfig.write("#------------------------------------- \n ")
2261 serviceConfig.write("#export JAVA_HOME=${JAVA_HOME:-/usr/lib/jvm/java-7-openjdk-amd64/}\n ")
2262 serviceConfig.write("""export JAVA_OPTS="${JAVA_OPTS:--Xms""" + str(memory) + "G -Xmx" + str(memory) + """G}" \n """)
2263 serviceConfig.write("[ -d $ONOS_HOME ] && cd $ONOS_HOME || ONOS_HOME=$(dirname $0)/..\n")
2264 serviceConfig.write("""${ONOS_HOME}/apache-karaf-$KARAF_VERSION/bin/karaf "$@" \n """)
2265 serviceConfig.close()
2266
Jon Hall6c44c0b2016-04-20 15:21:00 -07002267 def createDBFile( self, testData ):
Jon Hall4ba53f02015-07-29 13:07:41 -07002268
cameron@onlab.us78b89652015-07-08 15:21:03 -07002269 filename = main.TEST + "DB"
2270 DBString = ""
Jon Hall4ba53f02015-07-29 13:07:41 -07002271
cameron@onlab.us78b89652015-07-08 15:21:03 -07002272 for item in testData:
Jon Hall6c44c0b2016-04-20 15:21:00 -07002273 if type( item ) is string:
cameron@onlab.us78b89652015-07-08 15:21:03 -07002274 item = "'" + item + "'"
Jon Hall6c44c0b2016-04-20 15:21:00 -07002275 if testData.index( item ) < len( testData - 1 ):
cameron@onlab.us78b89652015-07-08 15:21:03 -07002276 item += ","
Jon Hall6c44c0b2016-04-20 15:21:00 -07002277 DBString += str( item )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002278
Jon Hall6c44c0b2016-04-20 15:21:00 -07002279 DBFile = open( filename, "a" )
2280 DBFile.write( DBString )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002281 DBFile.close()
2282
Jon Hall6c44c0b2016-04-20 15:21:00 -07002283 def verifySummary( self, ONOSIp, *deviceCount ):
cameron@onlab.us78b89652015-07-08 15:21:03 -07002284
Jon Hall6c44c0b2016-04-20 15:21:00 -07002285 self.handle.sendline( "onos " + ONOSIp + " summary" )
2286 self.handle.expect( ":~" )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002287
2288 summaryStr = self.handle.before
2289 print "\nSummary\n==============\n" + summaryStr + "\n\n"
2290
2291 #passed = "SCC(s)=1" in summaryStr
2292 #if deviceCount:
2293 # passed = "devices=" + str(deviceCount) + "," not in summaryStr
2294
GlennRC772363b2015-08-25 13:05:57 -07002295 passed = False
cameron@onlab.us78b89652015-07-08 15:21:03 -07002296 if "SCC(s)=1," in summaryStr:
2297 passed = True
Jon Hall6c44c0b2016-04-20 15:21:00 -07002298 print "Summary is verifed"
Jon Hall4ba53f02015-07-29 13:07:41 -07002299 else:
Jon Hall6c44c0b2016-04-20 15:21:00 -07002300 print "Summary failed"
cameron@onlab.us78b89652015-07-08 15:21:03 -07002301
2302 if deviceCount:
2303 print" ============================="
Jon Hall6c44c0b2016-04-20 15:21:00 -07002304 checkStr = "devices=" + str( deviceCount[0] ) + ","
cameron@onlab.us78b89652015-07-08 15:21:03 -07002305 print "Checkstr: " + checkStr
2306 if checkStr not in summaryStr:
2307 passed = False
Jon Hall6c44c0b2016-04-20 15:21:00 -07002308 print "Device count failed"
Jon Hall4ba53f02015-07-29 13:07:41 -07002309 else:
2310 print "device count verified"
cameron@onlab.us78b89652015-07-08 15:21:03 -07002311
2312 return passed
Jon Hall6c44c0b2016-04-20 15:21:00 -07002313
Jon Hall8f6d4622016-05-23 15:27:18 -07002314 def getIpAddr( self, iface=None ):
Jon Hall6c44c0b2016-04-20 15:21:00 -07002315 """
2316 Update self.ip_address with numerical ip address. If multiple IP's are
2317 located on the device, will attempt to use self.nicAddr to choose the
2318 right one. Defaults to 127.0.0.1 if no other address is found or cannot
2319 determine the correct address.
2320
2321 ONLY WORKS WITH IPV4 ADDRESSES
2322 """
2323 try:
Jon Hall8f6d4622016-05-23 15:27:18 -07002324 LOCALHOST = "127.0.0.1"
Jon Hall6c44c0b2016-04-20 15:21:00 -07002325 ipPat = "\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"
2326 pattern = re.compile( ipPat )
2327 match = re.search( pattern, self.ip_address )
2328 if self.nicAddr:
2329 nicPat = self.nicAddr.replace( ".", "\." ).replace( "\*", r"\d{1,3}" )
2330 nicPat = re.compile( nicPat )
2331 else:
2332 nicPat = None
2333 # IF self.ip_address is an ip address and matches
2334 # self.nicAddr: return self.ip_address
2335 if match:
2336 curIp = match.group(0)
2337 if nicPat:
2338 nicMatch = re.search( nicPat, curIp )
2339 if nicMatch:
2340 return self.ip_address
Jon Hall8f6d4622016-05-23 15:27:18 -07002341 # ELSE: IF iface, return ip of interface
2342 cmd = "ifconfig"
2343 ifPat = re.compile( "inet addr:({})".format( ipPat ) )
2344 if iface:
2345 cmd += " " + str( iface )
2346 raw = subprocess.check_output( cmd.split() )
Jon Hall6c44c0b2016-04-20 15:21:00 -07002347 ifPat = re.compile( "inet addr:({})".format( ipPat ) )
2348 ips = re.findall( ifPat, raw )
Jon Hall8f6d4622016-05-23 15:27:18 -07002349 if iface:
2350 if ips:
2351 ip = ips[0]
2352 self.ip_address = ip
2353 return ip
2354 else:
2355 main.log.error( "Error finding ip, ifconfig output:".format( raw ) )
2356 # ELSE: attempt to get address matching nicPat.
Jon Hall6c44c0b2016-04-20 15:21:00 -07002357 if nicPat:
2358 for ip in ips:
2359 curMatch = re.search( nicPat, ip )
2360 if curMatch:
2361 self.ip_address = ip
2362 return ip
Jon Hall8f6d4622016-05-23 15:27:18 -07002363 else: # If only one non-localhost ip, return that
2364 tmpList = [ ip for ip in ips if ip is not LOCALHOST ]
Jon Hall6c44c0b2016-04-20 15:21:00 -07002365 if len(tmpList) == 1:
2366 curIp = tmpList[0]
2367 self.ip_address = curIp
2368 return curIp
Jon Hall8f6d4622016-05-23 15:27:18 -07002369 # Either no non-localhost IPs, or more than 1
Jon Hallebccd352016-05-20 15:17:17 -07002370 main.log.warn( "getIpAddr failed to find a public IP address" )
Jon Hall8f6d4622016-05-23 15:27:18 -07002371 return LOCALHOST
Jon Halle1790952016-05-23 15:51:46 -07002372 except subprocess.CalledProcessError:
Jon Hall8f6d4622016-05-23 15:27:18 -07002373 main.log.exception( "Error executing ifconfig" )
2374 except IndexError:
2375 main.log.exception( "Error getting IP Address" )
Jon Hall6c44c0b2016-04-20 15:21:00 -07002376 except Exception:
2377 main.log.exception( "Uncaught exception" )
suibin zhang116647a2016-05-06 16:30:09 -07002378
2379 def startBasicONOS(self, nodeList, opSleep = 60, onosStartupSleep = 60):
2380
2381 '''
2382 Start onos cluster with defined nodes, but only with drivers app
2383
2384 '''
2385 import time
2386
2387 self.createCellFile( self.ip_address,
2388 "temp",
2389 self.ip_address,
2390 "drivers",
2391 nodeList )
2392
2393 main.log.info( self.name + ": Apply cell to environment" )
2394 cellResult = self.setCell( "temp" )
2395 verifyResult = self.verifyCell()
2396
2397 main.log.info( self.name + ": Creating ONOS package" )
2398 packageResult = self.onosPackage( opTimeout=opSleep )
2399
2400 main.log.info( self.name + ": Installing ONOS package" )
2401 for nd in nodeList:
2402 self.onosInstall( node=nd )
2403
2404 main.log.info( self.name + ": Starting ONOS service" )
2405 time.sleep( onosStartupSleep )
2406
2407 onosStatus = True
2408 for nd in nodeList:
2409 onosStatus = onosStatus & self.isup( node = nd )
2410 #print "onosStatus is: " + str( onosStatus )
2411
2412 return main.TRUE if onosStatus else main.FALSE
2413
Jeremy Songster5665f1b2016-06-20 14:38:22 -07002414 def onosNetCfg( self, controllerIps, path, fileName ):
2415 """
2416 Push a specified json file to ONOS through the onos-netcfg service
2417
2418 Required:
2419 controllerIps - the Ips of the ONOS nodes in the cluster
2420 path - the location of the file to be sent
2421 fileName - name of the json file to be sent
2422
2423 Returns main.TRUE on successfully sending json file, and main.FALSE if
2424 there is an error.
2425 """
2426 try:
2427 cmd = "onos-netcfg {0} {1}{2}.json".format( controllerIps, path, fileName )
2428 main.log.info( "Sending: " + cmd )
2429 main.ONOSbench.handle.sendline( cmd )
2430 handle = self.handle.before
2431 print handle
2432 if "Error" in handle:
2433 main.log.error( self.name + ": " + self.handle.before )
2434 return main.FALSE
2435 else:
2436 self.handle.expect( "\$" )
2437 return main.TRUE
2438 except pexpect.EOF:
2439 main.log.error( self.name + ": EOF exception found" )
2440 main.log.error( self.name + ": " + self.handle.before )
2441 main.cleanup()
2442 main.exit()
2443 except Exception:
2444 main.log.exception( self.name + ": Uncaught exception!" )
2445 main.cleanup()
Jeremy Songsterae01bba2016-07-11 15:39:17 -07002446 main.exit()