blob: 32856b46fb7ce2aff03e5ac1070c6a6cd572663d [file] [log] [blame]
Jon Hall05b2b432014-10-08 19:53:25 -04001#!/usr/bin/env python
andrewonlabe8e56fd2014-10-09 17:12:44 -04002
kelvin8ec71442015-01-15 16:57:00 -08003"""
4This driver interacts with ONOS bench, the OSGi platform
5that configures the ONOS nodes. ( aka ONOS-next )
andrewonlabe8e56fd2014-10-09 17:12:44 -04006
kelvin8ec71442015-01-15 16:57:00 -08007Please follow the coding style demonstrated by existing
andrewonlabe8e56fd2014-10-09 17:12:44 -04008functions and document properly.
9
10If you are a contributor to the driver, please
11list your email here for future contact:
12
13jhall@onlab.us
14andrew@onlab.us
15
16OCT 9 2014
17
kelvin8ec71442015-01-15 16:57:00 -080018"""
Jon Hall05b2b432014-10-08 19:53:25 -040019import time
Jon Hall6801cda2015-07-15 14:13:45 -070020import types
Jon Hall05b2b432014-10-08 19:53:25 -040021import pexpect
kelvin-onlaba4074292015-07-09 15:19:49 -070022import os
andrewonlab7735d852014-10-09 13:02:47 -040023import os.path
pingping-lin6d23d9e2015-02-02 16:54:24 -080024from requests.models import Response
Jon Hall05b2b432014-10-08 19:53:25 -040025from drivers.common.clidriver import CLI
26
Jon Hall05b2b432014-10-08 19:53:25 -040027
kelvin8ec71442015-01-15 16:57:00 -080028class OnosDriver( CLI ):
Jon Hall05b2b432014-10-08 19:53:25 -040029
kelvin8ec71442015-01-15 16:57:00 -080030 def __init__( self ):
31 """
32 Initialize client
33 """
Jon Hallefbd9792015-03-05 16:11:36 -080034 self.name = None
35 self.home = None
36 self.handle = None
kelvin8ec71442015-01-15 16:57:00 -080037 super( CLI, self ).__init__()
38
39 def connect( self, **connectargs ):
40 """
Jon Hall05b2b432014-10-08 19:53:25 -040041 Creates ssh handle for ONOS "bench".
kelvin-onlaba4074292015-07-09 15:19:49 -070042 NOTE:
43 The ip_address would come from the topo file using the host tag, the
44 value can be an environment variable as well as a "localhost" to get
45 the ip address needed to ssh to the "bench"
kelvin8ec71442015-01-15 16:57:00 -080046 """
Jon Hall05b2b432014-10-08 19:53:25 -040047 try:
48 for key in connectargs:
kelvin8ec71442015-01-15 16:57:00 -080049 vars( self )[ key ] = connectargs[ key ]
andrew@onlab.us3b087132015-03-11 15:00:08 -070050 self.home = "~/onos"
Jon Hall05b2b432014-10-08 19:53:25 -040051 for key in self.options:
52 if key == "home":
kelvin8ec71442015-01-15 16:57:00 -080053 self.home = self.options[ 'home' ]
Jon Hall05b2b432014-10-08 19:53:25 -040054 break
Jon Hall274b6642015-02-17 11:57:17 -080055 if self.home is None or self.home == "":
Jon Halle94919c2015-03-23 11:42:57 -070056 self.home = "~/onos"
Jon Hall21270ac2015-02-16 17:59:55 -080057
kelvin8ec71442015-01-15 16:57:00 -080058 self.name = self.options[ 'name' ]
kelvin-onlaba4074292015-07-09 15:19:49 -070059
kelvin-onlabc2b79102015-07-14 11:41:20 -070060 # The 'nodes' tag is optional and it is not required in .topo file
kelvin-onlaba4074292015-07-09 15:19:49 -070061 for key in self.options:
62 if key == "nodes":
kelvin-onlabc2b79102015-07-14 11:41:20 -070063 # Maximum number of ONOS nodes to run, if there is any
kelvin-onlaba4074292015-07-09 15:19:49 -070064 self.maxNodes = int( self.options[ 'nodes' ] )
65 break
66 self.maxNodes = None
67
kelvin-onlabc2b79102015-07-14 11:41:20 -070068 if self.maxNodes == None or self.maxNodes == "":
69 self.maxNodes = 100
kelvin-onlaba4074292015-07-09 15:19:49 -070070
kelvin-onlabc2b79102015-07-14 11:41:20 -070071
72 # Grabs all OC environment variables based on max number of nodes
kelvin-onlaba4074292015-07-09 15:19:49 -070073 self.onosIps = {} # Dictionary of all possible ONOS ip
74
75 try:
76 if self.maxNodes:
kelvin-onlaba4074292015-07-09 15:19:49 -070077 for i in range( self.maxNodes ):
78 envString = "OC" + str( i + 1 )
kelvin-onlabc2b79102015-07-14 11:41:20 -070079 # If there is no more OC# then break the loop
80 if os.getenv( envString ):
81 self.onosIps[ envString ] = os.getenv( envString )
82 else:
83 self.maxNodes = len( self.onosIps )
84 main.log.info( self.name +
85 ": Created cluster data with " +
86 str( self.maxNodes ) +
87 " maximum number" +
88 " of nodes" )
89 break
kelvin-onlaba4074292015-07-09 15:19:49 -070090
91 if not self.onosIps:
92 main.log.info( "Could not read any environment variable"
93 + " please load a cell file with all" +
94 " onos IP" )
Jon Hall5cf14d52015-07-16 12:15:19 -070095 self.maxNodes = None
kelvin-onlaba4074292015-07-09 15:19:49 -070096 else:
97 main.log.info( self.name + ": Found " +
98 str( self.onosIps.values() ) +
99 " ONOS IPs" )
kelvin-onlaba4074292015-07-09 15:19:49 -0700100 except KeyError:
101 main.log.info( "Invalid environment variable" )
102 except Exception as inst:
103 main.log.error( "Uncaught exception: " + str( inst ) )
104
105 try:
106 if os.getenv( str( self.ip_address ) ) != None:
107 self.ip_address = os.getenv( str( self.ip_address ) )
108 else:
109 main.log.info( self.name +
110 ": Trying to connect to " +
111 self.ip_address )
kelvin-onlaba4074292015-07-09 15:19:49 -0700112 except KeyError:
113 main.log.info( "Invalid host name," +
114 " connecting to local host instead" )
115 self.ip_address = 'localhost'
116 except Exception as inst:
117 main.log.error( "Uncaught exception: " + str( inst ) )
118
kelvin8ec71442015-01-15 16:57:00 -0800119 self.handle = super( OnosDriver, self ).connect(
120 user_name=self.user_name,
kelvin-onlab08679eb2015-01-21 16:11:48 -0800121 ip_address=self.ip_address,
kelvin-onlabd3b64892015-01-20 13:26:24 -0800122 port=self.port,
123 pwd=self.pwd,
124 home=self.home )
Jon Hall05b2b432014-10-08 19:53:25 -0400125
Jon Hall05b2b432014-10-08 19:53:25 -0400126 if self.handle:
Jon Hall0fc0d452015-07-14 09:49:58 -0700127 self.handle.sendline( "cd " + self.home )
128 self.handle.expect( "\$" )
Jon Hall05b2b432014-10-08 19:53:25 -0400129 return self.handle
kelvin8ec71442015-01-15 16:57:00 -0800130 else:
Jon Hall0fc0d452015-07-14 09:49:58 -0700131 main.log.info( "Failed to create ONOS handle" )
Jon Hall05b2b432014-10-08 19:53:25 -0400132 return main.FALSE
133 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800134 main.log.error( self.name + ": EOF exception found" )
135 main.log.error( self.name + ": " + self.handle.before )
Jon Hall05b2b432014-10-08 19:53:25 -0400136 main.cleanup()
137 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800138 except Exception:
139 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall05b2b432014-10-08 19:53:25 -0400140 main.cleanup()
141 main.exit()
142
kelvin8ec71442015-01-15 16:57:00 -0800143 def disconnect( self ):
144 """
Jon Hall05b2b432014-10-08 19:53:25 -0400145 Called when Test is complete to disconnect the ONOS handle.
kelvin8ec71442015-01-15 16:57:00 -0800146 """
Jon Halld61331b2015-02-17 16:35:47 -0800147 response = main.TRUE
Jon Hall05b2b432014-10-08 19:53:25 -0400148 try:
Jon Hall61282e32015-03-19 11:34:11 -0700149 if self.handle:
150 self.handle.sendline( "" )
151 self.handle.expect( "\$" )
152 self.handle.sendline( "exit" )
153 self.handle.expect( "closed" )
Jon Hall05b2b432014-10-08 19:53:25 -0400154 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800155 main.log.error( self.name + ": EOF exception found" )
156 main.log.error( self.name + ": " + self.handle.before )
Jon Hall61282e32015-03-19 11:34:11 -0700157 except ValueError:
Jon Hall1a77a1e2015-04-06 10:41:13 -0700158 main.log.exception( "Exception in disconnect of " + self.name )
Jon Hall61282e32015-03-19 11:34:11 -0700159 response = main.TRUE
Jon Hallfebb1c72015-03-05 13:30:09 -0800160 except Exception:
161 main.log.exception( self.name + ": Connection failed to the host" )
Jon Hall05b2b432014-10-08 19:53:25 -0400162 response = main.FALSE
163 return response
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400164
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400165 def getEpochMs( self ):
166 """
167 Returns milliseconds since epoch
Jon Hall4ba53f02015-07-29 13:07:41 -0700168
169 When checking multiple nodes in a for loop,
170 around a hundred milliseconds of difference (ascending) is
171 generally acceptable due to calltime of the function.
172 Few seconds, however, is not and it means clocks
173 are off sync.
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400174 """
175 try:
176 self.handle.sendline( 'date +%s.%N' )
177 self.handle.expect( 'date \+\%s\.\%N' )
178 self.handle.expect( '\$' )
179 epochMs = self.handle.before
180 return epochMs
181 except Exception:
182 main.log.exception( 'Uncaught exception getting epoch time' )
183 main.cleanup()
184 main.exit()
185
GlennRC9cc3dd92015-12-10 12:21:25 -0800186 def onosPackage( self, opTimeout=120 ):
kelvin8ec71442015-01-15 16:57:00 -0800187 """
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400188 Produce a self-contained tar.gz file that can be deployed
Jon Hall64af8502015-12-15 10:09:33 -0800189 and executed on any platform with Java 8 JRE.
kelvin8ec71442015-01-15 16:57:00 -0800190 """
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400191 try:
Jon Hall64af8502015-12-15 10:09:33 -0800192 ret = main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800193 self.handle.sendline( "onos-package" )
194 self.handle.expect( "onos-package" )
Jon Hallc6793552016-01-19 14:18:37 -0800195 i = self.handle.expect( [ "Downloading",
196 "tar.gz",
197 "\$",
198 "Unknown options" ],
199 opTimeout )
Jon Hall64af8502015-12-15 10:09:33 -0800200 handle = str( self.handle.before + self.handle.after )
201 if i == 0:
Jon Hallc6793552016-01-19 14:18:37 -0800202 # Give more time to download the file
203 self.handle.expect( "\$", opTimeout * 2 )
Jon Hall64af8502015-12-15 10:09:33 -0800204 handle += str( self.handle.before )
205 elif i == 1:
Jon Hallc6793552016-01-19 14:18:37 -0800206 self.handle.expect( "\$" )
207 handle += str( self.handle.before )
208 elif i == 2:
Jon Hall64af8502015-12-15 10:09:33 -0800209 # This seems to be harmless, but may be a problem
210 main.log.warn( "onos-package output not as expected" )
Jon Hallc6793552016-01-19 14:18:37 -0800211 elif i == 3:
Jon Hall64af8502015-12-15 10:09:33 -0800212 # Incorrect usage
213 main.log.error( "onos-package does not recognize the given options" )
214 self.handle.expect( "\$" )
215 handle += str( self.handle.before )
216 ret = main.FALSE
Jon Hallc6793552016-01-19 14:18:37 -0800217 main.log.info( "onos-package command returned: " + handle )
kelvin8ec71442015-01-15 16:57:00 -0800218 # As long as the sendline does not time out,
219 # return true. However, be careful to interpret
220 # the results of the onos-package command return
Jon Hall64af8502015-12-15 10:09:33 -0800221 return ret
222 except pexpect.TIMEOUT:
223 main.log.exception( self.name + ": TIMEOUT exception found in onosPackage" )
224 main.log.error( self.name + ": " + self.handle.before )
225 return main.FALSE
andrewonlab7735d852014-10-09 13:02:47 -0400226 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800227 main.log.error( self.name + ": EOF exception found" )
228 main.log.error( self.name + ": " + self.handle.before )
Jon Hall64af8502015-12-15 10:09:33 -0800229 main.cleanup()
230 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800231 except Exception:
232 main.log.exception( "Failed to package ONOS" )
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400233 main.cleanup()
234 main.exit()
235
kelvin-onlabd3b64892015-01-20 13:26:24 -0800236 def onosBuild( self ):
kelvin8ec71442015-01-15 16:57:00 -0800237 """
andrewonlab8790abb2014-11-06 13:51:54 -0500238 Use the pre defined script to build onos via mvn
kelvin8ec71442015-01-15 16:57:00 -0800239 """
andrewonlab8790abb2014-11-06 13:51:54 -0500240 try:
kelvin8ec71442015-01-15 16:57:00 -0800241 self.handle.sendline( "onos-build" )
242 self.handle.expect( "onos-build" )
243 i = self.handle.expect( [
kelvin-onlabd3b64892015-01-20 13:26:24 -0800244 "BUILD SUCCESS",
245 "ERROR",
246 "BUILD FAILED" ],
247 timeout=120 )
kelvin8ec71442015-01-15 16:57:00 -0800248 handle = str( self.handle.before )
Jon Hall3b489db2015-10-05 14:38:37 -0700249 self.handle.expect( "\$" )
andrewonlab8790abb2014-11-06 13:51:54 -0500250
kelvin8ec71442015-01-15 16:57:00 -0800251 main.log.info( "onos-build command returned: " +
252 handle )
andrewonlab8790abb2014-11-06 13:51:54 -0500253
254 if i == 0:
255 return main.TRUE
256 else:
257 return handle
258
259 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800260 main.log.error( self.name + ": EOF exception found" )
261 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -0800262 except Exception:
263 main.log.exception( "Failed to build ONOS" )
andrewonlab8790abb2014-11-06 13:51:54 -0500264 main.cleanup()
265 main.exit()
266
shahshreya9f531fe2015-06-10 12:03:51 -0700267 def cleanInstall( self, skipTest=False, mciTimeout=600 ):
kelvin8ec71442015-01-15 16:57:00 -0800268 """
269 Runs mvn clean install in the root of the ONOS directory.
270 This will clean all ONOS artifacts then compile each module
shahshreya9f531fe2015-06-10 12:03:51 -0700271 Optional:
272 skipTest - Does "-DskipTests -Dcheckstyle.skip -U -T 1C" which
273 skip the test. This will make the building faster.
274 Disregarding the credibility of the build
kelvin8ec71442015-01-15 16:57:00 -0800275 Returns: main.TRUE on success
Jon Hallde9d9aa2014-10-08 20:36:02 -0400276 On Failure, exits the test
kelvin8ec71442015-01-15 16:57:00 -0800277 """
Jon Hallde9d9aa2014-10-08 20:36:02 -0400278 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800279 main.log.info( "Running 'mvn clean install' on " +
280 str( self.name ) +
kelvin8ec71442015-01-15 16:57:00 -0800281 ". This may take some time." )
282 self.handle.sendline( "cd " + self.home )
283 self.handle.expect( "\$" )
Jon Hallea7818b2014-10-09 14:30:59 -0400284
kelvin8ec71442015-01-15 16:57:00 -0800285 self.handle.sendline( "" )
286 self.handle.expect( "\$" )
shahshreya9f531fe2015-06-10 12:03:51 -0700287
288 if not skipTest:
289 self.handle.sendline( "mvn clean install" )
290 self.handle.expect( "mvn clean install" )
291 else:
292 self.handle.sendline( "mvn clean install -DskipTests" +
293 " -Dcheckstyle.skip -U -T 1C" )
294 self.handle.expect( "mvn clean install -DskipTests" +
295 " -Dcheckstyle.skip -U -T 1C" )
kelvin8ec71442015-01-15 16:57:00 -0800296 while True:
297 i = self.handle.expect( [
Jon Hall274b6642015-02-17 11:57:17 -0800298 'There\sis\sinsufficient\smemory\sfor\sthe\sJava\s' +
Jon Hallefbd9792015-03-05 16:11:36 -0800299 'Runtime\sEnvironment\sto\scontinue',
Jon Hallde9d9aa2014-10-08 20:36:02 -0400300 'BUILD\sFAILURE',
301 'BUILD\sSUCCESS',
Jon Halle94919c2015-03-23 11:42:57 -0700302 'onos\$', #TODO: fix this to be more generic?
Jon Hallde9d9aa2014-10-08 20:36:02 -0400303 'ONOS\$',
pingping-lin57a56ce2015-05-20 16:43:48 -0700304 pexpect.TIMEOUT ], mciTimeout )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400305 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -0800306 main.log.error( self.name + ":There is insufficient memory \
307 for the Java Runtime Environment to continue." )
308 # return main.FALSE
Jon Hallde9d9aa2014-10-08 20:36:02 -0400309 main.cleanup()
310 main.exit()
311 if i == 1:
kelvin8ec71442015-01-15 16:57:00 -0800312 main.log.error( self.name + ": Build failure!" )
313 # return main.FALSE
Jon Hallde9d9aa2014-10-08 20:36:02 -0400314 main.cleanup()
315 main.exit()
316 elif i == 2:
kelvin8ec71442015-01-15 16:57:00 -0800317 main.log.info( self.name + ": Build success!" )
Jon Halle94919c2015-03-23 11:42:57 -0700318 elif i == 3 or i == 4:
kelvin8ec71442015-01-15 16:57:00 -0800319 main.log.info( self.name + ": Build complete" )
320 # Print the build time
Jon Hallf8ef52c2014-10-09 19:37:33 -0400321 for line in self.handle.before.splitlines():
322 if "Total time:" in line:
kelvin8ec71442015-01-15 16:57:00 -0800323 main.log.info( line )
324 self.handle.sendline( "" )
325 self.handle.expect( "\$", timeout=60 )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400326 return main.TRUE
Jon Halle94919c2015-03-23 11:42:57 -0700327 elif i == 5:
kelvin8ec71442015-01-15 16:57:00 -0800328 main.log.error(
329 self.name +
330 ": mvn clean install TIMEOUT!" )
331 # return main.FALSE
Jon Hallde9d9aa2014-10-08 20:36:02 -0400332 main.cleanup()
333 main.exit()
334 else:
Jon Hall274b6642015-02-17 11:57:17 -0800335 main.log.error( self.name + ": unexpected response from " +
Jon Hallefbd9792015-03-05 16:11:36 -0800336 "mvn clean install" )
kelvin8ec71442015-01-15 16:57:00 -0800337 # return main.FALSE
Jon Hallde9d9aa2014-10-08 20:36:02 -0400338 main.cleanup()
339 main.exit()
340 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800341 main.log.error( self.name + ": EOF exception found" )
342 main.log.error( self.name + ": " + self.handle.before )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400343 main.cleanup()
344 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800345 except Exception:
346 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400347 main.cleanup()
348 main.exit()
Jon Hallacabffd2014-10-09 12:36:53 -0400349
Jon Hall61282e32015-03-19 11:34:11 -0700350 def gitPull( self, comp1="", fastForward=True ):
kelvin8ec71442015-01-15 16:57:00 -0800351 """
Jon Hallacabffd2014-10-09 12:36:53 -0400352 Assumes that "git pull" works without login
Jon Hall47a93fb2015-01-06 16:46:06 -0800353
Jon Hall61282e32015-03-19 11:34:11 -0700354 If the fastForward boolean is set to true, only git pulls that can
355 be fast forwarded will be performed. IE if you have not local commits
356 in your branch.
357
Jon Hallacabffd2014-10-09 12:36:53 -0400358 This function will perform a git pull on the ONOS instance.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800359 If used as gitPull( "NODE" ) it will do git pull + NODE. This is
Jon Hallacabffd2014-10-09 12:36:53 -0400360 for the purpose of pulling from other nodes if necessary.
361
Jon Hall47a93fb2015-01-06 16:46:06 -0800362 Otherwise, this function will perform a git pull in the
Jon Hallacabffd2014-10-09 12:36:53 -0400363 ONOS repository. If it has any problems, it will return main.ERROR
kelvin-onlabd3b64892015-01-20 13:26:24 -0800364 If it successfully does a gitPull, it will return a 1 ( main.TRUE )
Shreya Shahee15f6c2014-10-28 18:12:30 -0400365 If it has no updates, it will return 3.
Jon Hallacabffd2014-10-09 12:36:53 -0400366
kelvin8ec71442015-01-15 16:57:00 -0800367 """
Jon Hallacabffd2014-10-09 12:36:53 -0400368 try:
kelvin8ec71442015-01-15 16:57:00 -0800369 self.handle.sendline( "cd " + self.home )
kelvin-onlaba1484582015-02-02 15:46:20 -0800370 self.handle.expect( self.home + "\$" )
Jon Hall61282e32015-03-19 11:34:11 -0700371 cmd = "git pull"
372 if comp1 != "":
373 cmd += ' ' + comp1
374 if fastForward:
375 cmd += ' ' + " --ff-only"
376 self.handle.sendline( cmd )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800377 i = self.handle.expect(
378 [
379 'fatal',
380 'Username\sfor\s(.*):\s',
381 '\sfile(s*) changed,\s',
382 'Already up-to-date',
383 'Aborting',
384 'You\sare\snot\scurrently\son\sa\sbranch',
Jon Hall274b6642015-02-17 11:57:17 -0800385 'You asked me to pull without telling me which branch you',
386 'Pull is not possible because you have unmerged files',
Jon Hall61282e32015-03-19 11:34:11 -0700387 'Please enter a commit message to explain why this merge',
388 'Found a swap file by the name',
389 'Please, commit your changes before you can merge.',
kelvin-onlabd3b64892015-01-20 13:26:24 -0800390 pexpect.TIMEOUT ],
391 timeout=300 )
kelvin8ec71442015-01-15 16:57:00 -0800392 if i == 0:
Jon Hall61282e32015-03-19 11:34:11 -0700393 main.log.error( self.name + ": Git pull had some issue" )
394 output = self.handle.after
395 self.handle.expect( '\$' )
396 output += self.handle.before
397 main.log.warn( output )
Jon Hallacabffd2014-10-09 12:36:53 -0400398 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800399 elif i == 1:
400 main.log.error(
401 self.name +
402 ": Git Pull Asking for username. " )
Jon Hallacabffd2014-10-09 12:36:53 -0400403 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800404 elif i == 2:
405 main.log.info(
406 self.name +
407 ": Git Pull - pulling repository now" )
kelvin-onlaba1484582015-02-02 15:46:20 -0800408 self.handle.expect( self.home + "\$", 120 )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800409 # So that only when git pull is done, we do mvn clean compile
410 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800411 elif i == 3:
412 main.log.info( self.name + ": Git Pull - Already up to date" )
Jon Hall47a93fb2015-01-06 16:46:06 -0800413 return i
kelvin8ec71442015-01-15 16:57:00 -0800414 elif i == 4:
415 main.log.info(
416 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800417 ": Git Pull - Aborting..." +
418 "Are there conflicting git files?" )
Jon Hallacabffd2014-10-09 12:36:53 -0400419 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800420 elif i == 5:
421 main.log.info(
422 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800423 ": Git Pull - You are not currently " +
424 "on a branch so git pull failed!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400425 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800426 elif i == 6:
427 main.log.info(
428 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800429 ": Git Pull - You have not configured an upstream " +
430 "branch to pull from. Git pull failed!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400431 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800432 elif i == 7:
433 main.log.info(
434 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800435 ": Git Pull - Pull is not possible because " +
436 "you have unmerged files." )
Jon Hallacabffd2014-10-09 12:36:53 -0400437 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800438 elif i == 8:
Jon Hall61282e32015-03-19 11:34:11 -0700439 # NOTE: abandoning test since we can't reliably handle this
440 # there could be different default text editors and we
441 # also don't know if we actually want to make the commit
442 main.log.error( "Git pull resulted in a merge commit message" +
443 ". Exiting test!" )
444 main.cleanup()
445 main.exit()
446 elif i == 9: # Merge commit message but swap file exists
447 main.log.error( "Git pull resulted in a merge commit message" +
448 " but a swap file exists." )
449 try:
450 self.handle.send( 'A' ) # Abort
451 self.handle.expect( "\$" )
452 return main.ERROR
453 except Exception:
454 main.log.exception( "Couldn't exit editor prompt!")
455 main.cleanup()
456 main.exit()
457 elif i == 10: # In the middle of a merge commit
458 main.log.error( "Git branch is in the middle of a merge. " )
459 main.log.warn( self.handle.before + self.handle.after )
460 return main.ERROR
461 elif i == 11:
kelvin8ec71442015-01-15 16:57:00 -0800462 main.log.error( self.name + ": Git Pull - TIMEOUT" )
463 main.log.error(
464 self.name + " Response was: " + str(
465 self.handle.before ) )
Jon Hallacabffd2014-10-09 12:36:53 -0400466 return main.ERROR
467 else:
kelvin8ec71442015-01-15 16:57:00 -0800468 main.log.error(
469 self.name +
470 ": Git Pull - Unexpected response, check for pull errors" )
Jon Hallacabffd2014-10-09 12:36:53 -0400471 return main.ERROR
472 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800473 main.log.error( self.name + ": EOF exception found" )
474 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400475 main.cleanup()
476 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800477 except Exception:
478 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400479 main.cleanup()
480 main.exit()
481
kelvin-onlabd3b64892015-01-20 13:26:24 -0800482 def gitCheckout( self, branch="master" ):
kelvin8ec71442015-01-15 16:57:00 -0800483 """
Jon Hallacabffd2014-10-09 12:36:53 -0400484 Assumes that "git pull" works without login
kelvin8ec71442015-01-15 16:57:00 -0800485
Jon Hallacabffd2014-10-09 12:36:53 -0400486 This function will perform a git git checkout on the ONOS instance.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800487 If used as gitCheckout( "branch" ) it will do git checkout
488 of the "branch".
Jon Hallacabffd2014-10-09 12:36:53 -0400489
490 Otherwise, this function will perform a git checkout of the master
kelvin8ec71442015-01-15 16:57:00 -0800491 branch of the ONOS repository. If it has any problems, it will return
492 main.ERROR.
493 If the branch was already the specified branch, or the git checkout was
Jon Hallacabffd2014-10-09 12:36:53 -0400494 successful then the function will return main.TRUE.
495
kelvin8ec71442015-01-15 16:57:00 -0800496 """
Jon Hallacabffd2014-10-09 12:36:53 -0400497 try:
kelvin8ec71442015-01-15 16:57:00 -0800498 self.handle.sendline( "cd " + self.home )
kelvin-onlaba1484582015-02-02 15:46:20 -0800499 self.handle.expect( self.home + "\$" )
Jon Hall274b6642015-02-17 11:57:17 -0800500 main.log.info( self.name +
501 ": Checking out git branch/ref: " + branch + "..." )
kelvin8ec71442015-01-15 16:57:00 -0800502 cmd = "git checkout " + branch
503 self.handle.sendline( cmd )
504 self.handle.expect( cmd )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800505 i = self.handle.expect(
Jon Hall274b6642015-02-17 11:57:17 -0800506 [ 'fatal',
Jon Hall61282e32015-03-19 11:34:11 -0700507 'Username for (.*): ',
508 'Already on \'',
Jon Hall7a8354f2015-06-10 15:37:00 -0700509 'Switched to (a new )?branch \'' + str( branch ),
Jon Hall274b6642015-02-17 11:57:17 -0800510 pexpect.TIMEOUT,
511 'error: Your local changes to the following files' +
Jon Hallefbd9792015-03-05 16:11:36 -0800512 'would be overwritten by checkout:',
Jon Hall274b6642015-02-17 11:57:17 -0800513 'error: you need to resolve your current index first',
514 "You are in 'detached HEAD' state.",
515 "HEAD is now at " ],
kelvin-onlabd3b64892015-01-20 13:26:24 -0800516 timeout=60 )
kelvin8ec71442015-01-15 16:57:00 -0800517 if i == 0:
518 main.log.error(
519 self.name +
520 ": Git checkout had some issue..." )
521 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400522 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800523 elif i == 1:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800524 main.log.error(
525 self.name +
526 ": Git checkout asking for username." +
527 " Please configure your local git repository to be able " +
528 "to access your remote repository passwordlessly" )
Jon Hall274b6642015-02-17 11:57:17 -0800529 # TODO add support for authenticating
Jon Hallacabffd2014-10-09 12:36:53 -0400530 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800531 elif i == 2:
532 main.log.info(
533 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800534 ": Git Checkout %s : Already on this branch" % branch )
kelvin-onlaba1484582015-02-02 15:46:20 -0800535 self.handle.expect( self.home + "\$" )
kelvin8ec71442015-01-15 16:57:00 -0800536 # main.log.info( "DEBUG: after checkout cmd = "+
537 # self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400538 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800539 elif i == 3:
540 main.log.info(
541 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800542 ": Git checkout %s - Switched to this branch" % branch )
kelvin-onlaba1484582015-02-02 15:46:20 -0800543 self.handle.expect( self.home + "\$" )
kelvin8ec71442015-01-15 16:57:00 -0800544 # main.log.info( "DEBUG: after checkout cmd = "+
545 # self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400546 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800547 elif i == 4:
548 main.log.error( self.name + ": Git Checkout- TIMEOUT" )
549 main.log.error(
Jon Hall274b6642015-02-17 11:57:17 -0800550 self.name + " Response was: " + str( self.handle.before ) )
Jon Hallacabffd2014-10-09 12:36:53 -0400551 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800552 elif i == 5:
553 self.handle.expect( "Aborting" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800554 main.log.error(
555 self.name +
556 ": Git checkout error: \n" +
Jon Hall274b6642015-02-17 11:57:17 -0800557 "Your local changes to the following files would" +
558 " be overwritten by checkout:" +
559 str( self.handle.before ) )
kelvin-onlaba1484582015-02-02 15:46:20 -0800560 self.handle.expect( self.home + "\$" )
Jon Hall81e29af2014-11-04 20:41:23 -0500561 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800562 elif i == 6:
Jon Hall274b6642015-02-17 11:57:17 -0800563 main.log.error(
564 self.name +
565 ": Git checkout error: \n" +
566 "You need to resolve your current index first:" +
567 str( self.handle.before ) )
kelvin-onlaba1484582015-02-02 15:46:20 -0800568 self.handle.expect( self.home + "\$" )
Jon Hall81e29af2014-11-04 20:41:23 -0500569 return main.ERROR
Jon Hall274b6642015-02-17 11:57:17 -0800570 elif i == 7:
571 main.log.info(
572 self.name +
573 ": Git checkout " + str( branch ) +
574 " - You are in 'detached HEAD' state. HEAD is now at " +
575 str( branch ) )
576 self.handle.expect( self.home + "\$" )
577 return main.TRUE
578 elif i == 8: # Already in detached HEAD on the specified commit
579 main.log.info(
580 self.name +
581 ": Git Checkout %s : Already on commit" % branch )
582 self.handle.expect( self.home + "\$" )
583 return main.TRUE
Jon Hallacabffd2014-10-09 12:36:53 -0400584 else:
kelvin8ec71442015-01-15 16:57:00 -0800585 main.log.error(
586 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800587 ": Git Checkout - Unexpected response, " +
588 "check for pull errors" )
kelvin8ec71442015-01-15 16:57:00 -0800589 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400590 return main.ERROR
591
592 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800593 main.log.error( self.name + ": EOF exception found" )
594 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400595 main.cleanup()
596 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800597 except Exception:
598 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400599 main.cleanup()
600 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -0400601
pingping-lin6d23d9e2015-02-02 16:54:24 -0800602 def getBranchName( self ):
pingping-linf30cf272015-05-29 15:54:07 -0700603 main.log.info( "self.home = " )
604 main.log.info( self.home )
pingping-lin6d23d9e2015-02-02 16:54:24 -0800605 self.handle.sendline( "cd " + self.home )
pingping-lin9bf3d8f2015-05-29 16:05:28 -0700606 self.handle.expect( self.home + "\$" )
pingping-lin6d23d9e2015-02-02 16:54:24 -0800607 self.handle.sendline( "git name-rev --name-only HEAD" )
608 self.handle.expect( "git name-rev --name-only HEAD" )
609 self.handle.expect( "\$" )
610
611 lines = self.handle.before.splitlines()
612 if lines[1] == "master":
613 return "master"
614 elif lines[1] == "onos-1.0":
615 return "onos-1.0"
616 else:
617 main.log.info( lines[1] )
618 return "unexpected ONOS branch for SDN-IP test"
619
kelvin-onlabd3b64892015-01-20 13:26:24 -0800620 def getVersion( self, report=False ):
kelvin8ec71442015-01-15 16:57:00 -0800621 """
Jon Hall274b6642015-02-17 11:57:17 -0800622 Writes the COMMIT number to the report to be parsed
Jon Hallefbd9792015-03-05 16:11:36 -0800623 by Jenkins data collector.
kelvin8ec71442015-01-15 16:57:00 -0800624 """
Jon Hall45ec0922014-10-10 19:33:49 -0400625 try:
kelvin8ec71442015-01-15 16:57:00 -0800626 self.handle.sendline( "" )
627 self.handle.expect( "\$" )
628 self.handle.sendline(
629 "cd " +
630 self.home +
Jon Hall274b6642015-02-17 11:57:17 -0800631 "; git log -1 --pretty=fuller --decorate=short | grep -A 6 " +
632 " \"commit\" --color=never" )
kelvin8ec71442015-01-15 16:57:00 -0800633 # NOTE: for some reason there are backspaces inserted in this
634 # phrase when run from Jenkins on some tests
635 self.handle.expect( "never" )
636 self.handle.expect( "\$" )
637 response = ( self.name + ": \n" + str(
638 self.handle.before + self.handle.after ) )
639 self.handle.sendline( "cd " + self.home )
640 self.handle.expect( "\$" )
641 lines = response.splitlines()
Jon Hall45ec0922014-10-10 19:33:49 -0400642 for line in lines:
Jon Hallfd191202014-11-07 18:36:09 -0500643 print line
644 if report:
pingping-lin763ee042015-05-20 17:45:30 -0700645 main.log.wiki( "<blockquote>" )
kelvin8ec71442015-01-15 16:57:00 -0800646 for line in lines[ 2:-1 ]:
647 # Bracket replacement is for Wiki-compliant
648 # formatting. '<' or '>' are interpreted
649 # as xml specific tags that cause errors
650 line = line.replace( "<", "[" )
651 line = line.replace( ">", "]" )
pingping-lin763ee042015-05-20 17:45:30 -0700652 #main.log.wiki( "\t" + line )
653 main.log.wiki( line + "<br /> " )
654 main.log.summary( line )
655 main.log.wiki( "</blockquote>" )
656 main.log.summary("\n")
kelvin8ec71442015-01-15 16:57:00 -0800657 return lines[ 2 ]
Jon Hall45ec0922014-10-10 19:33:49 -0400658 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800659 main.log.error( self.name + ": EOF exception found" )
660 main.log.error( self.name + ": " + self.handle.before )
Jon Hall45ec0922014-10-10 19:33:49 -0400661 main.cleanup()
662 main.exit()
Jon Hall368769f2014-11-19 15:43:35 -0800663 except pexpect.TIMEOUT:
kelvin8ec71442015-01-15 16:57:00 -0800664 main.log.error( self.name + ": TIMEOUT exception found" )
665 main.log.error( self.name + ": " + self.handle.before )
Jon Hall368769f2014-11-19 15:43:35 -0800666 main.cleanup()
667 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800668 except Exception:
669 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall45ec0922014-10-10 19:33:49 -0400670 main.cleanup()
671 main.exit()
672
kelvin-onlabd3b64892015-01-20 13:26:24 -0800673 def createCellFile( self, benchIp, fileName, mnIpAddrs,
kelvin-onlaba4074292015-07-09 15:19:49 -0700674 appString, onosIpAddrs ):
kelvin8ec71442015-01-15 16:57:00 -0800675 """
andrewonlab94282092014-10-10 13:00:11 -0400676 Creates a cell file based on arguments
677 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800678 * Bench IP address ( benchIp )
andrewonlab94282092014-10-10 13:00:11 -0400679 - Needed to copy the cell file over
kelvin-onlabd3b64892015-01-20 13:26:24 -0800680 * File name of the cell file ( fileName )
681 * Mininet IP address ( mnIpAddrs )
kelvin8ec71442015-01-15 16:57:00 -0800682 - Note that only 1 ip address is
andrewonlab94282092014-10-10 13:00:11 -0400683 supported currently
kelvin-onlabd3b64892015-01-20 13:26:24 -0800684 * ONOS IP addresses ( onosIpAddrs )
andrewonlab94282092014-10-10 13:00:11 -0400685 - Must be passed in as last arguments
kelvin8ec71442015-01-15 16:57:00 -0800686
andrewonlab94282092014-10-10 13:00:11 -0400687 NOTE: Assumes cells are located at:
688 ~/<self.home>/tools/test/cells/
kelvin8ec71442015-01-15 16:57:00 -0800689 """
690 # Variable initialization
Jon Hall6801cda2015-07-15 14:13:45 -0700691 cellDirectory = self.home + "/tools/test/cells/"
kelvin8ec71442015-01-15 16:57:00 -0800692 # We want to create the cell file in the dependencies directory
693 # of TestON first, then copy over to ONOS bench
kelvin-onlabd3b64892015-01-20 13:26:24 -0800694 tempDirectory = "/tmp/"
kelvin8ec71442015-01-15 16:57:00 -0800695 # Create the cell file in the directory for writing ( w+ )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800696 cellFile = open( tempDirectory + fileName, 'w+' )
Jon Hall6801cda2015-07-15 14:13:45 -0700697 if isinstance( onosIpAddrs, types.StringType ):
698 onosIpAddrs = [ onosIpAddrs ]
kelvin8ec71442015-01-15 16:57:00 -0800699
cameron@onlab.us75900962015-03-30 13:22:49 -0700700 # App string is hardcoded environment variables
kelvin8ec71442015-01-15 16:57:00 -0800701 # That you may wish to use by default on startup.
cameron@onlab.us75900962015-03-30 13:22:49 -0700702 # Note that you may not want certain apps listed
kelvin8ec71442015-01-15 16:57:00 -0800703 # on here.
cameron@onlab.us75900962015-03-30 13:22:49 -0700704 appString = "export ONOS_APPS=" + appString
kelvin-onlabd3b64892015-01-20 13:26:24 -0800705 mnString = "export OCN="
kelvin-onlabf70fd542015-05-07 18:41:40 -0700706 if mnIpAddrs == "":
707 mnString = ""
kelvin-onlabd3b64892015-01-20 13:26:24 -0800708 onosString = "export OC"
709 tempCount = 1
kelvin8ec71442015-01-15 16:57:00 -0800710
kelvin-onlabd3b64892015-01-20 13:26:24 -0800711 # Create ONOSNIC ip address prefix
kelvin-onlaba4074292015-07-09 15:19:49 -0700712 tempOnosIp = str( onosIpAddrs[ 0 ] )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800713 tempList = []
714 tempList = tempOnosIp.split( "." )
kelvin8ec71442015-01-15 16:57:00 -0800715 # Omit last element of list to format for NIC
kelvin-onlabd3b64892015-01-20 13:26:24 -0800716 tempList = tempList[ :-1 ]
kelvin8ec71442015-01-15 16:57:00 -0800717 # Structure the nic string ip
kelvin-onlabd3b64892015-01-20 13:26:24 -0800718 nicAddr = ".".join( tempList ) + ".*"
719 onosNicString = "export ONOS_NIC=" + nicAddr
andrewonlab94282092014-10-10 13:00:11 -0400720
721 try:
kelvin8ec71442015-01-15 16:57:00 -0800722 # Start writing to file
kelvin-onlabd3b64892015-01-20 13:26:24 -0800723 cellFile.write( onosNicString + "\n" )
andrewonlab94282092014-10-10 13:00:11 -0400724
kelvin-onlabd3b64892015-01-20 13:26:24 -0800725 for arg in onosIpAddrs:
726 # For each argument in onosIpAddrs, write to file
kelvin8ec71442015-01-15 16:57:00 -0800727 # Output should look like the following:
andrewonlabd4940492014-10-24 12:21:27 -0400728 # export OC1="10.128.20.11"
729 # export OC2="10.128.20.12"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800730 cellFile.write( onosString + str( tempCount ) +
Jon Hall6f665652015-09-18 10:08:07 -0700731 "=\"" + arg + "\"\n" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800732 tempCount = tempCount + 1
kelvin8ec71442015-01-15 16:57:00 -0800733
Jon Hall6f665652015-09-18 10:08:07 -0700734 cellFile.write( "export OCI=$OC1\n" )
735 cellFile.write( mnString + "\"" + mnIpAddrs + "\"\n" )
cameron@onlab.us75900962015-03-30 13:22:49 -0700736 cellFile.write( appString + "\n" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800737 cellFile.close()
andrewonlab94282092014-10-10 13:00:11 -0400738
kelvin8ec71442015-01-15 16:57:00 -0800739 # We use os.system to send the command to TestON cluster
740 # to account for the case in which TestON is not located
741 # on the same cluster as the ONOS bench
742 # Note that even if TestON is located on the same cluster
743 # as ONOS bench, you must setup passwordless ssh
744 # between TestON and ONOS bench in order to automate the test.
kelvin-onlabc2b79102015-07-14 11:41:20 -0700745 os.system( "scp " + tempDirectory + fileName + " " +
746 self.user_name + "@" + self.ip_address + ":" + cellDirectory )
andrewonlab94282092014-10-10 13:00:11 -0400747
andrewonlab2a6c9342014-10-16 13:40:15 -0400748 return main.TRUE
749
andrewonlab94282092014-10-10 13:00:11 -0400750 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800751 main.log.error( self.name + ": EOF exception found" )
752 main.log.error( self.name + ": " + self.handle.before )
andrewonlab94282092014-10-10 13:00:11 -0400753 main.cleanup()
754 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800755 except Exception:
756 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab94282092014-10-10 13:00:11 -0400757 main.cleanup()
758 main.exit()
759
kelvin-onlabd3b64892015-01-20 13:26:24 -0800760 def setCell( self, cellname ):
kelvin8ec71442015-01-15 16:57:00 -0800761 """
andrewonlab95ca1462014-10-09 14:04:24 -0400762 Calls 'cell <name>' to set the environment variables on ONOSbench
kelvin8ec71442015-01-15 16:57:00 -0800763 """
Hari Krishna03f530e2015-07-10 17:28:27 -0700764 import re
andrewonlab95ca1462014-10-09 14:04:24 -0400765 try:
766 if not cellname:
kelvin8ec71442015-01-15 16:57:00 -0800767 main.log.error( "Must define cellname" )
andrewonlab95ca1462014-10-09 14:04:24 -0400768 main.cleanup()
769 main.exit()
770 else:
kelvin8ec71442015-01-15 16:57:00 -0800771 self.handle.sendline( "cell " + str( cellname ) )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800772 # Expect the cellname in the ONOSCELL variable.
kelvin8ec71442015-01-15 16:57:00 -0800773 # Note that this variable name is subject to change
andrewonlab95ca1462014-10-09 14:04:24 -0400774 # and that this driver will have to change accordingly
Jon Hall3b489db2015-10-05 14:38:37 -0700775 self.handle.expect( str( cellname ) )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800776 handleBefore = self.handle.before
777 handleAfter = self.handle.after
kelvin8ec71442015-01-15 16:57:00 -0800778 # Get the rest of the handle
Jon Hall3b489db2015-10-05 14:38:37 -0700779 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800780 handleMore = self.handle.before
andrewonlab95ca1462014-10-09 14:04:24 -0400781
Hari Krishna03f530e2015-07-10 17:28:27 -0700782 cell_result = handleBefore + handleAfter + handleMore
783 print cell_result
784 if( re.search( "No such cell", cell_result ) ):
785 main.log.error( "Cell call returned: " + handleBefore +
kelvin-onlabd3b64892015-01-20 13:26:24 -0800786 handleAfter + handleMore )
Hari Krishna03f530e2015-07-10 17:28:27 -0700787 main.cleanup()
788 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -0400789 return main.TRUE
andrewonlab95ca1462014-10-09 14:04:24 -0400790 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800791 main.log.error( self.name + ": EOF exception found" )
792 main.log.error( self.name + ": " + self.handle.before )
andrewonlab95ca1462014-10-09 14:04:24 -0400793 main.cleanup()
794 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800795 except Exception:
796 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab95ca1462014-10-09 14:04:24 -0400797 main.cleanup()
798 main.exit()
799
kelvin-onlabd3b64892015-01-20 13:26:24 -0800800 def verifyCell( self ):
kelvin8ec71442015-01-15 16:57:00 -0800801 """
andrewonlabc03bf6c2014-10-09 14:56:18 -0400802 Calls 'onos-verify-cell' to check for cell installation
kelvin8ec71442015-01-15 16:57:00 -0800803 """
804 # TODO: Add meaningful expect value
andrewonlab8d0d7d72014-10-09 16:33:15 -0400805
andrewonlabc03bf6c2014-10-09 14:56:18 -0400806 try:
kelvin8ec71442015-01-15 16:57:00 -0800807 # Clean handle by sending empty and expecting $
808 self.handle.sendline( "" )
809 self.handle.expect( "\$" )
810 self.handle.sendline( "onos-verify-cell" )
811 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800812 handleBefore = self.handle.before
813 handleAfter = self.handle.after
kelvin-onlabd3b64892015-01-20 13:26:24 -0800814 main.log.info( "Verify cell returned: " + handleBefore +
Jon Hall3b489db2015-10-05 14:38:37 -0700815 handleAfter )
andrewonlabc03bf6c2014-10-09 14:56:18 -0400816 return main.TRUE
Jon Halla5cb6172015-02-23 09:28:28 -0800817 except pexpect.ExceptionPexpect as e:
Jon Hall3b489db2015-10-05 14:38:37 -0700818 main.log.exception( self.name + ": Pexpect exception found: " )
kelvin8ec71442015-01-15 16:57:00 -0800819 main.log.error( self.name + ": " + self.handle.before )
Jon Hall7993bfc2014-10-09 16:30:14 -0400820 main.cleanup()
821 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800822 except Exception:
823 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall7993bfc2014-10-09 16:30:14 -0400824 main.cleanup()
825 main.exit()
826
jenkins1e99e7b2015-04-02 18:15:39 -0700827 def onosCfgSet( self, ONOSIp, configName, configParam ):
828 """
829 Uses 'onos <node-ip> cfg set' to change a parameter value of an
Jon Hall4ba53f02015-07-29 13:07:41 -0700830 application.
831
jenkins1e99e7b2015-04-02 18:15:39 -0700832 ex)
833 onos 10.0.0.1 cfg set org.onosproject.myapp appSetting 1
jenkins1e99e7b2015-04-02 18:15:39 -0700834 ONOSIp = '10.0.0.1'
835 configName = 'org.onosproject.myapp'
836 configParam = 'appSetting 1'
jenkins1e99e7b2015-04-02 18:15:39 -0700837 """
Jon Hall72280bc2016-01-25 14:29:05 -0800838 try:
839 cfgStr = "onos {} cfg set {} {}".format( ONOSIp,
840 configName,
841 configParam )
842 self.handle.sendline( "" )
843 self.handle.expect( ":~" )
844 self.handle.sendline( cfgStr )
845 self.handle.expect("cfg set")
846 self.handle.expect( ":~" )
jenkins1e99e7b2015-04-02 18:15:39 -0700847
Jon Hall72280bc2016-01-25 14:29:05 -0800848 paramValue = configParam.split(" ")[1]
849 paramName = configParam.split(" ")[0]
Jon Hall4ba53f02015-07-29 13:07:41 -0700850
Jon Hall72280bc2016-01-25 14:29:05 -0800851 checkStr = 'onos {} cfg get " {} {} " '.format( ONOSIp, configName, paramName )
Jon Hall4ba53f02015-07-29 13:07:41 -0700852
Jon Hall72280bc2016-01-25 14:29:05 -0800853 self.handle.sendline( checkStr )
854 self.handle.expect( ":~" )
jenkins1e99e7b2015-04-02 18:15:39 -0700855
Jon Hall72280bc2016-01-25 14:29:05 -0800856 if "value=" + paramValue + "," in self.handle.before:
857 main.log.info("cfg " + configName + " successfully set to " + configParam)
858 return main.TRUE
859 except pexpect.ExceptionPexpect as e:
860 main.log.exception( self.name + ": Pexpect exception found: " )
861 main.log.error( self.name + ": " + self.handle.before )
862 main.cleanup()
863 main.exit()
864 except Exception:
865 main.log.exception( self.name + ": Uncaught exception!" )
866 main.cleanup()
867 main.exit()
Jon Hall4ba53f02015-07-29 13:07:41 -0700868
kelvin-onlabd3b64892015-01-20 13:26:24 -0800869 def onosCli( self, ONOSIp, cmdstr ):
kelvin8ec71442015-01-15 16:57:00 -0800870 """
andrewonlab05e362f2014-10-10 00:40:57 -0400871 Uses 'onos' command to send various ONOS CLI arguments.
872 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800873 * ONOSIp: specify the ip of the cell machine
andrewonlab94282092014-10-10 13:00:11 -0400874 * cmdstr: specify the command string to send
kelvin8ec71442015-01-15 16:57:00 -0800875
876 This function is intended to expose the entire karaf
andrewonlab6e20c342014-10-10 18:08:48 -0400877 CLI commands for ONOS. Try to use this function first
878 before attempting to write a ONOS CLI specific driver
kelvin8ec71442015-01-15 16:57:00 -0800879 function.
880 You can see a list of available 'cmdstr' arguments
andrewonlab6e20c342014-10-10 18:08:48 -0400881 by starting onos, and typing in 'onos' to enter the
882 onos> CLI. Then, type 'help' to see the list of
kelvin8ec71442015-01-15 16:57:00 -0800883 available commands.
884 """
andrewonlab05e362f2014-10-10 00:40:57 -0400885 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800886 if not ONOSIp:
kelvin8ec71442015-01-15 16:57:00 -0800887 main.log.error( "You must specify the IP address" )
andrewonlab05e362f2014-10-10 00:40:57 -0400888 return main.FALSE
889 if not cmdstr:
kelvin8ec71442015-01-15 16:57:00 -0800890 main.log.error( "You must specify the command string" )
andrewonlab05e362f2014-10-10 00:40:57 -0400891 return main.FALSE
892
kelvin8ec71442015-01-15 16:57:00 -0800893 cmdstr = str( cmdstr )
894 self.handle.sendline( "" )
895 self.handle.expect( "\$" )
andrewonlab05e362f2014-10-10 00:40:57 -0400896
kelvin-onlabd3b64892015-01-20 13:26:24 -0800897 self.handle.sendline( "onos -w " + ONOSIp + " " + cmdstr )
kelvin8ec71442015-01-15 16:57:00 -0800898 self.handle.expect( "\$" )
andrewonlab05e362f2014-10-10 00:40:57 -0400899
kelvin-onlabd3b64892015-01-20 13:26:24 -0800900 handleBefore = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -0800901 main.log.info( "Command sent successfully" )
kelvin8ec71442015-01-15 16:57:00 -0800902 # Obtain return handle that consists of result from
903 # the onos command. The string may need to be
904 # configured further.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800905 returnString = handleBefore
kelvin-onlabd3b64892015-01-20 13:26:24 -0800906 return returnString
andrewonlab05e362f2014-10-10 00:40:57 -0400907 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800908 main.log.error( self.name + ": EOF exception found" )
909 main.log.error( self.name + ": " + self.handle.before )
andrewonlab05e362f2014-10-10 00:40:57 -0400910 main.cleanup()
911 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800912 except Exception:
913 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab05e362f2014-10-10 00:40:57 -0400914 main.cleanup()
915 main.exit()
Jon Hall7993bfc2014-10-09 16:30:14 -0400916
kelvin-onlabd3b64892015-01-20 13:26:24 -0800917 def onosInstall( self, options="-f", node="" ):
kelvin8ec71442015-01-15 16:57:00 -0800918 """
Jon Hall7993bfc2014-10-09 16:30:14 -0400919 Installs ONOS bits on the designated cell machine.
kelvin8ec71442015-01-15 16:57:00 -0800920 If -f option is provided, it also forces an uninstall.
921 Presently, install also includes onos-push-bits and
Jon Hall7993bfc2014-10-09 16:30:14 -0400922 onos-config within.
kelvin8ec71442015-01-15 16:57:00 -0800923 The node option allows you to selectively only push the jar
Jon Hall7993bfc2014-10-09 16:30:14 -0400924 files to certain onos nodes
925
926 Returns: main.TRUE on success and main.FALSE on failure
kelvin8ec71442015-01-15 16:57:00 -0800927 """
Jon Hall7993bfc2014-10-09 16:30:14 -0400928 try:
andrewonlab114768a2014-11-14 12:44:44 -0500929 if options:
kelvin8ec71442015-01-15 16:57:00 -0800930 self.handle.sendline( "onos-install " + options + " " + node )
andrewonlab114768a2014-11-14 12:44:44 -0500931 else:
kelvin8ec71442015-01-15 16:57:00 -0800932 self.handle.sendline( "onos-install " + node )
933 self.handle.expect( "onos-install " )
934 # NOTE: this timeout may need to change depending on the network
935 # and size of ONOS
936 i = self.handle.expect( [ "Network\sis\sunreachable",
kelvin-onlabd3b64892015-01-20 13:26:24 -0800937 "onos\sstart/running,\sprocess",
kelvin8ec71442015-01-15 16:57:00 -0800938 "ONOS\sis\salready\sinstalled",
Jeremyc72b2582016-02-26 18:27:38 -0800939 "already\sup-to-date",
940 "\$",
kelvin8ec71442015-01-15 16:57:00 -0800941 pexpect.TIMEOUT ], timeout=60 )
Jon Hall7993bfc2014-10-09 16:30:14 -0400942 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -0800943 main.log.warn( "Network is unreachable" )
Jon Hall3b489db2015-10-05 14:38:37 -0700944 self.handle.expect( "\$" )
Jon Hall7993bfc2014-10-09 16:30:14 -0400945 return main.FALSE
946 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -0800947 main.log.info(
948 "ONOS was installed on " +
949 node +
950 " and started" )
Jon Hall3b489db2015-10-05 14:38:37 -0700951 self.handle.expect( "\$" )
Jon Hall7993bfc2014-10-09 16:30:14 -0400952 return main.TRUE
andrewonlabd9a73a72014-11-14 17:28:21 -0500953 elif i == 2:
kelvin8ec71442015-01-15 16:57:00 -0800954 main.log.info( "ONOS is already installed on " + node )
Jon Hall3b489db2015-10-05 14:38:37 -0700955 self.handle.expect( "\$" )
andrewonlabd9a73a72014-11-14 17:28:21 -0500956 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800957 elif i == 3:
Jeremyc72b2582016-02-26 18:27:38 -0800958 main.log.info( "ONOS is already installed on " + node )
959 self.handle.expect( "\$" )
960 return main.TRUE
961 elif i == 4:
962 main.log.info( "ONOS was installed on " + node )
963 return main.TRUE
964 elif i == 5:
kelvin8ec71442015-01-15 16:57:00 -0800965 main.log.info(
966 "Installation of ONOS on " +
967 node +
968 " timed out" )
Jon Hall3b489db2015-10-05 14:38:37 -0700969 self.handle.expect( "\$" )
Jon Hall7993bfc2014-10-09 16:30:14 -0400970 return main.FALSE
andrewonlabc03bf6c2014-10-09 14:56:18 -0400971 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800972 main.log.error( self.name + ": EOF exception found" )
973 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc03bf6c2014-10-09 14:56:18 -0400974 main.cleanup()
975 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800976 except Exception:
977 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc03bf6c2014-10-09 14:56:18 -0400978 main.cleanup()
979 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -0400980
kelvin-onlabd3b64892015-01-20 13:26:24 -0800981 def onosStart( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -0800982 """
andrewonlab8d0d7d72014-10-09 16:33:15 -0400983 Calls onos command: 'onos-service [<node-ip>] start'
andrewonlabe8e56fd2014-10-09 17:12:44 -0400984 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -0800985 """
andrewonlab8d0d7d72014-10-09 16:33:15 -0400986 try:
kelvin8ec71442015-01-15 16:57:00 -0800987 self.handle.sendline( "" )
988 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800989 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -0800990 " start" )
991 i = self.handle.expect( [
andrewonlab8d0d7d72014-10-09 16:33:15 -0400992 "Job\sis\salready\srunning",
993 "start/running",
Jeremyd0e9a6d2016-03-02 11:28:52 -0800994 "\$",
andrewonlab8d0d7d72014-10-09 16:33:15 -0400995 "Unknown\sinstance",
kelvin8ec71442015-01-15 16:57:00 -0800996 pexpect.TIMEOUT ], timeout=120 )
Jon Hall3b489db2015-10-05 14:38:37 -0700997 self.handle.expect( "\$" )
andrewonlab8d0d7d72014-10-09 16:33:15 -0400998 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -0800999 main.log.info( "Service is already running" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001000 return main.TRUE
1001 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001002 main.log.info( "ONOS service started" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001003 return main.TRUE
Jeremyd0e9a6d2016-03-02 11:28:52 -08001004 elif i == 2:
1005 main.log.info( "ONOS service started" )
1006 return main.TRUE
andrewonlab8d0d7d72014-10-09 16:33:15 -04001007 else:
kelvin8ec71442015-01-15 16:57:00 -08001008 main.log.error( "ONOS service failed to start" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001009 main.cleanup()
1010 main.exit()
andrewonlab8d0d7d72014-10-09 16:33:15 -04001011 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001012 main.log.error( self.name + ": EOF exception found" )
1013 main.log.error( self.name + ": " + self.handle.before )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001014 main.cleanup()
1015 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001016 except Exception:
1017 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001018 main.cleanup()
1019 main.exit()
1020
kelvin-onlabd3b64892015-01-20 13:26:24 -08001021 def onosStop( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001022 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001023 Calls onos command: 'onos-service [<node-ip>] stop'
andrewonlabe8e56fd2014-10-09 17:12:44 -04001024 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -08001025 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001026 try:
kelvin8ec71442015-01-15 16:57:00 -08001027 self.handle.sendline( "" )
1028 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001029 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001030 " stop" )
1031 i = self.handle.expect( [
andrewonlab2b30bd32014-10-09 16:48:55 -04001032 "stop/waiting",
Jon Hall61282e32015-03-19 11:34:11 -07001033 "Could not resolve hostname",
andrewonlab2b30bd32014-10-09 16:48:55 -04001034 "Unknown\sinstance",
kelvin8ec71442015-01-15 16:57:00 -08001035 pexpect.TIMEOUT ], timeout=60 )
Jon Hall3b489db2015-10-05 14:38:37 -07001036 self.handle.expect( "\$" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001037 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001038 main.log.info( "ONOS service stopped" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001039 return main.TRUE
1040 elif i == 1:
Jon Hall65844a32015-03-09 19:09:37 -07001041 main.log.info( "onosStop() Unknown ONOS instance specified: " +
kelvin-onlabd3b64892015-01-20 13:26:24 -08001042 str( nodeIp ) )
andrewonlab2b30bd32014-10-09 16:48:55 -04001043 return main.FALSE
Jon Hall61282e32015-03-19 11:34:11 -07001044 elif i == 2:
1045 main.log.warn( "ONOS wasn't running" )
1046 return main.TRUE
andrewonlab2b30bd32014-10-09 16:48:55 -04001047 else:
kelvin8ec71442015-01-15 16:57:00 -08001048 main.log.error( "ONOS service failed to stop" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001049 return main.FALSE
andrewonlab2b30bd32014-10-09 16:48:55 -04001050 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001051 main.log.error( self.name + ": EOF exception found" )
1052 main.log.error( self.name + ": " + self.handle.before )
andrewonlab2b30bd32014-10-09 16:48:55 -04001053 main.cleanup()
1054 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001055 except Exception:
1056 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001057 main.cleanup()
1058 main.exit()
kelvin8ec71442015-01-15 16:57:00 -08001059
kelvin-onlabd3b64892015-01-20 13:26:24 -08001060 def onosUninstall( self, nodeIp="" ):
kelvin8ec71442015-01-15 16:57:00 -08001061 """
andrewonlabc8d47972014-10-09 16:52:36 -04001062 Calls the command: 'onos-uninstall'
kelvin8ec71442015-01-15 16:57:00 -08001063 Uninstalls ONOS from the designated cell machine, stopping
andrewonlabe8e56fd2014-10-09 17:12:44 -04001064 if needed
kelvin8ec71442015-01-15 16:57:00 -08001065 """
andrewonlabc8d47972014-10-09 16:52:36 -04001066 try:
kelvin8ec71442015-01-15 16:57:00 -08001067 self.handle.sendline( "" )
pingping-lin763ee042015-05-20 17:45:30 -07001068 self.handle.expect( "\$", timeout=60 )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001069 self.handle.sendline( "onos-uninstall " + str( nodeIp ) )
Jon Hall3b489db2015-10-05 14:38:37 -07001070 self.handle.expect( "\$", timeout=60 )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001071 main.log.info( "ONOS " + nodeIp + " was uninstalled" )
kelvin8ec71442015-01-15 16:57:00 -08001072 # onos-uninstall command does not return any text
andrewonlabc8d47972014-10-09 16:52:36 -04001073 return main.TRUE
pingping-lin763ee042015-05-20 17:45:30 -07001074 except pexpect.TIMEOUT:
1075 main.log.exception( self.name + ": Timeout in onosUninstall" )
1076 return main.FALSE
andrewonlabc8d47972014-10-09 16:52:36 -04001077 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001078 main.log.error( self.name + ": EOF exception found" )
1079 main.log.error( self.name + ": " + self.handle.before )
andrewonlabc8d47972014-10-09 16:52:36 -04001080 main.cleanup()
1081 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001082 except Exception:
1083 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabc8d47972014-10-09 16:52:36 -04001084 main.cleanup()
1085 main.exit()
andrewonlab2b30bd32014-10-09 16:48:55 -04001086
kelvin-onlabd3b64892015-01-20 13:26:24 -08001087 def onosDie( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001088 """
andrewonlabaedc8332014-12-04 12:43:03 -05001089 Issues the command 'onos-die <node-ip>'
1090 This command calls onos-kill and also stops the node
kelvin8ec71442015-01-15 16:57:00 -08001091 """
andrewonlabaedc8332014-12-04 12:43:03 -05001092 try:
kelvin8ec71442015-01-15 16:57:00 -08001093 self.handle.sendline( "" )
1094 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001095 cmdStr = "onos-kill " + str( nodeIp )
1096 self.handle.sendline( cmdStr )
kelvin8ec71442015-01-15 16:57:00 -08001097 i = self.handle.expect( [
andrewonlabaedc8332014-12-04 12:43:03 -05001098 "Killing\sONOS",
1099 "ONOS\sprocess\sis\snot\srunning",
kelvin8ec71442015-01-15 16:57:00 -08001100 pexpect.TIMEOUT ], timeout=20 )
andrewonlabaedc8332014-12-04 12:43:03 -05001101 if i == 0:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001102 main.log.info( "ONOS instance " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001103 " was killed and stopped" )
andrewonlabaedc8332014-12-04 12:43:03 -05001104 return main.TRUE
1105 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001106 main.log.info( "ONOS process was not running" )
andrewonlabaedc8332014-12-04 12:43:03 -05001107 return main.FALSE
1108 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001109 main.log.error( self.name + ": EOF exception found" )
1110 main.log.error( self.name + ": " + self.handle.before )
andrewonlabaedc8332014-12-04 12:43:03 -05001111 main.cleanup()
1112 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001113 except Exception:
1114 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabaedc8332014-12-04 12:43:03 -05001115 main.cleanup()
1116 main.exit()
1117
kelvin-onlabd3b64892015-01-20 13:26:24 -08001118 def onosKill( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001119 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001120 Calls the command: 'onos-kill [<node-ip>]'
1121 "Remotely, and unceremoniously kills the ONOS instance running on
1122 the specified cell machine" - Tom V
kelvin8ec71442015-01-15 16:57:00 -08001123 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001124 try:
kelvin8ec71442015-01-15 16:57:00 -08001125 self.handle.sendline( "" )
1126 self.handle.expect( "\$" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001127 self.handle.sendline( "onos-kill " + str( nodeIp ) )
kelvin8ec71442015-01-15 16:57:00 -08001128 i = self.handle.expect( [
andrewonlabe8e56fd2014-10-09 17:12:44 -04001129 "\$",
1130 "No\sroute\sto\shost",
1131 "password:",
kelvin8ec71442015-01-15 16:57:00 -08001132 pexpect.TIMEOUT ], timeout=20 )
1133
andrewonlabe8e56fd2014-10-09 17:12:44 -04001134 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001135 main.log.info(
1136 "ONOS instance " + str(
kelvin-onlabd3b64892015-01-20 13:26:24 -08001137 nodeIp ) + " was killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001138 return main.TRUE
1139 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001140 main.log.info( "No route to host" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001141 return main.FALSE
1142 elif i == 2:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001143 main.log.info(
1144 "Passwordless login for host: " +
1145 str( nodeIp ) +
1146 " not configured" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001147 return main.FALSE
1148 else:
Jon Hallefbd9792015-03-05 16:11:36 -08001149 main.log.info( "ONOS instance was not killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001150 return main.FALSE
kelvin8ec71442015-01-15 16:57:00 -08001151
andrewonlabe8e56fd2014-10-09 17:12:44 -04001152 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001153 main.log.error( self.name + ": EOF exception found" )
1154 main.log.error( self.name + ": " + self.handle.before )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001155 main.cleanup()
1156 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001157 except Exception:
1158 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001159 main.cleanup()
1160 main.exit()
1161
kelvin-onlabd3b64892015-01-20 13:26:24 -08001162 def onosRemoveRaftLogs( self ):
kelvin8ec71442015-01-15 16:57:00 -08001163 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001164 Removes Raft / Copy cat files from ONOS to ensure
Jon Hallfcc88622014-11-25 13:09:54 -05001165 a cleaner environment.
1166
andrewonlab19fbdca2014-11-14 12:55:59 -05001167 Description:
Jon Hallfcc88622014-11-25 13:09:54 -05001168 Stops all ONOS defined in the cell,
andrewonlab19fbdca2014-11-14 12:55:59 -05001169 wipes the raft / copycat log files
kelvin8ec71442015-01-15 16:57:00 -08001170 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001171 try:
kelvin8ec71442015-01-15 16:57:00 -08001172 self.handle.sendline( "" )
1173 self.handle.expect( "\$" )
1174 self.handle.sendline( "onos-remove-raft-logs" )
1175 # Sometimes this command hangs
1176 i = self.handle.expect( [ "\$", pexpect.TIMEOUT ],
1177 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001178 if i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001179 i = self.handle.expect( [ "\$", pexpect.TIMEOUT ],
1180 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001181 if i == 1:
1182 return main.FALSE
andrewonlab19fbdca2014-11-14 12:55:59 -05001183 return main.TRUE
andrewonlab19fbdca2014-11-14 12:55:59 -05001184 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001185 main.log.error( self.name + ": EOF exception found" )
1186 main.log.error( self.name + ": " + self.handle.before )
andrewonlab19fbdca2014-11-14 12:55:59 -05001187 main.cleanup()
1188 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001189 except Exception:
1190 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab19fbdca2014-11-14 12:55:59 -05001191 main.cleanup()
1192 main.exit()
Jon Hallfcc88622014-11-25 13:09:54 -05001193
kelvin-onlabd3b64892015-01-20 13:26:24 -08001194 def onosStartNetwork( self, mntopo ):
kelvin8ec71442015-01-15 16:57:00 -08001195 """
1196 Calls the command 'onos-start-network [ <mininet-topo> ]
1197 "remotely starts the specified topology on the cell's
andrewonlab94282092014-10-10 13:00:11 -04001198 mininet machine against all controllers configured in the
kelvin8ec71442015-01-15 16:57:00 -08001199 cell."
andrewonlab94282092014-10-10 13:00:11 -04001200 * Specify mininet topology file name for mntopo
1201 * Topo files should be placed at:
1202 ~/<your-onos-directory>/tools/test/topos
kelvin8ec71442015-01-15 16:57:00 -08001203
andrewonlab94282092014-10-10 13:00:11 -04001204 NOTE: This function will take you to the mininet prompt
kelvin8ec71442015-01-15 16:57:00 -08001205 """
andrewonlab94282092014-10-10 13:00:11 -04001206 try:
1207 if not mntopo:
kelvin8ec71442015-01-15 16:57:00 -08001208 main.log.error( "You must specify a topo file to execute" )
andrewonlab94282092014-10-10 13:00:11 -04001209 return main.FALSE
andrewonlab94282092014-10-10 13:00:11 -04001210
kelvin8ec71442015-01-15 16:57:00 -08001211 mntopo = str( mntopo )
1212 self.handle.sendline( "" )
1213 self.handle.expect( "\$" )
andrewonlab94282092014-10-10 13:00:11 -04001214
kelvin8ec71442015-01-15 16:57:00 -08001215 self.handle.sendline( "onos-start-network " + mntopo )
1216 self.handle.expect( "mininet>" )
1217 main.log.info( "Network started, entered mininet prompt" )
1218
1219 # TODO: Think about whether return is necessary or not
andrewonlab94282092014-10-10 13:00:11 -04001220
1221 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001222 main.log.error( self.name + ": EOF exception found" )
1223 main.log.error( self.name + ": " + self.handle.before )
andrewonlab94282092014-10-10 13:00:11 -04001224 main.cleanup()
1225 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001226 except Exception:
1227 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab94282092014-10-10 13:00:11 -04001228 main.cleanup()
1229 main.exit()
1230
Jon Hall3b489db2015-10-05 14:38:37 -07001231 def isup( self, node="", timeout=120 ):
kelvin8ec71442015-01-15 16:57:00 -08001232 """
1233 Run's onos-wait-for-start which only returns once ONOS is at run
Cameron Franke9c94fb02015-01-21 10:20:20 -08001234 level 100(ready for use)
andrewonlab8d0d7d72014-10-09 16:33:15 -04001235
Jon Hall7993bfc2014-10-09 16:30:14 -04001236 Returns: main.TRUE if ONOS is running and main.FALSE on timeout
kelvin8ec71442015-01-15 16:57:00 -08001237 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001238 try:
Jon Hall3b489db2015-10-05 14:38:37 -07001239 self.handle.sendline( "onos-wait-for-start " + node )
1240 self.handle.expect( "onos-wait-for-start" )
kelvin8ec71442015-01-15 16:57:00 -08001241 # NOTE: this timeout is arbitrary"
Cameron Franke9c94fb02015-01-21 10:20:20 -08001242 i = self.handle.expect(["\$", pexpect.TIMEOUT], timeout)
Jon Hall7993bfc2014-10-09 16:30:14 -04001243 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001244 main.log.info( self.name + ": " + node + " is up" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001245 return main.TRUE
1246 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001247 # NOTE: since this function won't return until ONOS is ready,
Jon Hall7993bfc2014-10-09 16:30:14 -04001248 # we will kill it on timeout
kelvin8ec71442015-01-15 16:57:00 -08001249 main.log.error( "ONOS has not started yet" )
1250 self.handle.send( "\x03" ) # Control-C
1251 self.handle.expect( "\$" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001252 return main.FALSE
1253 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001254 main.log.error( self.name + ": EOF exception found" )
1255 main.log.error( self.name + ": " + self.handle.before )
Jon Hall7993bfc2014-10-09 16:30:14 -04001256 main.cleanup()
1257 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001258 except Exception:
1259 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001260 main.cleanup()
1261 main.exit()
andrewonlab05e362f2014-10-10 00:40:57 -04001262
kelvin-onlabd3b64892015-01-20 13:26:24 -08001263 def pushTestIntentsShell(
1264 self,
1265 dpidSrc,
1266 dpidDst,
1267 numIntents,
1268 dirFile,
1269 onosIp,
1270 numMult="",
1271 appId="",
1272 report=True,
1273 options="" ):
kelvin8ec71442015-01-15 16:57:00 -08001274 """
andrewonlabb66dfa12014-12-02 15:51:10 -05001275 Description:
kelvin8ec71442015-01-15 16:57:00 -08001276 Use the linux prompt to push test intents to
andrewonlabb66dfa12014-12-02 15:51:10 -05001277 better parallelize the results than the CLI
1278 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001279 * dpidSrc: specify source dpid
1280 * dpidDst: specify destination dpid
1281 * numIntents: specify number of intents to push
1282 * dirFile: specify directory and file name to save
andrewonlabb66dfa12014-12-02 15:51:10 -05001283 results
kelvin-onlabd3b64892015-01-20 13:26:24 -08001284 * onosIp: specify the IP of ONOS to install on
kelvin8ec71442015-01-15 16:57:00 -08001285 NOTE:
andrewonlabb66dfa12014-12-02 15:51:10 -05001286 You must invoke this command at linux shell prompt
kelvin8ec71442015-01-15 16:57:00 -08001287 """
1288 try:
1289 # Create the string to sendline
andrewonlabaedc8332014-12-04 12:43:03 -05001290 if options:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001291 baseCmd = "onos " + str( onosIp ) + " push-test-intents " +\
kelvin8ec71442015-01-15 16:57:00 -08001292 options + " "
andrewonlabaedc8332014-12-04 12:43:03 -05001293 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001294 baseCmd = "onos " + str( onosIp ) + " push-test-intents "
kelvin8ec71442015-01-15 16:57:00 -08001295
kelvin-onlabd3b64892015-01-20 13:26:24 -08001296 addDpid = baseCmd + str( dpidSrc ) + " " + str( dpidDst )
1297 if not numMult:
1298 addIntents = addDpid + " " + str( numIntents )
1299 elif numMult:
1300 addIntents = addDpid + " " + str( numIntents ) + " " +\
1301 str( numMult )
1302 if appId:
1303 addApp = addIntents + " " + str( appId )
andrewonlabb66dfa12014-12-02 15:51:10 -05001304 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001305 addApp = addIntents
andrewonlabb66dfa12014-12-02 15:51:10 -05001306
andrewonlabaedc8332014-12-04 12:43:03 -05001307 if report:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001308 sendCmd = addApp + " > " + str( dirFile ) + " &"
andrewonlabaedc8332014-12-04 12:43:03 -05001309 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001310 sendCmd = addApp + " &"
1311 main.log.info( "Send cmd: " + sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001312
kelvin-onlabd3b64892015-01-20 13:26:24 -08001313 self.handle.sendline( sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001314
1315 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001316 main.log.error( self.name + ": EOF exception found" )
1317 main.log.error( self.name + ": " + self.handle.before )
andrewonlabb66dfa12014-12-02 15:51:10 -05001318 main.cleanup()
1319 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001320 except Exception:
1321 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlabb66dfa12014-12-02 15:51:10 -05001322 main.cleanup()
kelvin8ec71442015-01-15 16:57:00 -08001323 main.exit()
andrewonlab05e362f2014-10-10 00:40:57 -04001324
kelvin-onlabd3b64892015-01-20 13:26:24 -08001325 def getTopology( self, topologyOutput ):
kelvin8ec71442015-01-15 16:57:00 -08001326 """
Hari Krishnaef1bd4e2015-03-12 16:55:30 -07001327 Definition:
1328 Loads a json topology output
1329 Return:
1330 topology = current ONOS topology
kelvin8ec71442015-01-15 16:57:00 -08001331 """
Hari Krishnaef1bd4e2015-03-12 16:55:30 -07001332 import json
Jon Hall77f53ce2014-10-13 18:02:06 -04001333 try:
Hari Krishnaef1bd4e2015-03-12 16:55:30 -07001334 # either onos:topology or 'topology' will work in CLI
1335 topology = json.loads(topologyOutput)
1336 print topology
Jon Hall77f53ce2014-10-13 18:02:06 -04001337 return topology
1338 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001339 main.log.error( self.name + ": EOF exception found" )
1340 main.log.error( self.name + ": " + self.handle.before )
Jon Hall77f53ce2014-10-13 18:02:06 -04001341 main.cleanup()
1342 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001343 except Exception:
1344 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall77f53ce2014-10-13 18:02:06 -04001345 main.cleanup()
1346 main.exit()
1347
kelvin-onlabd3b64892015-01-20 13:26:24 -08001348 def checkStatus(
1349 self,
1350 topologyResult,
1351 numoswitch,
1352 numolink,
1353 logLevel="info" ):
kelvin8ec71442015-01-15 16:57:00 -08001354 """
Jon Hallefbd9792015-03-05 16:11:36 -08001355 Checks the number of switches & links that ONOS sees against the
kelvin8ec71442015-01-15 16:57:00 -08001356 supplied values. By default this will report to main.log, but the
Jon Hallefbd9792015-03-05 16:11:36 -08001357 log level can be specific.
kelvin8ec71442015-01-15 16:57:00 -08001358
Jon Hall77f53ce2014-10-13 18:02:06 -04001359 Params: ip = ip used for the onos cli
1360 numoswitch = expected number of switches
Jon Hallefbd9792015-03-05 16:11:36 -08001361 numolink = expected number of links
kelvin-onlabd3b64892015-01-20 13:26:24 -08001362 logLevel = level to log to.
1363 Currently accepts 'info', 'warn' and 'report'
Jon Hall77f53ce2014-10-13 18:02:06 -04001364
1365
kelvin-onlabd3b64892015-01-20 13:26:24 -08001366 logLevel can
Jon Hall77f53ce2014-10-13 18:02:06 -04001367
Jon Hallefbd9792015-03-05 16:11:36 -08001368 Returns: main.TRUE if the number of switches and links are correct,
1369 main.FALSE if the number of switches and links is incorrect,
Jon Hall77f53ce2014-10-13 18:02:06 -04001370 and main.ERROR otherwise
kelvin8ec71442015-01-15 16:57:00 -08001371 """
Jon Hall77f53ce2014-10-13 18:02:06 -04001372 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001373 topology = self.getTopology( topologyResult )
Jon Hall77f53ce2014-10-13 18:02:06 -04001374 if topology == {}:
1375 return main.ERROR
1376 output = ""
kelvin8ec71442015-01-15 16:57:00 -08001377 # Is the number of switches is what we expected
shahshreya234a1682015-05-27 15:41:56 -07001378 devices = topology.get( 'devices', False )
1379 links = topology.get( 'links', False )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001380 if not devices or not links:
Jon Hall77f53ce2014-10-13 18:02:06 -04001381 return main.ERROR
kelvin-onlabd3b64892015-01-20 13:26:24 -08001382 switchCheck = ( int( devices ) == int( numoswitch ) )
kelvin8ec71442015-01-15 16:57:00 -08001383 # Is the number of links is what we expected
kelvin-onlabd3b64892015-01-20 13:26:24 -08001384 linkCheck = ( int( links ) == int( numolink ) )
Jon Hallefbd9792015-03-05 16:11:36 -08001385 if switchCheck and linkCheck:
kelvin8ec71442015-01-15 16:57:00 -08001386 # We expected the correct numbers
Jon Hall77f53ce2014-10-13 18:02:06 -04001387 output = output + "The number of links and switches match "\
kelvin8ec71442015-01-15 16:57:00 -08001388 + "what was expected"
Jon Hall77f53ce2014-10-13 18:02:06 -04001389 result = main.TRUE
1390 else:
1391 output = output + \
Jon Hall274b6642015-02-17 11:57:17 -08001392 "The number of links and switches does not match " + \
1393 "what was expected"
Jon Hall77f53ce2014-10-13 18:02:06 -04001394 result = main.FALSE
Jon Hallefbd9792015-03-05 16:11:36 -08001395 output = output + "\n ONOS sees %i devices" % int( devices )
1396 output = output + " (%i expected) " % int( numoswitch )
Jon Hall274b6642015-02-17 11:57:17 -08001397 output = output + "and %i links " % int( links )
1398 output = output + "(%i expected)" % int( numolink )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001399 if logLevel == "report":
kelvin8ec71442015-01-15 16:57:00 -08001400 main.log.report( output )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001401 elif logLevel == "warn":
kelvin8ec71442015-01-15 16:57:00 -08001402 main.log.warn( output )
Jon Hall77f53ce2014-10-13 18:02:06 -04001403 else:
kelvin8ec71442015-01-15 16:57:00 -08001404 main.log.info( output )
1405 return result
Jon Hall77f53ce2014-10-13 18:02:06 -04001406 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001407 main.log.error( self.name + ": EOF exception found" )
1408 main.log.error( self.name + ": " + self.handle.before )
Jon Hall77f53ce2014-10-13 18:02:06 -04001409 main.cleanup()
1410 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001411 except Exception:
1412 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall77f53ce2014-10-13 18:02:06 -04001413 main.cleanup()
1414 main.exit()
andrewonlabba44bcf2014-10-16 16:54:41 -04001415
kelvin-onlabd3b64892015-01-20 13:26:24 -08001416 def tsharkPcap( self, interface, dirFile ):
kelvin8ec71442015-01-15 16:57:00 -08001417 """
andrewonlab970399c2014-11-07 13:09:32 -05001418 Capture all packet activity and store in specified
1419 directory/file
1420
1421 Required:
1422 * interface: interface to capture
1423 * dir: directory/filename to store pcap
kelvin8ec71442015-01-15 16:57:00 -08001424 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001425 try:
1426 self.handle.sendline( "" )
1427 self.handle.expect( "\$" )
andrewonlab970399c2014-11-07 13:09:32 -05001428
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001429 self.handle.sendline( "tshark -i " + str( interface ) + " -t e -w " + str( dirFile ) + " &" )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001430 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001431 self.handle.expect( "Capturing on" )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001432 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001433 self.handle.expect( "\$" )
andrewonlab970399c2014-11-07 13:09:32 -05001434
Jon Hallfebb1c72015-03-05 13:30:09 -08001435 main.log.info( "Tshark started capturing files on " +
1436 str( interface ) + " and saving to directory: " +
1437 str( dirFile ) )
1438 except pexpect.EOF:
1439 main.log.error( self.name + ": EOF exception found" )
1440 main.log.error( self.name + ": " + self.handle.before )
1441 main.cleanup()
1442 main.exit()
1443 except Exception:
1444 main.log.exception( self.name + ": Uncaught exception!" )
1445 main.cleanup()
1446 main.exit()
Shreya Shaha73aaad2014-10-27 18:03:09 -04001447
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001448 def onosTopoCfg( self, onosIp, jsonFile ):
kelvin8ec71442015-01-15 16:57:00 -08001449 """
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001450 Description:
1451 Execute onos-topo-cfg command
1452 Required:
1453 onosIp - IP of the onos node you want to send the json to
1454 jsonFile - File path of the json file
1455 Return:
1456 Returns main.TRUE if the command is successfull; Returns
1457 main.FALSE if there was an error
kelvin8ec71442015-01-15 16:57:00 -08001458 """
shahshreyae6c7cf42014-11-26 16:39:01 -08001459 try:
kelvin8ec71442015-01-15 16:57:00 -08001460 self.handle.sendline( "" )
1461 self.handle.expect( "\$" )
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001462 cmd = "onos-topo-cfg "
1463 self.handle.sendline( cmd + str( onosIp ) + " " + jsonFile )
1464 handle = self.handle.before
1465 print handle
1466 if "Error" in handle:
1467 main.log.error( self.name + ": " + self.handle.before )
1468 return main.FALSE
1469 else:
1470 self.handle.expect( "\$" )
1471 return main.TRUE
1472
Jon Hallfebb1c72015-03-05 13:30:09 -08001473 except pexpect.EOF:
1474 main.log.error( self.name + ": EOF exception found" )
1475 main.log.error( self.name + ": " + self.handle.before )
1476 main.cleanup()
1477 main.exit()
1478 except Exception:
1479 main.log.exception( self.name + ": Uncaught exception!" )
1480 main.cleanup()
1481 main.exit()
kelvin8ec71442015-01-15 16:57:00 -08001482
jenkins1e99e7b2015-04-02 18:15:39 -07001483 def tsharkGrep( self, grep, directory, interface='eth0', grepOptions='' ):
kelvin8ec71442015-01-15 16:57:00 -08001484 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001485 Required:
kelvin8ec71442015-01-15 16:57:00 -08001486 * grep string
andrewonlabba44bcf2014-10-16 16:54:41 -04001487 * directory to store results
1488 Optional:
1489 * interface - default: eth0
Jon Hall4ba53f02015-07-29 13:07:41 -07001490 * grepOptions - options for grep
andrewonlabba44bcf2014-10-16 16:54:41 -04001491 Description:
1492 Uses tshark command to grep specific group of packets
1493 and stores the results to specified directory.
kelvin8ec71442015-01-15 16:57:00 -08001494 The timestamp is hardcoded to be in epoch
1495 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001496 try:
1497 self.handle.sendline( "" )
1498 self.handle.expect( "\$" )
1499 self.handle.sendline( "" )
jenkins1e99e7b2015-04-02 18:15:39 -07001500 if grepOptions:
1501 grepStr = "grep "+str(grepOptions)
1502 else:
1503 grepStr = "grep"
Jon Hall4ba53f02015-07-29 13:07:41 -07001504
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001505 cmd = (
1506 "sudo tshark -i " +
Jon Hallfebb1c72015-03-05 13:30:09 -08001507 str( interface ) +
jenkins1e99e7b2015-04-02 18:15:39 -07001508 " -t e | " +
1509 grepStr + " --line-buffered \"" +
Jon Hallfebb1c72015-03-05 13:30:09 -08001510 str(grep) +
1511 "\" >" +
1512 directory +
1513 " &" )
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001514 self.handle.sendline(cmd)
1515 main.log.info(cmd)
Jon Hallfebb1c72015-03-05 13:30:09 -08001516 self.handle.expect( "Capturing on" )
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001517 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001518 self.handle.expect( "\$" )
1519 except pexpect.EOF:
1520 main.log.error( self.name + ": EOF exception found" )
1521 main.log.error( self.name + ": " + self.handle.before )
1522 main.cleanup()
1523 main.exit()
1524 except Exception:
1525 main.log.exception( self.name + ": Uncaught exception!" )
1526 main.cleanup()
1527 main.exit()
1528
kelvin-onlabd3b64892015-01-20 13:26:24 -08001529 def tsharkStop( self ):
kelvin8ec71442015-01-15 16:57:00 -08001530 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001531 Removes wireshark files from /tmp and kills all tshark processes
kelvin8ec71442015-01-15 16:57:00 -08001532 """
1533 # Remove all pcap from previous captures
Jon Hallfebb1c72015-03-05 13:30:09 -08001534 try:
1535 self.execute( cmd="sudo rm /tmp/wireshark*" )
1536 self.handle.sendline( "" )
Jon Hallefbd9792015-03-05 16:11:36 -08001537 self.handle.sendline( "sudo kill -9 `ps -ef | grep \"tshark -i\"" +
1538 " | grep -v grep | awk '{print $2}'`" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001539 self.handle.sendline( "" )
1540 main.log.info( "Tshark stopped" )
1541 except pexpect.EOF:
1542 main.log.error( self.name + ": EOF exception found" )
1543 main.log.error( self.name + ": " + self.handle.before )
1544 main.cleanup()
1545 main.exit()
1546 except Exception:
1547 main.log.exception( self.name + ": Uncaught exception!" )
1548 main.cleanup()
1549 main.exit()
1550
kelvin8ec71442015-01-15 16:57:00 -08001551 def ptpd( self, args ):
1552 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001553 Initiate ptp with user-specified args.
1554 Required:
1555 * args: specify string of args after command
1556 'sudo ptpd'
kelvin8ec71442015-01-15 16:57:00 -08001557 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001558 try:
kelvin8ec71442015-01-15 16:57:00 -08001559 self.handle.sendline( "sudo ptpd " + str( args ) )
1560 i = self.handle.expect( [
andrewonlab0c38a4a2014-10-28 18:35:35 -04001561 "Multiple",
1562 "Error",
kelvin8ec71442015-01-15 16:57:00 -08001563 "\$" ] )
1564 self.handle.expect( "\$" )
andrewonlabba44bcf2014-10-16 16:54:41 -04001565
andrewonlab0c38a4a2014-10-28 18:35:35 -04001566 if i == 0:
1567 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001568 main.log.info( "ptpd returned an error: " +
1569 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001570 return handle
1571 elif i == 1:
1572 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001573 main.log.error( "ptpd returned an error: " +
1574 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001575 return handle
1576 else:
1577 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -08001578
andrewonlab0c38a4a2014-10-28 18:35:35 -04001579 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001580 main.log.error( self.name + ": EOF exception found" )
1581 main.log.error( self.name + ": " + self.handle.before )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001582 main.cleanup()
1583 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001584 except Exception:
1585 main.log.exception( self.name + ": Uncaught exception!" )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001586 main.cleanup()
1587 main.exit()
andrewonlabba44bcf2014-10-16 16:54:41 -04001588
kelvin-onlabd3b64892015-01-20 13:26:24 -08001589 def cpLogsToDir( self, logToCopy,
Jon Hallefbd9792015-03-05 16:11:36 -08001590 destDir, copyFileName="" ):
kelvin8ec71442015-01-15 16:57:00 -08001591 """
1592 Copies logs to a desired directory.
andrewonlab5d7a8f32014-11-10 13:07:56 -05001593 Current implementation of ONOS deletes its karaf
1594 logs on every iteration. For debugging purposes,
kelvin8ec71442015-01-15 16:57:00 -08001595 you may want to use this function to capture
1596 certain karaf logs. ( or any other logs if needed )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001597 Localtime will be attached to the filename
1598
1599 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001600 * logToCopy: specify directory and log name to
andrewonlab5d7a8f32014-11-10 13:07:56 -05001601 copy.
kelvin8ec71442015-01-15 16:57:00 -08001602 ex ) /opt/onos/log/karaf.log.1
kelvin-onlabd3b64892015-01-20 13:26:24 -08001603 For copying multiple files, leave copyFileName
1604 empty and only specify destDir -
kelvin8ec71442015-01-15 16:57:00 -08001605 ex ) /opt/onos/log/karaf*
kelvin-onlabd3b64892015-01-20 13:26:24 -08001606 * destDir: specify directory to copy to.
kelvin8ec71442015-01-15 16:57:00 -08001607 ex ) /tmp/
1608 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001609 * copyFileName: If you want to rename the log
1610 file, specify copyFileName. This will not work
andrewonlab5d7a8f32014-11-10 13:07:56 -05001611 with multiple file copying
kelvin8ec71442015-01-15 16:57:00 -08001612 """
andrewonlab5d7a8f32014-11-10 13:07:56 -05001613 try:
kelvin8ec71442015-01-15 16:57:00 -08001614 localtime = time.strftime( '%x %X' )
1615 localtime = localtime.replace( "/", "" )
1616 localtime = localtime.replace( " ", "_" )
1617 localtime = localtime.replace( ":", "" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001618 if destDir[ -1: ] != "/":
1619 destDir += "/"
andrewonlab5d7a8f32014-11-10 13:07:56 -05001620
kelvin-onlabd3b64892015-01-20 13:26:24 -08001621 if copyFileName:
Jon Hallfebb1c72015-03-05 13:30:09 -08001622 self.handle.sendline( "cp " + str( logToCopy ) + " " +
1623 str( destDir ) + str( copyFileName ) +
1624 localtime )
kelvin8ec71442015-01-15 16:57:00 -08001625 self.handle.expect( "cp" )
1626 self.handle.expect( "\$" )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001627 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001628 self.handle.sendline( "cp " + str( logToCopy ) +
1629 " " + str( destDir ) )
kelvin8ec71442015-01-15 16:57:00 -08001630 self.handle.expect( "cp" )
1631 self.handle.expect( "\$" )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001632
kelvin8ec71442015-01-15 16:57:00 -08001633 return self.handle.before
1634
1635 except pexpect.EOF:
1636 main.log.error( "Copying files failed" )
1637 main.log.error( self.name + ": EOF exception found" )
1638 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001639 except Exception:
1640 main.log.exception( "Copying files failed" )
1641
Jon Hall16b72c42015-05-20 10:23:36 -07001642 def checkLogs( self, onosIp, restart=False):
kelvin8ec71442015-01-15 16:57:00 -08001643 """
Jon Hall94fd0472014-12-08 11:52:42 -08001644 runs onos-check-logs on the given onos node
Jon Hall80daded2015-05-27 16:07:00 -07001645 If restart is True, use the old version of onos-check-logs which
1646 does not print the full stacktrace, but shows the entire log file,
1647 including across restarts
Jon Hall94fd0472014-12-08 11:52:42 -08001648 returns the response
kelvin8ec71442015-01-15 16:57:00 -08001649 """
Jon Hall94fd0472014-12-08 11:52:42 -08001650 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001651 cmd = "onos-check-logs " + str( onosIp )
Jon Hall16b72c42015-05-20 10:23:36 -07001652 if restart:
1653 cmd += " old"
kelvin8ec71442015-01-15 16:57:00 -08001654 self.handle.sendline( cmd )
1655 self.handle.expect( cmd )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001656 self.handle.expect( "\$ " )
Jon Hall94fd0472014-12-08 11:52:42 -08001657 response = self.handle.before
1658 return response
1659 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001660 main.log.error( "Lost ssh connection" )
1661 main.log.error( self.name + ": EOF exception found" )
1662 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001663 except Exception:
1664 main.log.exception( self.name + ": Uncaught exception!" )
1665 main.cleanup()
1666 main.exit()
Jon Hall94fd0472014-12-08 11:52:42 -08001667
kelvin-onlabd3b64892015-01-20 13:26:24 -08001668 def onosStatus( self, node="" ):
kelvin8ec71442015-01-15 16:57:00 -08001669 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001670 Calls onos command: 'onos-service [<node-ip>] status'
kelvin8ec71442015-01-15 16:57:00 -08001671 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001672 try:
kelvin8ec71442015-01-15 16:57:00 -08001673 self.handle.sendline( "" )
1674 self.handle.expect( "\$" )
1675 self.handle.sendline( "onos-service " + str( node ) +
1676 " status" )
1677 i = self.handle.expect( [
You Wang7bd83062016-03-01 11:50:00 -08001678 "Running ...",
1679 "Not Running ...",
kelvin8ec71442015-01-15 16:57:00 -08001680 pexpect.TIMEOUT ], timeout=120 )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001681
1682 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001683 main.log.info( "ONOS is running" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001684 return main.TRUE
1685 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001686 main.log.info( "ONOS is stopped" )
kelvin8ec71442015-01-15 16:57:00 -08001687 main.log.error( "ONOS service failed to check the status" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001688 main.cleanup()
1689 main.exit()
1690 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001691 main.log.error( self.name + ": EOF exception found" )
1692 main.log.error( self.name + ": " + self.handle.before )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001693 main.cleanup()
1694 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001695 except Exception:
1696 main.log.exception( self.name + ": Uncaught exception!" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001697 main.cleanup()
1698 main.exit()
Jon Hall21270ac2015-02-16 17:59:55 -08001699
Jon Hall63604932015-02-26 17:09:50 -08001700 def setIpTables( self, ip, port='', action='add', packet_type='',
1701 direction='INPUT', rule='DROP', states=True ):
Jon Hallefbd9792015-03-05 16:11:36 -08001702 """
Jon Hall21270ac2015-02-16 17:59:55 -08001703 Description:
1704 add or remove iptables rule to DROP (default) packets from
1705 specific IP and PORT
1706 Usage:
1707 * specify action ('add' or 'remove')
1708 when removing, pass in the same argument as you would add. It will
1709 delete that specific rule.
1710 * specify the ip to block
1711 * specify the destination port to block (defaults to all ports)
1712 * optional packet type to block (default tcp)
1713 * optional iptables rule (default DROP)
1714 * optional direction to block (default 'INPUT')
Jon Hall63604932015-02-26 17:09:50 -08001715 * States boolean toggles adding all supported tcp states to the
1716 firewall rule
Jon Hall21270ac2015-02-16 17:59:55 -08001717 Returns:
1718 main.TRUE on success or
1719 main.FALSE if given invalid input or
1720 main.ERROR if there is an error in response from iptables
1721 WARNING:
1722 * This function uses root privilege iptables command which may result
1723 in unwanted network errors. USE WITH CAUTION
Jon Hallefbd9792015-03-05 16:11:36 -08001724 """
Jon Hall21270ac2015-02-16 17:59:55 -08001725
1726 # NOTE*********
1727 # The strict checking methods of this driver function is intentional
1728 # to discourage any misuse or error of iptables, which can cause
1729 # severe network errors
1730 # *************
1731
1732 # NOTE: Sleep needed to give some time for rule to be added and
1733 # registered to the instance. If you are calling this function
1734 # multiple times this sleep will prevent any errors.
1735 # DO NOT REMOVE
Jon Hall63604932015-02-26 17:09:50 -08001736 # time.sleep( 5 )
Jon Hall21270ac2015-02-16 17:59:55 -08001737 try:
1738 # input validation
1739 action_type = action.lower()
1740 rule = rule.upper()
1741 direction = direction.upper()
1742 if action_type != 'add' and action_type != 'remove':
1743 main.log.error( "Invalid action type. Use 'add' or "
1744 "'remove' table rule" )
1745 if rule != 'DROP' and rule != 'ACCEPT' and rule != 'LOG':
1746 # NOTE Currently only supports rules DROP, ACCEPT, and LOG
1747 main.log.error( "Invalid rule. Valid rules are 'DROP' or "
1748 "'ACCEPT' or 'LOG' only." )
1749 if direction != 'INPUT' and direction != 'OUTPUT':
1750 # NOTE currently only supports rules INPUT and OUPTUT
1751 main.log.error( "Invalid rule. Valid directions are"
1752 " 'OUTPUT' or 'INPUT'" )
1753 return main.FALSE
1754 return main.FALSE
1755 return main.FALSE
1756 if action_type == 'add':
1757 # -A is the 'append' action of iptables
1758 actionFlag = '-A'
1759 elif action_type == 'remove':
1760 # -D is the 'delete' rule of iptables
1761 actionFlag = '-D'
1762 self.handle.sendline( "" )
1763 self.handle.expect( "\$" )
1764 cmd = "sudo iptables " + actionFlag + " " +\
1765 direction +\
Jon Hall21270ac2015-02-16 17:59:55 -08001766 " -s " + str( ip )
Jon Hall63604932015-02-26 17:09:50 -08001767 # " -p " + str( packet_type ) +\
1768 if packet_type:
1769 cmd += " -p " + str( packet_type )
Jon Hall21270ac2015-02-16 17:59:55 -08001770 if port:
1771 cmd += " --dport " + str( port )
Jon Hall63604932015-02-26 17:09:50 -08001772 if states:
1773 cmd += " -m state --state="
1774 #FIXME- Allow user to configure which states to block
1775 cmd += "INVALID,ESTABLISHED,NEW,RELATED,UNTRACKED"
Jon Hall21270ac2015-02-16 17:59:55 -08001776 cmd += " -j " + str( rule )
1777
1778 self.handle.sendline( cmd )
1779 self.handle.expect( "\$" )
1780 main.log.warn( self.handle.before )
1781
1782 info_string = "On " + str( self.name )
1783 info_string += " " + str( action_type )
1784 info_string += " iptable rule [ "
1785 info_string += " IP: " + str( ip )
1786 info_string += " Port: " + str( port )
1787 info_string += " Rule: " + str( rule )
1788 info_string += " Direction: " + str( direction ) + " ]"
1789 main.log.info( info_string )
1790 return main.TRUE
1791 except pexpect.TIMEOUT:
1792 main.log.exception( self.name + ": Timeout exception in "
1793 "setIpTables function" )
1794 return main.ERROR
1795 except pexpect.EOF:
1796 main.log.error( self.name + ": EOF exception found" )
1797 main.log.error( self.name + ": " + self.handle.before )
1798 main.cleanup()
1799 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001800 except Exception:
1801 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall21270ac2015-02-16 17:59:55 -08001802 main.cleanup()
1803 main.exit()
1804
Jon Hall0468b042015-02-19 19:08:21 -08001805 def detailed_status(self, log_filename):
Jon Hallefbd9792015-03-05 16:11:36 -08001806 """
Jon Hall0468b042015-02-19 19:08:21 -08001807 This method is used by STS to check the status of the controller
1808 Reports RUNNING, STARTING, STOPPED, FROZEN, ERROR (and reason)
Jon Hallefbd9792015-03-05 16:11:36 -08001809 """
Jon Hall0468b042015-02-19 19:08:21 -08001810 import re
1811 try:
1812 self.handle.sendline( "" )
1813 self.handle.expect( "\$" )
1814 self.handle.sendline( "cd " + self.home )
1815 self.handle.expect( "\$" )
1816 self.handle.sendline( "service onos status" )
1817 self.handle.expect( "\$" )
1818 response = self.handle.before
1819 if re.search( "onos start/running", response ):
1820 # onos start/running, process 10457
1821 return 'RUNNING'
1822 # FIXME: Implement this case
1823 # elif re.search( pattern, response ):
1824 # return 'STARTING'
1825 elif re.search( "onos stop/", response ):
1826 # onos stop/waiting
1827 # FIXME handle this differently?: onos stop/pre-stop
1828 return 'STOPPED'
1829 # FIXME: Implement this case
1830 # elif re.search( pattern, response ):
1831 # return 'FROZEN'
1832 else:
1833 main.log.warn( self.name +
Jon Hallefbd9792015-03-05 16:11:36 -08001834 " WARNING: status received unknown response" )
Jon Hall0468b042015-02-19 19:08:21 -08001835 main.log.warn( response )
1836 return 'ERROR', "Unknown response: %s" % response
1837 except pexpect.TIMEOUT:
1838 main.log.exception( self.name + ": Timeout exception in "
1839 "setIpTables function" )
1840 return 'ERROR', "Pexpect Timeout"
1841 except pexpect.EOF:
1842 main.log.error( self.name + ": EOF exception found" )
1843 main.log.error( self.name + ": " + self.handle.before )
1844 main.cleanup()
1845 main.exit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001846 except Exception:
1847 main.log.exception( self.name + ": Uncaught exception!" )
Jon Hall0468b042015-02-19 19:08:21 -08001848 main.cleanup()
1849 main.exit()
1850
andrew@onlab.us3b087132015-03-11 15:00:08 -07001851 def createLinkGraphFile( self, benchIp, ONOSIpList, deviceCount):
1852 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07001853 Create/formats the LinkGraph.cfg file based on arguments
1854 -only creates a linear topology and connects islands
1855 -evenly distributes devices
andrew@onlab.us3b087132015-03-11 15:00:08 -07001856 -must be called by ONOSbench
1857
Jon Hall4ba53f02015-07-29 13:07:41 -07001858 ONOSIpList - list of all of the node IPs to be used
1859
1860 deviceCount - number of switches to be assigned
andrew@onlab.us3b087132015-03-11 15:00:08 -07001861 '''
1862 main.log.step("Creating link graph configuration file." )
1863 linkGraphPath = self.home + "/tools/package/etc/linkGraph.cfg"
Jon Hall4ba53f02015-07-29 13:07:41 -07001864 tempFile = "/tmp/linkGraph.cfg"
andrew@onlab.us3b087132015-03-11 15:00:08 -07001865
1866 linkGraph = open(tempFile, 'w+')
1867 linkGraph.write("# NullLinkProvider topology description (config file).\n")
1868 linkGraph.write("# The NodeId is only added if the destination is another node's device.\n")
1869 linkGraph.write("# Bugs: Comments cannot be appended to a line to be read.\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07001870
andrew@onlab.us3b087132015-03-11 15:00:08 -07001871 clusterCount = len(ONOSIpList)
Jon Hall4ba53f02015-07-29 13:07:41 -07001872
1873 if type(deviceCount) is int or type(deviceCount) is str:
andrew@onlab.us3b087132015-03-11 15:00:08 -07001874 deviceCount = int(deviceCount)
1875 switchList = [0]*(clusterCount+1)
1876 baselineSwitchCount = deviceCount/clusterCount
Jon Hall4ba53f02015-07-29 13:07:41 -07001877
andrew@onlab.us3b087132015-03-11 15:00:08 -07001878 for node in range(1, clusterCount + 1):
1879 switchList[node] = baselineSwitchCount
1880
1881 for node in range(1, (deviceCount%clusterCount)+1):
1882 switchList[node] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001883
andrew@onlab.us3b087132015-03-11 15:00:08 -07001884 if type(deviceCount) is list:
1885 main.log.info("Using provided device distribution")
1886 switchList = [0]
1887 for i in deviceCount:
1888 switchList.append(int(i))
1889
1890 tempList = ['0']
1891 tempList.extend(ONOSIpList)
1892 ONOSIpList = tempList
1893
1894 myPort = 6
1895 lastSwitch = 0
1896 for node in range(1, clusterCount+1):
1897 if switchList[node] == 0:
1898 continue
1899
1900 linkGraph.write("graph " + ONOSIpList[node] + " {\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07001901
andrew@onlab.us3b087132015-03-11 15:00:08 -07001902 if node > 1:
1903 #connect to last device on previous node
Jon Hall4ba53f02015-07-29 13:07:41 -07001904 line = ("\t0:5 -> " + str(lastSwitch) + ":6:" + lastIp + "\n") #ONOSIpList[node-1]
1905 linkGraph.write(line)
1906
1907 lastSwitch = 0
1908 for switch in range (0, switchList[node]-1):
andrew@onlab.us3b087132015-03-11 15:00:08 -07001909 line = ""
1910 line = ("\t" + str(switch) + ":" + str(myPort))
1911 line += " -- "
1912 line += (str(switch+1) + ":" + str(myPort-1) + "\n")
1913 linkGraph.write(line)
Jon Hall4ba53f02015-07-29 13:07:41 -07001914 lastSwitch = switch+1
andrew@onlab.us3b087132015-03-11 15:00:08 -07001915 lastIp = ONOSIpList[node]
Jon Hall4ba53f02015-07-29 13:07:41 -07001916
andrew@onlab.us3b087132015-03-11 15:00:08 -07001917 #lastSwitch += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001918 if node < (clusterCount):
andrew@onlab.us3b087132015-03-11 15:00:08 -07001919 #connect to first device on the next node
Jon Hall4ba53f02015-07-29 13:07:41 -07001920 line = ("\t" + str(lastSwitch) + ":6 -> 0:5:" + ONOSIpList[node+1] + "\n")
andrew@onlab.us3b087132015-03-11 15:00:08 -07001921 linkGraph.write(line)
Jon Hall4ba53f02015-07-29 13:07:41 -07001922
andrew@onlab.us3b087132015-03-11 15:00:08 -07001923 linkGraph.write("}\n")
1924 linkGraph.close()
1925
1926 #SCP
Jon Hall4ba53f02015-07-29 13:07:41 -07001927 os.system( "scp " + tempFile + " " + self.user_name + "@" + benchIp + ":" + linkGraphPath)
andrew@onlab.us3b087132015-03-11 15:00:08 -07001928 main.log.info("linkGraph.cfg creation complete")
1929
cameron@onlab.us75900962015-03-30 13:22:49 -07001930 def configNullDev( self, ONOSIpList, deviceCount, numPorts=10):
Jon Hall4ba53f02015-07-29 13:07:41 -07001931
andrew@onlab.us3b087132015-03-11 15:00:08 -07001932 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07001933 ONOSIpList = list of Ip addresses of nodes switches will be devided amongst
1934 deviceCount = number of switches to distribute, or list of values to use as custom distribution
cameron@onlab.us75900962015-03-30 13:22:49 -07001935 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 -07001936 '''
1937
cameron@onlab.us75900962015-03-30 13:22:49 -07001938 main.log.step("Configuring Null Device Provider" )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001939 clusterCount = len(ONOSIpList)
1940
Jon Hall4ba53f02015-07-29 13:07:41 -07001941 try:
1942
cameron@onlab.us75900962015-03-30 13:22:49 -07001943 if type(deviceCount) is int or type(deviceCount) is str:
1944 main.log.step("Creating device distribution")
1945 deviceCount = int(deviceCount)
1946 switchList = [0]*(clusterCount+1)
1947 baselineSwitchCount = deviceCount/clusterCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001948
cameron@onlab.us75900962015-03-30 13:22:49 -07001949 for node in range(1, clusterCount + 1):
1950 switchList[node] = baselineSwitchCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001951
cameron@onlab.us75900962015-03-30 13:22:49 -07001952 for node in range(1, (deviceCount%clusterCount)+1):
1953 switchList[node] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001954
1955 if type(deviceCount) is list:
1956 main.log.info("Using provided device distribution")
1957
1958 if len(deviceCount) == clusterCount:
cameron@onlab.us75900962015-03-30 13:22:49 -07001959 switchList = ['0']
1960 switchList.extend(deviceCount)
Jon Hall4ba53f02015-07-29 13:07:41 -07001961
1962 if len(deviceCount) == (clusterCount + 1):
1963 if deviceCount[0] == '0' or deviceCount[0] == 0:
cameron@onlab.us75900962015-03-30 13:22:49 -07001964 switchList = deviceCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001965
cameron@onlab.us75900962015-03-30 13:22:49 -07001966 assert len(switchList) == (clusterCount + 1)
Jon Hall4ba53f02015-07-29 13:07:41 -07001967
cameron@onlab.us75900962015-03-30 13:22:49 -07001968 except AssertionError:
Jon Hall4ba53f02015-07-29 13:07:41 -07001969 main.log.error( "Bad device/Ip list match")
cameron@onlab.us75900962015-03-30 13:22:49 -07001970 except TypeError:
1971 main.log.exception( self.name + ": Object not as expected" )
1972 return None
Jon Hall77ba41c2015-04-06 10:25:40 -07001973 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07001974 main.log.exception( self.name + ": Uncaught exception!" )
1975 main.cleanup()
1976 main.exit()
1977
andrew@onlab.us3b087132015-03-11 15:00:08 -07001978
1979 ONOSIp = [0]
1980 ONOSIp.extend(ONOSIpList)
Jon Hall4ba53f02015-07-29 13:07:41 -07001981
andrew@onlab.us3b087132015-03-11 15:00:08 -07001982 devicesString = "devConfigs = "
1983 for node in range(1, len(ONOSIp)):
1984 devicesString += (ONOSIp[node] + ":" + str(switchList[node] ))
1985 if node < clusterCount:
1986 devicesString += (",")
Jon Hall4ba53f02015-07-29 13:07:41 -07001987
1988 try:
cameron@onlab.us75900962015-03-30 13:22:49 -07001989 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider devConfigs " + devicesString )
1990 self.handle.expect(":~")
1991 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider numPorts " + str(numPorts) )
1992 self.handle.expect(":~")
andrew@onlab.us3b087132015-03-11 15:00:08 -07001993
cameron@onlab.us75900962015-03-30 13:22:49 -07001994 for i in range(10):
1995 self.handle.sendline("onos $OC1 cfg get org.onosproject.provider.nil.device.impl.NullDeviceProvider")
1996 self.handle.expect(":~")
1997 verification = self.handle.before
1998 if (" value=" + str(numPorts)) in verification and (" value=" + devicesString) in verification:
1999 break
2000 else:
2001 time.sleep(1)
andrew@onlab.us3b087132015-03-11 15:00:08 -07002002
cameron@onlab.us2cc8bf12015-04-02 14:12:30 -07002003 assert ("value=" + str(numPorts)) in verification and (" value=" + devicesString) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002004
cameron@onlab.us75900962015-03-30 13:22:49 -07002005 except AssertionError:
2006 main.log.error("Incorrect Config settings: " + verification)
Jon Hall77ba41c2015-04-06 10:25:40 -07002007 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002008 main.log.exception( self.name + ": Uncaught exception!" )
2009 main.cleanup()
2010 main.exit()
2011
Jon Hall4ba53f02015-07-29 13:07:41 -07002012 def configNullLink( self,fileName="/opt/onos/apache-karaf-3.0.3/etc/linkGraph.cfg", eventRate=0):
andrew@onlab.us3b087132015-03-11 15:00:08 -07002013 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07002014 fileName default is currently the same as the default on ONOS, specify alternate file if
cameron@onlab.us75900962015-03-30 13:22:49 -07002015 you want to use a different topology file than linkGraph.cfg
andrew@onlab.us3b087132015-03-11 15:00:08 -07002016 '''
2017
Jon Hall4ba53f02015-07-29 13:07:41 -07002018
2019 try:
2020 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider eventRate " + str(eventRate))
2021 self.handle.expect(":~")
cameron@onlab.us75900962015-03-30 13:22:49 -07002022 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider cfgFile " + fileName )
2023 self.handle.expect(":~")
Jon Hall4ba53f02015-07-29 13:07:41 -07002024
2025 for i in range(10):
2026 self.handle.sendline("onos $OC1 cfg get org.onosproject.provider.nil.link.impl.NullLinkProvider")
cameron@onlab.us75900962015-03-30 13:22:49 -07002027 self.handle.expect(":~")
2028 verification = self.handle.before
Jon Hall4ba53f02015-07-29 13:07:41 -07002029 if (" value=" + str(eventRate)) in verification and (" value=" + fileName) in verification:
cameron@onlab.us75900962015-03-30 13:22:49 -07002030 break
Jon Hall4ba53f02015-07-29 13:07:41 -07002031 else:
cameron@onlab.us75900962015-03-30 13:22:49 -07002032 time.sleep(1)
Jon Hall4ba53f02015-07-29 13:07:41 -07002033
cameron@onlab.us75900962015-03-30 13:22:49 -07002034 assert ("value=" + str(eventRate)) in verification and (" value=" + fileName) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002035
cameron@onlab.us75900962015-03-30 13:22:49 -07002036 except pexpect.EOF:
2037 main.log.error( self.name + ": EOF exception found" )
2038 main.log.error( self.name + ": " + self.handle.before )
2039 main.cleanup()
2040 main.exit()
cameron@onlab.us75900962015-03-30 13:22:49 -07002041 except AssertionError:
2042 main.log.info("Settings did not post to ONOS")
Jon Hall4ba53f02015-07-29 13:07:41 -07002043 main.log.error(varification)
Jon Hall77ba41c2015-04-06 10:25:40 -07002044 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002045 main.log.exception( self.name + ": Uncaught exception!" )
2046 main.log.error(varification)
2047 main.cleanup()
2048 main.exit()
andrew@onlab.us3b087132015-03-11 15:00:08 -07002049
kelvin-onlaba4074292015-07-09 15:19:49 -07002050 def getOnosIps( self ):
2051 """
2052 Get all onos IPs stored in
2053 """
cameron@onlab.us59d29d92015-05-11 14:31:54 -07002054
kelvin-onlaba4074292015-07-09 15:19:49 -07002055 return sorted( self.onosIps.values() )
cameron@onlab.us59d29d92015-05-11 14:31:54 -07002056
kelvin-onlaba4074292015-07-09 15:19:49 -07002057 def logReport( self, nodeIp, searchTerms, outputMode="s" ):
Jon Hallb4242222016-01-25 17:07:04 -08002058 """
2059 Searches the latest ONOS log file for the given search terms and
2060 prints the total occurances of each term. Returns to combined total of
2061 all occurances.
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002062
Jon Hallb4242222016-01-25 17:07:04 -08002063 Arguments:
2064 * nodeIp - The ip of the ONOS node where the log is located
2065 * searchTerms - A string to grep for or a list of strings to grep
2066 for in the ONOS log. Will print out the number of
2067 occurances for each term.
2068 Optional Arguments:
2069 * outputMode - 's' or 'd'. If 'd' will print the last 5 lines
2070 containing each search term as well as the total
2071 number of occurances of each term. Defaults to 's',
2072 which prints the simple output of just the number
2073 of occurances for each term.
2074 """
2075 try:
2076 main.log.info( " Log Report for {} ".format( nodeIp ).center( 70, '=' ) )
2077 if type( searchTerms ) is str:
2078 searchTerms = [searchTerms]
2079 numTerms = len( searchTerms )
2080 outputMode = outputMode.lower()
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002081
Jon Hallb4242222016-01-25 17:07:04 -08002082 totalHits = 0
2083 logLines = []
2084 for termIndex in range( numTerms ):
2085 term = searchTerms[termIndex]
2086 logLines.append( [term] )
2087 cmd = "onos-ssh " + nodeIp + " cat /opt/onos/log/karaf.log | grep " + term
2088 self.handle.sendline( cmd )
2089 self.handle.expect( ":~" )
2090 before = self.handle.before.splitlines()
2091 count = 0
2092 for line in before:
2093 if term in line and "grep" not in line:
2094 count += 1
2095 if before.index( line ) > ( len( before ) - 7 ):
2096 logLines[termIndex].append( line )
2097 main.log.info( "{}: {}".format( term, count ) )
2098 totalHits += count
2099 if termIndex == numTerms - 1:
2100 print "\n"
2101 if outputMode != "s":
2102 outputString = ""
2103 for term in logLines:
2104 outputString = term[0] + ": \n"
2105 for line in range( 1, len( term ) ):
2106 outputString += ( "\t" + term[line] + "\n" )
2107 if outputString != ( term[0] + ": \n" ):
2108 main.log.info( outputString )
2109 main.log.info( "=" * 70 )
2110 return totalHits
2111 except pexpect.EOF:
2112 main.log.error( self.name + ": EOF exception found" )
2113 main.log.error( self.name + ": " + self.handle.before )
2114 main.cleanup()
2115 main.exit()
2116 except pexpect.TIMEOUT:
2117 main.log.error( self.name + ": TIMEOUT exception found" )
2118 main.log.error( self.name + ": " + self.handle.before )
2119 main.cleanup()
2120 main.exit()
2121 except Exception:
2122 main.log.exception( self.name + ": Uncaught exception!" )
2123 main.cleanup()
2124 main.exit()
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002125
2126 def copyMininetFile( self, fileName, localPath, userName, ip,
2127 mnPath='~/mininet/custom/', timeout = 60 ):
2128 """
2129 Description:
2130 Copy mininet topology file from dependency folder in the test folder
2131 and paste it to the mininet machine's mininet/custom folder
2132 Required:
2133 fileName - Name of the topology file to copy
2134 localPath - File path of the mininet topology file
2135 userName - User name of the mininet machine to send the file to
2136 ip - Ip address of the mininet machine
2137 Optional:
2138 mnPath - of the mininet directory to send the file to
2139 Return:
2140 Return main.TRUE if successfully copied the file otherwise
2141 return main.FALSE
2142 """
2143
2144 try:
2145 cmd = "scp " + localPath + fileName + " " + userName + "@" + \
2146 str( ip ) + ":" + mnPath + fileName
2147
2148 self.handle.sendline( "" )
2149 self.handle.expect( "\$" )
2150
2151 main.log.info( self.name + ": Execute: " + cmd )
2152
2153 self.handle.sendline( cmd )
2154
2155 i = self.handle.expect( [ 'No such file',
2156 "100%",
2157 pexpect.TIMEOUT ] )
2158
2159 if i == 0:
2160 main.log.error( self.name + ": File " + fileName +
2161 " does not exist!" )
2162 return main.FALSE
2163
2164 if i == 1:
2165 main.log.info( self.name + ": File " + fileName +
2166 " has been copied!" )
2167 self.handle.sendline( "" )
2168 self.handle.expect( "\$" )
2169 return main.TRUE
2170
2171 except pexpect.EOF:
2172 main.log.error( self.name + ": EOF exception found" )
2173 main.log.error( self.name + ": " + self.handle.before )
2174 main.cleanup()
2175 main.exit()
2176 except pexpect.TIMEOUT:
2177 main.log.error( self.name + ": TIMEOUT exception found" )
2178 main.log.error( self.name + ": " + self.handle.before )
2179 main.cleanup()
2180 main.exit()
cameron@onlab.us78b89652015-07-08 15:21:03 -07002181
2182 def jvmSet(self, memory=8):
Jon Hall4ba53f02015-07-29 13:07:41 -07002183
cameron@onlab.us78b89652015-07-08 15:21:03 -07002184 import os
2185
2186 homeDir = os.path.expanduser('~')
2187 filename = "/onos/tools/package/bin/onos-service"
2188
2189 serviceConfig = open(homeDir + filename, 'w+')
2190 serviceConfig.write("#!/bin/bash\n ")
2191 serviceConfig.write("#------------------------------------- \n ")
2192 serviceConfig.write("# Starts ONOS Apache Karaf container\n ")
2193 serviceConfig.write("#------------------------------------- \n ")
2194 serviceConfig.write("#export JAVA_HOME=${JAVA_HOME:-/usr/lib/jvm/java-7-openjdk-amd64/}\n ")
2195 serviceConfig.write("""export JAVA_OPTS="${JAVA_OPTS:--Xms""" + str(memory) + "G -Xmx" + str(memory) + """G}" \n """)
2196 serviceConfig.write("[ -d $ONOS_HOME ] && cd $ONOS_HOME || ONOS_HOME=$(dirname $0)/..\n")
2197 serviceConfig.write("""${ONOS_HOME}/apache-karaf-$KARAF_VERSION/bin/karaf "$@" \n """)
2198 serviceConfig.close()
2199
2200 def createDBFile(self, testData):
Jon Hall4ba53f02015-07-29 13:07:41 -07002201
cameron@onlab.us78b89652015-07-08 15:21:03 -07002202 filename = main.TEST + "DB"
2203 DBString = ""
Jon Hall4ba53f02015-07-29 13:07:41 -07002204
cameron@onlab.us78b89652015-07-08 15:21:03 -07002205 for item in testData:
Jon Hall4ba53f02015-07-29 13:07:41 -07002206 if type(item) is string:
cameron@onlab.us78b89652015-07-08 15:21:03 -07002207 item = "'" + item + "'"
2208 if testData.index(item) < len(testData-1):
2209 item += ","
Jon Hall4ba53f02015-07-29 13:07:41 -07002210 DBString += str(item)
cameron@onlab.us78b89652015-07-08 15:21:03 -07002211
2212 DBFile = open(filename, "a")
2213 DBFile.write(DBString)
2214 DBFile.close()
2215
Jon Hall4ba53f02015-07-29 13:07:41 -07002216 def verifySummary(self, ONOSIp,*deviceCount):
cameron@onlab.us78b89652015-07-08 15:21:03 -07002217
2218 self.handle.sendline("onos " + ONOSIp + " summary")
2219 self.handle.expect(":~")
2220
2221 summaryStr = self.handle.before
2222 print "\nSummary\n==============\n" + summaryStr + "\n\n"
2223
2224 #passed = "SCC(s)=1" in summaryStr
2225 #if deviceCount:
2226 # passed = "devices=" + str(deviceCount) + "," not in summaryStr
2227
GlennRC772363b2015-08-25 13:05:57 -07002228 passed = False
cameron@onlab.us78b89652015-07-08 15:21:03 -07002229 if "SCC(s)=1," in summaryStr:
2230 passed = True
2231 print("Summary is verifed")
Jon Hall4ba53f02015-07-29 13:07:41 -07002232 else:
2233 print("Summary failed")
cameron@onlab.us78b89652015-07-08 15:21:03 -07002234
2235 if deviceCount:
2236 print" ============================="
2237 checkStr = "devices=" + str(deviceCount[0]) + ","
2238 print "Checkstr: " + checkStr
2239 if checkStr not in summaryStr:
2240 passed = False
Jon Hall4ba53f02015-07-29 13:07:41 -07002241 print("Device count failed")
2242 else:
2243 print "device count verified"
cameron@onlab.us78b89652015-07-08 15:21:03 -07002244
2245 return passed