blob: eed4057aa859c56ba619b45fc65cf4515c1325e4 [file] [log] [blame]
Jon Hall05b2b432014-10-08 19:53:25 -04001#!/usr/bin/env python
andrewonlabe8e56fd2014-10-09 17:12:44 -04002
kelvin8ec71442015-01-15 16:57:00 -08003"""
4This driver interacts with ONOS bench, the OSGi platform
5that configures the ONOS nodes. ( aka ONOS-next )
andrewonlabe8e56fd2014-10-09 17:12:44 -04006
kelvin8ec71442015-01-15 16:57:00 -08007Please follow the coding style demonstrated by existing
andrewonlabe8e56fd2014-10-09 17:12:44 -04008functions and document properly.
9
10If you are a contributor to the driver, please
11list your email here for future contact:
12
13jhall@onlab.us
14andrew@onlab.us
15
16OCT 9 2014
Jeremy Songsterae01bba2016-07-11 15:39:17 -070017Modified 2016 by ON.Lab
18
19Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
20the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
21or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>
andrewonlabe8e56fd2014-10-09 17:12:44 -040022
kelvin8ec71442015-01-15 16:57:00 -080023"""
Jon Hall05b2b432014-10-08 19:53:25 -040024import time
Jon Hall6801cda2015-07-15 14:13:45 -070025import types
Jon Hall05b2b432014-10-08 19:53:25 -040026import pexpect
kelvin-onlaba4074292015-07-09 15:19:49 -070027import os
Jon Hall6c44c0b2016-04-20 15:21:00 -070028import re
29import subprocess
pingping-lin6d23d9e2015-02-02 16:54:24 -080030from requests.models import Response
Jon Hall05b2b432014-10-08 19:53:25 -040031from drivers.common.clidriver import CLI
32
kelvin8ec71442015-01-15 16:57:00 -080033class OnosDriver( CLI ):
Jon Hall05b2b432014-10-08 19:53:25 -040034
kelvin8ec71442015-01-15 16:57:00 -080035 def __init__( self ):
36 """
37 Initialize client
38 """
Jon Hallefbd9792015-03-05 16:11:36 -080039 self.name = None
40 self.home = None
41 self.handle = None
Jon Hall6c44c0b2016-04-20 15:21:00 -070042 self.nicAddr = None
Devin Limdc78e202017-06-09 18:30:07 -070043 super( OnosDriver, self ).__init__()
kelvin8ec71442015-01-15 16:57:00 -080044
45 def connect( self, **connectargs ):
46 """
Jon Hall05b2b432014-10-08 19:53:25 -040047 Creates ssh handle for ONOS "bench".
kelvin-onlaba4074292015-07-09 15:19:49 -070048 NOTE:
49 The ip_address would come from the topo file using the host tag, the
50 value can be an environment variable as well as a "localhost" to get
51 the ip address needed to ssh to the "bench"
kelvin8ec71442015-01-15 16:57:00 -080052 """
Jon Hall05b2b432014-10-08 19:53:25 -040053 try:
Devin Limdc78e202017-06-09 18:30:07 -070054
Jon Hall05b2b432014-10-08 19:53:25 -040055 for key in connectargs:
kelvin8ec71442015-01-15 16:57:00 -080056 vars( self )[ key ] = connectargs[ key ]
andrew@onlab.us3b087132015-03-11 15:00:08 -070057 self.home = "~/onos"
Jon Hall05b2b432014-10-08 19:53:25 -040058 for key in self.options:
59 if key == "home":
kelvin8ec71442015-01-15 16:57:00 -080060 self.home = self.options[ 'home' ]
Jon Hall05b2b432014-10-08 19:53:25 -040061 break
Jon Hall274b6642015-02-17 11:57:17 -080062 if self.home is None or self.home == "":
Jon Halle94919c2015-03-23 11:42:57 -070063 self.home = "~/onos"
Jon Hall21270ac2015-02-16 17:59:55 -080064
kelvin8ec71442015-01-15 16:57:00 -080065 self.name = self.options[ 'name' ]
kelvin-onlaba4074292015-07-09 15:19:49 -070066
kelvin-onlabc2b79102015-07-14 11:41:20 -070067 # The 'nodes' tag is optional and it is not required in .topo file
kelvin-onlaba4074292015-07-09 15:19:49 -070068 for key in self.options:
69 if key == "nodes":
kelvin-onlabc2b79102015-07-14 11:41:20 -070070 # Maximum number of ONOS nodes to run, if there is any
kelvin-onlaba4074292015-07-09 15:19:49 -070071 self.maxNodes = int( self.options[ 'nodes' ] )
72 break
73 self.maxNodes = None
74
kelvin-onlabc2b79102015-07-14 11:41:20 -070075 if self.maxNodes == None or self.maxNodes == "":
76 self.maxNodes = 100
kelvin-onlaba4074292015-07-09 15:19:49 -070077
kelvin-onlabc2b79102015-07-14 11:41:20 -070078
79 # Grabs all OC environment variables based on max number of nodes
kelvin-onlaba4074292015-07-09 15:19:49 -070080 self.onosIps = {} # Dictionary of all possible ONOS ip
81
82 try:
83 if self.maxNodes:
kelvin-onlaba4074292015-07-09 15:19:49 -070084 for i in range( self.maxNodes ):
85 envString = "OC" + str( i + 1 )
kelvin-onlabc2b79102015-07-14 11:41:20 -070086 # If there is no more OC# then break the loop
87 if os.getenv( envString ):
88 self.onosIps[ envString ] = os.getenv( envString )
89 else:
90 self.maxNodes = len( self.onosIps )
91 main.log.info( self.name +
92 ": Created cluster data with " +
93 str( self.maxNodes ) +
94 " maximum number" +
95 " of nodes" )
96 break
kelvin-onlaba4074292015-07-09 15:19:49 -070097
98 if not self.onosIps:
99 main.log.info( "Could not read any environment variable"
100 + " please load a cell file with all" +
101 " onos IP" )
Jon Hall5cf14d52015-07-16 12:15:19 -0700102 self.maxNodes = None
kelvin-onlaba4074292015-07-09 15:19:49 -0700103 else:
104 main.log.info( self.name + ": Found " +
105 str( self.onosIps.values() ) +
106 " ONOS IPs" )
kelvin-onlaba4074292015-07-09 15:19:49 -0700107 except KeyError:
108 main.log.info( "Invalid environment variable" )
109 except Exception as inst:
110 main.log.error( "Uncaught exception: " + str( inst ) )
111
112 try:
113 if os.getenv( str( self.ip_address ) ) != None:
114 self.ip_address = os.getenv( str( self.ip_address ) )
115 else:
116 main.log.info( self.name +
117 ": Trying to connect to " +
118 self.ip_address )
kelvin-onlaba4074292015-07-09 15:19:49 -0700119 except KeyError:
120 main.log.info( "Invalid host name," +
121 " connecting to local host instead" )
122 self.ip_address = 'localhost'
123 except Exception as inst:
124 main.log.error( "Uncaught exception: " + str( inst ) )
125
kelvin8ec71442015-01-15 16:57:00 -0800126 self.handle = super( OnosDriver, self ).connect(
127 user_name=self.user_name,
kelvin-onlab08679eb2015-01-21 16:11:48 -0800128 ip_address=self.ip_address,
kelvin-onlabd3b64892015-01-20 13:26:24 -0800129 port=self.port,
130 pwd=self.pwd,
131 home=self.home )
Jon Hall05b2b432014-10-08 19:53:25 -0400132
Jon Hall05b2b432014-10-08 19:53:25 -0400133 if self.handle:
Jon Hall0fc0d452015-07-14 09:49:58 -0700134 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -0700135 self.handle.expect( self.prompt )
Jon Hall05b2b432014-10-08 19:53:25 -0400136 return self.handle
kelvin8ec71442015-01-15 16:57:00 -0800137 else:
Jon Hall0fc0d452015-07-14 09:49:58 -0700138 main.log.info( "Failed to create ONOS handle" )
Jon Hall05b2b432014-10-08 19:53:25 -0400139 return main.FALSE
140 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800141 main.log.error( self.name + ": EOF exception found" )
142 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700143 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800144 except Exception:
145 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700146 main.cleanAndExit()
Jon Hall05b2b432014-10-08 19:53:25 -0400147
kelvin8ec71442015-01-15 16:57:00 -0800148 def disconnect( self ):
149 """
Jon Hall05b2b432014-10-08 19:53:25 -0400150 Called when Test is complete to disconnect the ONOS handle.
kelvin8ec71442015-01-15 16:57:00 -0800151 """
Jon Halld61331b2015-02-17 16:35:47 -0800152 response = main.TRUE
Jon Hall05b2b432014-10-08 19:53:25 -0400153 try:
Jon Hall61282e32015-03-19 11:34:11 -0700154 if self.handle:
155 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700156 self.handle.expect( self.prompt )
Jon Hall61282e32015-03-19 11:34:11 -0700157 self.handle.sendline( "exit" )
158 self.handle.expect( "closed" )
Jon Hall05b2b432014-10-08 19:53:25 -0400159 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800160 main.log.error( self.name + ": EOF exception found" )
161 main.log.error( self.name + ": " + self.handle.before )
Jon Hall61282e32015-03-19 11:34:11 -0700162 except ValueError:
Jon Hall1a77a1e2015-04-06 10:41:13 -0700163 main.log.exception( "Exception in disconnect of " + self.name )
Jon Hall61282e32015-03-19 11:34:11 -0700164 response = main.TRUE
Jon Hallfebb1c72015-03-05 13:30:09 -0800165 except Exception:
166 main.log.exception( self.name + ": Connection failed to the host" )
Jon Hall05b2b432014-10-08 19:53:25 -0400167 response = main.FALSE
168 return response
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400169
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400170 def getEpochMs( self ):
171 """
172 Returns milliseconds since epoch
Jon Hall4ba53f02015-07-29 13:07:41 -0700173
174 When checking multiple nodes in a for loop,
175 around a hundred milliseconds of difference (ascending) is
176 generally acceptable due to calltime of the function.
177 Few seconds, however, is not and it means clocks
178 are off sync.
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400179 """
180 try:
181 self.handle.sendline( 'date +%s.%N' )
182 self.handle.expect( 'date \+\%s\.\%N' )
Devin Limdc78e202017-06-09 18:30:07 -0700183 self.handle.expect( self.prompt )
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400184 epochMs = self.handle.before
185 return epochMs
186 except Exception:
187 main.log.exception( 'Uncaught exception getting epoch time' )
Devin Lim44075962017-08-11 10:56:37 -0700188 main.cleanAndExit()
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400189
Jon Hall6c44c0b2016-04-20 15:21:00 -0700190 def onosPackage( self, opTimeout=180 ):
kelvin8ec71442015-01-15 16:57:00 -0800191 """
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400192 Produce a self-contained tar.gz file that can be deployed
Jon Hall64af8502015-12-15 10:09:33 -0800193 and executed on any platform with Java 8 JRE.
kelvin8ec71442015-01-15 16:57:00 -0800194 """
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400195 try:
Jon Hall64af8502015-12-15 10:09:33 -0800196 ret = main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800197 self.handle.sendline( "onos-package" )
198 self.handle.expect( "onos-package" )
Jon Hall96451092016-05-04 09:42:30 -0700199 while True:
200 i = self.handle.expect( [ "Downloading",
201 "Unknown options",
202 "No such file or directory",
203 "tar.gz",
Devin Limc20e79a2017-06-07 10:29:57 -0700204 self.prompt ],
Jon Hall96451092016-05-04 09:42:30 -0700205 opTimeout )
206 handle = str( self.handle.before + self.handle.after )
207 if i == 0:
208 # Give more time to download the file
209 continue # expect again
210 elif i == 1:
211 # Incorrect usage
212 main.log.error( "onos-package does not recognize the given options" )
213 ret = main.FALSE
214 continue # expect again
215 elif i == 2:
216 # File(s) not found
217 main.log.error( "onos-package could not find a file or directory" )
218 ret = main.FALSE
219 continue # expect again
220 elif i == 3:
221 # tar.gz
222 continue # expect again
223 elif i == 4:
224 # Prompt returned
225 break
Jon Hallc6793552016-01-19 14:18:37 -0800226 main.log.info( "onos-package command returned: " + handle )
kelvin8ec71442015-01-15 16:57:00 -0800227 # As long as the sendline does not time out,
228 # return true. However, be careful to interpret
229 # the results of the onos-package command return
Jon Hall64af8502015-12-15 10:09:33 -0800230 return ret
231 except pexpect.TIMEOUT:
232 main.log.exception( self.name + ": TIMEOUT exception found in onosPackage" )
233 main.log.error( self.name + ": " + self.handle.before )
234 return main.FALSE
andrewonlab7735d852014-10-09 13:02:47 -0400235 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800236 main.log.error( self.name + ": EOF exception found" )
237 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700238 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800239 except Exception:
240 main.log.exception( "Failed to package ONOS" )
Devin Lim44075962017-08-11 10:56:37 -0700241 main.cleanAndExit()
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400242
kelvin-onlabd3b64892015-01-20 13:26:24 -0800243 def onosBuild( self ):
kelvin8ec71442015-01-15 16:57:00 -0800244 """
andrewonlab8790abb2014-11-06 13:51:54 -0500245 Use the pre defined script to build onos via mvn
kelvin8ec71442015-01-15 16:57:00 -0800246 """
andrewonlab8790abb2014-11-06 13:51:54 -0500247 try:
kelvin8ec71442015-01-15 16:57:00 -0800248 self.handle.sendline( "onos-build" )
249 self.handle.expect( "onos-build" )
250 i = self.handle.expect( [
kelvin-onlabd3b64892015-01-20 13:26:24 -0800251 "BUILD SUCCESS",
252 "ERROR",
253 "BUILD FAILED" ],
254 timeout=120 )
kelvin8ec71442015-01-15 16:57:00 -0800255 handle = str( self.handle.before )
Devin Limc20e79a2017-06-07 10:29:57 -0700256 self.handle.expect( self.prompt )
andrewonlab8790abb2014-11-06 13:51:54 -0500257
kelvin8ec71442015-01-15 16:57:00 -0800258 main.log.info( "onos-build command returned: " +
259 handle )
andrewonlab8790abb2014-11-06 13:51:54 -0500260
261 if i == 0:
262 return main.TRUE
263 else:
264 return handle
265
266 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800267 main.log.error( self.name + ": EOF exception found" )
268 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -0800269 except Exception:
270 main.log.exception( "Failed to build ONOS" )
Devin Lim44075962017-08-11 10:56:37 -0700271 main.cleanAndExit()
andrewonlab8790abb2014-11-06 13:51:54 -0500272
shahshreya9f531fe2015-06-10 12:03:51 -0700273 def cleanInstall( self, skipTest=False, mciTimeout=600 ):
kelvin8ec71442015-01-15 16:57:00 -0800274 """
275 Runs mvn clean install in the root of the ONOS directory.
276 This will clean all ONOS artifacts then compile each module
shahshreya9f531fe2015-06-10 12:03:51 -0700277 Optional:
278 skipTest - Does "-DskipTests -Dcheckstyle.skip -U -T 1C" which
279 skip the test. This will make the building faster.
280 Disregarding the credibility of the build
kelvin8ec71442015-01-15 16:57:00 -0800281 Returns: main.TRUE on success
Jon Hallde9d9aa2014-10-08 20:36:02 -0400282 On Failure, exits the test
kelvin8ec71442015-01-15 16:57:00 -0800283 """
Jon Hallde9d9aa2014-10-08 20:36:02 -0400284 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800285 main.log.info( "Running 'mvn clean install' on " +
286 str( self.name ) +
kelvin8ec71442015-01-15 16:57:00 -0800287 ". This may take some time." )
288 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -0700289 self.handle.expect( self.prompt )
Jon Hallea7818b2014-10-09 14:30:59 -0400290
kelvin8ec71442015-01-15 16:57:00 -0800291 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700292 self.handle.expect( self.prompt )
shahshreya9f531fe2015-06-10 12:03:51 -0700293
294 if not skipTest:
295 self.handle.sendline( "mvn clean install" )
296 self.handle.expect( "mvn clean install" )
297 else:
298 self.handle.sendline( "mvn clean install -DskipTests" +
299 " -Dcheckstyle.skip -U -T 1C" )
300 self.handle.expect( "mvn clean install -DskipTests" +
301 " -Dcheckstyle.skip -U -T 1C" )
kelvin8ec71442015-01-15 16:57:00 -0800302 while True:
303 i = self.handle.expect( [
Jon Hall274b6642015-02-17 11:57:17 -0800304 'There\sis\sinsufficient\smemory\sfor\sthe\sJava\s' +
Jon Hallefbd9792015-03-05 16:11:36 -0800305 'Runtime\sEnvironment\sto\scontinue',
Jon Hallde9d9aa2014-10-08 20:36:02 -0400306 'BUILD\sFAILURE',
307 'BUILD\sSUCCESS',
Devin Limdc78e202017-06-09 18:30:07 -0700308 'onos' + self.prompt, #TODO: fix this to be more generic?
309 'ONOS' + self.prompt,
pingping-lin57a56ce2015-05-20 16:43:48 -0700310 pexpect.TIMEOUT ], mciTimeout )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400311 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -0800312 main.log.error( self.name + ":There is insufficient memory \
313 for the Java Runtime Environment to continue." )
314 # return main.FALSE
Devin Lim44075962017-08-11 10:56:37 -0700315
316 main.cleanAndExit()
Jon Hallde9d9aa2014-10-08 20:36:02 -0400317 if i == 1:
kelvin8ec71442015-01-15 16:57:00 -0800318 main.log.error( self.name + ": Build failure!" )
319 # return main.FALSE
Devin Lim44075962017-08-11 10:56:37 -0700320
321 main.cleanAndExit()
Jon Hallde9d9aa2014-10-08 20:36:02 -0400322 elif i == 2:
kelvin8ec71442015-01-15 16:57:00 -0800323 main.log.info( self.name + ": Build success!" )
Jon Halle94919c2015-03-23 11:42:57 -0700324 elif i == 3 or i == 4:
kelvin8ec71442015-01-15 16:57:00 -0800325 main.log.info( self.name + ": Build complete" )
326 # Print the build time
Jon Hallf8ef52c2014-10-09 19:37:33 -0400327 for line in self.handle.before.splitlines():
328 if "Total time:" in line:
kelvin8ec71442015-01-15 16:57:00 -0800329 main.log.info( line )
330 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700331 self.handle.expect( self.prompt, timeout=60 )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400332 return main.TRUE
Jon Halle94919c2015-03-23 11:42:57 -0700333 elif i == 5:
kelvin8ec71442015-01-15 16:57:00 -0800334 main.log.error(
335 self.name +
336 ": mvn clean install TIMEOUT!" )
337 # return main.FALSE
Devin Lim44075962017-08-11 10:56:37 -0700338
339 main.cleanAndExit()
Jon Hallde9d9aa2014-10-08 20:36:02 -0400340 else:
Jon Hall274b6642015-02-17 11:57:17 -0800341 main.log.error( self.name + ": unexpected response from " +
Jon Hallefbd9792015-03-05 16:11:36 -0800342 "mvn clean install" )
kelvin8ec71442015-01-15 16:57:00 -0800343 # return main.FALSE
Devin Lim44075962017-08-11 10:56:37 -0700344
345 main.cleanAndExit()
Jon Hallde9d9aa2014-10-08 20:36:02 -0400346 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800347 main.log.error( self.name + ": EOF exception found" )
348 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700349 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800350 except Exception:
351 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700352 main.cleanAndExit()
Jon Hallacabffd2014-10-09 12:36:53 -0400353
Jon Hall3576f572016-08-23 10:01:07 -0700354 def buckBuild( self, timeout=180 ):
355 """
356 Build onos using buck.
357 """
358 try:
359 ret = main.TRUE
360 self.handle.sendline( "buck build onos" )
361 self.handle.expect( "buck build onos" )
362 output = ""
363 while True:
364 i = self.handle.expect( [ "This does not appear to be the root of a Buck project.",
365 "\n",
366 "BUILD FAILED",
Devin Limc20e79a2017-06-07 10:29:57 -0700367 self.prompt ],
Jon Hall3576f572016-08-23 10:01:07 -0700368 timeout=timeout )
369 output += str( self.handle.before + self.handle.after )
370 if i == 0:
371 main.log.error( "Wrong location" )
372 ret = main.FALSE
373 elif i == 1:
374 # end of a line, buck is still printing output
375 pass
376 elif i == 2:
377 # Build failed
378 main.log.error( "Build failed" )
379 ret = main.FALSE
380 elif i == 3:
381 # Prompt returned
382 break
383 main.log.debug( output )
384 return ret
385 except pexpect.TIMEOUT:
386 main.log.exception( self.name + ": TIMEOUT exception found" )
387 main.log.error( self.name + ": " + self.handle.before )
388 return main.FALSE
389 except pexpect.EOF:
390 main.log.error( self.name + ": EOF exception found" )
391 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700392 main.cleanAndExit()
Jon Hall3576f572016-08-23 10:01:07 -0700393 except Exception:
394 main.log.exception( "Failed to build and package ONOS" )
Devin Lim44075962017-08-11 10:56:37 -0700395 main.cleanAndExit()
Jon Hall3576f572016-08-23 10:01:07 -0700396
Jon Hall61282e32015-03-19 11:34:11 -0700397 def gitPull( self, comp1="", fastForward=True ):
kelvin8ec71442015-01-15 16:57:00 -0800398 """
Jon Hallacabffd2014-10-09 12:36:53 -0400399 Assumes that "git pull" works without login
Jon Hall47a93fb2015-01-06 16:46:06 -0800400
Jon Hall61282e32015-03-19 11:34:11 -0700401 If the fastForward boolean is set to true, only git pulls that can
402 be fast forwarded will be performed. IE if you have not local commits
403 in your branch.
404
Jon Hallacabffd2014-10-09 12:36:53 -0400405 This function will perform a git pull on the ONOS instance.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800406 If used as gitPull( "NODE" ) it will do git pull + NODE. This is
Jon Hallacabffd2014-10-09 12:36:53 -0400407 for the purpose of pulling from other nodes if necessary.
408
Jon Hall47a93fb2015-01-06 16:46:06 -0800409 Otherwise, this function will perform a git pull in the
Jon Hallacabffd2014-10-09 12:36:53 -0400410 ONOS repository. If it has any problems, it will return main.ERROR
kelvin-onlabd3b64892015-01-20 13:26:24 -0800411 If it successfully does a gitPull, it will return a 1 ( main.TRUE )
Shreya Shahee15f6c2014-10-28 18:12:30 -0400412 If it has no updates, it will return 3.
Jon Hallacabffd2014-10-09 12:36:53 -0400413
kelvin8ec71442015-01-15 16:57:00 -0800414 """
Jon Hallacabffd2014-10-09 12:36:53 -0400415 try:
kelvin8ec71442015-01-15 16:57:00 -0800416 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -0700417 self.handle.expect( self.prompt )
Jon Hall61282e32015-03-19 11:34:11 -0700418 cmd = "git pull"
419 if comp1 != "":
420 cmd += ' ' + comp1
421 if fastForward:
422 cmd += ' ' + " --ff-only"
423 self.handle.sendline( cmd )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800424 i = self.handle.expect(
425 [
426 'fatal',
427 'Username\sfor\s(.*):\s',
428 '\sfile(s*) changed,\s',
429 'Already up-to-date',
430 'Aborting',
431 'You\sare\snot\scurrently\son\sa\sbranch',
Jon Hall274b6642015-02-17 11:57:17 -0800432 'You asked me to pull without telling me which branch you',
433 'Pull is not possible because you have unmerged files',
Jon Hall61282e32015-03-19 11:34:11 -0700434 'Please enter a commit message to explain why this merge',
435 'Found a swap file by the name',
436 'Please, commit your changes before you can merge.',
kelvin-onlabd3b64892015-01-20 13:26:24 -0800437 pexpect.TIMEOUT ],
438 timeout=300 )
kelvin8ec71442015-01-15 16:57:00 -0800439 if i == 0:
Jon Hall61282e32015-03-19 11:34:11 -0700440 main.log.error( self.name + ": Git pull had some issue" )
441 output = self.handle.after
Devin Limdc78e202017-06-09 18:30:07 -0700442 self.handle.expect( self.prompt )
Jon Hall61282e32015-03-19 11:34:11 -0700443 output += self.handle.before
444 main.log.warn( output )
Jon Hallacabffd2014-10-09 12:36:53 -0400445 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800446 elif i == 1:
447 main.log.error(
448 self.name +
449 ": Git Pull Asking for username. " )
Jon Hallacabffd2014-10-09 12:36:53 -0400450 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800451 elif i == 2:
452 main.log.info(
453 self.name +
454 ": Git Pull - pulling repository now" )
Devin Limc20e79a2017-06-07 10:29:57 -0700455 self.handle.expect( self.prompt, 120 )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800456 # So that only when git pull is done, we do mvn clean compile
457 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800458 elif i == 3:
459 main.log.info( self.name + ": Git Pull - Already up to date" )
Devin Limc20e79a2017-06-07 10:29:57 -0700460 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800461 elif i == 4:
462 main.log.info(
463 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800464 ": Git Pull - Aborting..." +
465 "Are there conflicting git files?" )
Jon Hallacabffd2014-10-09 12:36:53 -0400466 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800467 elif i == 5:
468 main.log.info(
469 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800470 ": Git Pull - You are not currently " +
471 "on a branch so git pull failed!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400472 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800473 elif i == 6:
474 main.log.info(
475 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800476 ": Git Pull - You have not configured an upstream " +
477 "branch to pull from. Git pull failed!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400478 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800479 elif i == 7:
480 main.log.info(
481 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800482 ": Git Pull - Pull is not possible because " +
483 "you have unmerged files." )
Jon Hallacabffd2014-10-09 12:36:53 -0400484 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800485 elif i == 8:
Jon Hall61282e32015-03-19 11:34:11 -0700486 # NOTE: abandoning test since we can't reliably handle this
487 # there could be different default text editors and we
488 # also don't know if we actually want to make the commit
489 main.log.error( "Git pull resulted in a merge commit message" +
490 ". Exiting test!" )
Devin Lim44075962017-08-11 10:56:37 -0700491
492 main.cleanAndExit()
Jon Hall61282e32015-03-19 11:34:11 -0700493 elif i == 9: # Merge commit message but swap file exists
494 main.log.error( "Git pull resulted in a merge commit message" +
495 " but a swap file exists." )
496 try:
497 self.handle.send( 'A' ) # Abort
Devin Limc20e79a2017-06-07 10:29:57 -0700498 self.handle.expect( self.prompt )
Jon Hall61282e32015-03-19 11:34:11 -0700499 return main.ERROR
500 except Exception:
501 main.log.exception( "Couldn't exit editor prompt!")
Devin Lim44075962017-08-11 10:56:37 -0700502
503 main.cleanAndExit()
Jon Hall61282e32015-03-19 11:34:11 -0700504 elif i == 10: # In the middle of a merge commit
505 main.log.error( "Git branch is in the middle of a merge. " )
506 main.log.warn( self.handle.before + self.handle.after )
507 return main.ERROR
508 elif i == 11:
kelvin8ec71442015-01-15 16:57:00 -0800509 main.log.error( self.name + ": Git Pull - TIMEOUT" )
510 main.log.error(
511 self.name + " Response was: " + str(
512 self.handle.before ) )
Jon Hallacabffd2014-10-09 12:36:53 -0400513 return main.ERROR
514 else:
kelvin8ec71442015-01-15 16:57:00 -0800515 main.log.error(
516 self.name +
517 ": Git Pull - Unexpected response, check for pull errors" )
Jon Hallacabffd2014-10-09 12:36:53 -0400518 return main.ERROR
519 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800520 main.log.error( self.name + ": EOF exception found" )
521 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700522 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800523 except Exception:
524 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700525 main.cleanAndExit()
Jon Hallacabffd2014-10-09 12:36:53 -0400526
kelvin-onlabd3b64892015-01-20 13:26:24 -0800527 def gitCheckout( self, branch="master" ):
kelvin8ec71442015-01-15 16:57:00 -0800528 """
Jon Hallacabffd2014-10-09 12:36:53 -0400529 Assumes that "git pull" works without login
kelvin8ec71442015-01-15 16:57:00 -0800530
Jon Hallacabffd2014-10-09 12:36:53 -0400531 This function will perform a git git checkout on the ONOS instance.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800532 If used as gitCheckout( "branch" ) it will do git checkout
533 of the "branch".
Jon Hallacabffd2014-10-09 12:36:53 -0400534
535 Otherwise, this function will perform a git checkout of the master
kelvin8ec71442015-01-15 16:57:00 -0800536 branch of the ONOS repository. If it has any problems, it will return
537 main.ERROR.
538 If the branch was already the specified branch, or the git checkout was
Jon Hallacabffd2014-10-09 12:36:53 -0400539 successful then the function will return main.TRUE.
540
kelvin8ec71442015-01-15 16:57:00 -0800541 """
Jon Hallacabffd2014-10-09 12:36:53 -0400542 try:
kelvin8ec71442015-01-15 16:57:00 -0800543 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -0700544 self.handle.expect( self.prompt )
Jon Hall274b6642015-02-17 11:57:17 -0800545 main.log.info( self.name +
546 ": Checking out git branch/ref: " + branch + "..." )
kelvin8ec71442015-01-15 16:57:00 -0800547 cmd = "git checkout " + branch
548 self.handle.sendline( cmd )
549 self.handle.expect( cmd )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800550 i = self.handle.expect(
Jon Hall274b6642015-02-17 11:57:17 -0800551 [ 'fatal',
Jon Hall61282e32015-03-19 11:34:11 -0700552 'Username for (.*): ',
553 'Already on \'',
Jon Hall7a8354f2015-06-10 15:37:00 -0700554 'Switched to (a new )?branch \'' + str( branch ),
Jon Hall274b6642015-02-17 11:57:17 -0800555 pexpect.TIMEOUT,
556 'error: Your local changes to the following files' +
Jon Hallefbd9792015-03-05 16:11:36 -0800557 'would be overwritten by checkout:',
Jon Hall274b6642015-02-17 11:57:17 -0800558 'error: you need to resolve your current index first',
559 "You are in 'detached HEAD' state.",
560 "HEAD is now at " ],
kelvin-onlabd3b64892015-01-20 13:26:24 -0800561 timeout=60 )
kelvin8ec71442015-01-15 16:57:00 -0800562 if i == 0:
563 main.log.error(
564 self.name +
565 ": Git checkout had some issue..." )
566 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400567 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800568 elif i == 1:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800569 main.log.error(
570 self.name +
571 ": Git checkout asking for username." +
572 " Please configure your local git repository to be able " +
573 "to access your remote repository passwordlessly" )
Jon Hall274b6642015-02-17 11:57:17 -0800574 # TODO add support for authenticating
Jon Hallacabffd2014-10-09 12:36:53 -0400575 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800576 elif i == 2:
577 main.log.info(
578 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800579 ": Git Checkout %s : Already on this branch" % branch )
Devin Limc20e79a2017-06-07 10:29:57 -0700580 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -0800581 # main.log.info( "DEBUG: after checkout cmd = "+
582 # self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400583 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800584 elif i == 3:
585 main.log.info(
586 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800587 ": Git checkout %s - Switched to this branch" % branch )
Devin Limc20e79a2017-06-07 10:29:57 -0700588 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -0800589 # main.log.info( "DEBUG: after checkout cmd = "+
590 # self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400591 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800592 elif i == 4:
593 main.log.error( self.name + ": Git Checkout- TIMEOUT" )
594 main.log.error(
Jon Hall274b6642015-02-17 11:57:17 -0800595 self.name + " Response was: " + str( self.handle.before ) )
Jon Hallacabffd2014-10-09 12:36:53 -0400596 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800597 elif i == 5:
598 self.handle.expect( "Aborting" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800599 main.log.error(
600 self.name +
601 ": Git checkout error: \n" +
Jon Hall274b6642015-02-17 11:57:17 -0800602 "Your local changes to the following files would" +
603 " be overwritten by checkout:" +
604 str( self.handle.before ) )
Devin Limc20e79a2017-06-07 10:29:57 -0700605 self.handle.expect( self.prompt )
Jon Hall81e29af2014-11-04 20:41:23 -0500606 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800607 elif i == 6:
Jon Hall274b6642015-02-17 11:57:17 -0800608 main.log.error(
609 self.name +
610 ": Git checkout error: \n" +
611 "You need to resolve your current index first:" +
612 str( self.handle.before ) )
Devin Limc20e79a2017-06-07 10:29:57 -0700613 self.handle.expect( self.prompt )
Jon Hall81e29af2014-11-04 20:41:23 -0500614 return main.ERROR
Jon Hall274b6642015-02-17 11:57:17 -0800615 elif i == 7:
616 main.log.info(
617 self.name +
618 ": Git checkout " + str( branch ) +
619 " - You are in 'detached HEAD' state. HEAD is now at " +
620 str( branch ) )
Devin Limc20e79a2017-06-07 10:29:57 -0700621 self.handle.expect( self.prompt )
Jon Hall274b6642015-02-17 11:57:17 -0800622 return main.TRUE
623 elif i == 8: # Already in detached HEAD on the specified commit
624 main.log.info(
625 self.name +
626 ": Git Checkout %s : Already on commit" % branch )
Devin Limc20e79a2017-06-07 10:29:57 -0700627 self.handle.expect( self.prompt )
Jon Hall274b6642015-02-17 11:57:17 -0800628 return main.TRUE
Jon Hallacabffd2014-10-09 12:36:53 -0400629 else:
kelvin8ec71442015-01-15 16:57:00 -0800630 main.log.error(
631 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800632 ": Git Checkout - Unexpected response, " +
633 "check for pull errors" )
kelvin8ec71442015-01-15 16:57:00 -0800634 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400635 return main.ERROR
636
637 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800638 main.log.error( self.name + ": EOF exception found" )
639 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700640 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800641 except Exception:
642 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700643 main.cleanAndExit()
andrewonlab95ca1462014-10-09 14:04:24 -0400644
pingping-lin6d23d9e2015-02-02 16:54:24 -0800645 def getBranchName( self ):
You Wang9cdf9a22017-05-01 13:44:18 -0700646 import re
647 try:
648 main.log.info( "self.home = " )
649 main.log.info( self.home )
650 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -0700651 self.handle.expect( self.prompt )
You Wang9cdf9a22017-05-01 13:44:18 -0700652 self.handle.sendline( "git name-rev --name-only HEAD" )
653 self.handle.expect( "git name-rev --name-only HEAD" )
Devin Limc20e79a2017-06-07 10:29:57 -0700654 self.handle.expect( self.prompt )
You Wang9cdf9a22017-05-01 13:44:18 -0700655 lines = self.handle.before.splitlines()
656 if lines[1] == "master" or re.search( "^onos-\d+(\.\d+)+$", lines[1] ):
657 return lines[1]
658 else:
659 main.log.info( lines[1] )
660 return "unexpected ONOS branch"
661 except pexpect.EOF:
662 main.log.error( self.name + ": EOF exception found" )
663 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700664 main.cleanAndExit()
You Wang9cdf9a22017-05-01 13:44:18 -0700665 except pexpect.TIMEOUT:
666 main.log.error( self.name + ": TIMEOUT exception found" )
667 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700668 main.cleanAndExit()
You Wang9cdf9a22017-05-01 13:44:18 -0700669 except Exception:
670 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700671 main.cleanAndExit()
pingping-lin6d23d9e2015-02-02 16:54:24 -0800672
kelvin-onlabd3b64892015-01-20 13:26:24 -0800673 def getVersion( self, report=False ):
kelvin8ec71442015-01-15 16:57:00 -0800674 """
Jon Hall274b6642015-02-17 11:57:17 -0800675 Writes the COMMIT number to the report to be parsed
Jon Hallefbd9792015-03-05 16:11:36 -0800676 by Jenkins data collector.
kelvin8ec71442015-01-15 16:57:00 -0800677 """
Jon Hall45ec0922014-10-10 19:33:49 -0400678 try:
kelvin8ec71442015-01-15 16:57:00 -0800679 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700680 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -0800681 self.handle.sendline(
682 "cd " +
683 self.home +
Jon Hall274b6642015-02-17 11:57:17 -0800684 "; git log -1 --pretty=fuller --decorate=short | grep -A 6 " +
685 " \"commit\" --color=never" )
kelvin8ec71442015-01-15 16:57:00 -0800686 # NOTE: for some reason there are backspaces inserted in this
687 # phrase when run from Jenkins on some tests
688 self.handle.expect( "never" )
Devin Limc20e79a2017-06-07 10:29:57 -0700689 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -0800690 response = ( self.name + ": \n" + str(
691 self.handle.before + self.handle.after ) )
692 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -0700693 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -0800694 lines = response.splitlines()
Jon Hall45ec0922014-10-10 19:33:49 -0400695 for line in lines:
Jon Hallfd191202014-11-07 18:36:09 -0500696 print line
697 if report:
pingping-lin763ee042015-05-20 17:45:30 -0700698 main.log.wiki( "<blockquote>" )
kelvin8ec71442015-01-15 16:57:00 -0800699 for line in lines[ 2:-1 ]:
700 # Bracket replacement is for Wiki-compliant
701 # formatting. '<' or '>' are interpreted
702 # as xml specific tags that cause errors
703 line = line.replace( "<", "[" )
704 line = line.replace( ">", "]" )
pingping-lin763ee042015-05-20 17:45:30 -0700705 #main.log.wiki( "\t" + line )
706 main.log.wiki( line + "<br /> " )
707 main.log.summary( line )
708 main.log.wiki( "</blockquote>" )
709 main.log.summary("\n")
kelvin8ec71442015-01-15 16:57:00 -0800710 return lines[ 2 ]
Jon Hall45ec0922014-10-10 19:33:49 -0400711 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800712 main.log.error( self.name + ": EOF exception found" )
713 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700714 main.cleanAndExit()
Jon Hall368769f2014-11-19 15:43:35 -0800715 except pexpect.TIMEOUT:
kelvin8ec71442015-01-15 16:57:00 -0800716 main.log.error( self.name + ": TIMEOUT exception found" )
717 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700718 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800719 except Exception:
720 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700721 main.cleanAndExit()
Jon Hall45ec0922014-10-10 19:33:49 -0400722
kelvin-onlabd3b64892015-01-20 13:26:24 -0800723 def createCellFile( self, benchIp, fileName, mnIpAddrs,
Jon Hall810b67d2016-12-05 10:19:01 -0800724 appString, onosIpAddrs, onosUser="sdn", useSSH=True ):
kelvin8ec71442015-01-15 16:57:00 -0800725 """
andrewonlab94282092014-10-10 13:00:11 -0400726 Creates a cell file based on arguments
727 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800728 * Bench IP address ( benchIp )
andrewonlab94282092014-10-10 13:00:11 -0400729 - Needed to copy the cell file over
kelvin-onlabd3b64892015-01-20 13:26:24 -0800730 * File name of the cell file ( fileName )
731 * Mininet IP address ( mnIpAddrs )
kelvin8ec71442015-01-15 16:57:00 -0800732 - Note that only 1 ip address is
andrewonlab94282092014-10-10 13:00:11 -0400733 supported currently
kelvin-onlabd3b64892015-01-20 13:26:24 -0800734 * ONOS IP addresses ( onosIpAddrs )
andrewonlab94282092014-10-10 13:00:11 -0400735 - Must be passed in as last arguments
Flavio Castrocc38a542016-03-03 13:15:46 -0800736 * ONOS USER (onosUser)
737 - optional argument to set ONOS_USER environment variable
kelvin8ec71442015-01-15 16:57:00 -0800738
andrewonlab94282092014-10-10 13:00:11 -0400739 NOTE: Assumes cells are located at:
740 ~/<self.home>/tools/test/cells/
kelvin8ec71442015-01-15 16:57:00 -0800741 """
andrewonlab94282092014-10-10 13:00:11 -0400742 try:
Devin Lim461f0872017-06-05 16:49:33 -0700743
Jon Hall2c8959e2016-12-16 12:17:34 -0800744 # Variable initialization
745 cellDirectory = self.home + "/tools/test/cells/"
746 # We want to create the cell file in the dependencies directory
747 # of TestON first, then copy over to ONOS bench
748 tempDirectory = "/tmp/"
749 # Create the cell file in the directory for writing ( w+ )
750 cellFile = open( tempDirectory + fileName, 'w+' )
751 if isinstance( onosIpAddrs, types.StringType ):
752 onosIpAddrs = [ onosIpAddrs ]
753
754 # App string is hardcoded environment variables
755 # That you may wish to use by default on startup.
756 # Note that you may not want certain apps listed
757 # on here.
758 appString = "export ONOS_APPS=" + appString
759 onosGroup = "export ONOS_GROUP=" + onosUser
760 onosUser = "export ONOS_USER=" + onosUser
761 if useSSH:
762 onosUseSSH = "export ONOS_USE_SSH=true"
763 mnString = "export OCN="
764 if mnIpAddrs == "":
765 mnString = ""
766 onosString = "export OC"
767 tempCount = 1
768
769 # Create ONOSNIC ip address prefix
770 tempOnosIp = str( onosIpAddrs[ 0 ] )
771 tempList = []
772 tempList = tempOnosIp.split( "." )
773 # Omit last element of list to format for NIC
774 tempList = tempList[ :-1 ]
775 # Structure the nic string ip
776 nicAddr = ".".join( tempList ) + ".*"
777 self.nicAddr = nicAddr
778 onosNicString = "export ONOS_NIC=" + nicAddr
779
kelvin8ec71442015-01-15 16:57:00 -0800780 # Start writing to file
kelvin-onlabd3b64892015-01-20 13:26:24 -0800781 cellFile.write( onosNicString + "\n" )
andrewonlab94282092014-10-10 13:00:11 -0400782
kelvin-onlabd3b64892015-01-20 13:26:24 -0800783 for arg in onosIpAddrs:
784 # For each argument in onosIpAddrs, write to file
kelvin8ec71442015-01-15 16:57:00 -0800785 # Output should look like the following:
andrewonlabd4940492014-10-24 12:21:27 -0400786 # export OC1="10.128.20.11"
787 # export OC2="10.128.20.12"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800788 cellFile.write( onosString + str( tempCount ) +
Jon Hall6f665652015-09-18 10:08:07 -0700789 "=\"" + arg + "\"\n" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800790 tempCount = tempCount + 1
kelvin8ec71442015-01-15 16:57:00 -0800791
Jon Hall6f665652015-09-18 10:08:07 -0700792 cellFile.write( "export OCI=$OC1\n" )
793 cellFile.write( mnString + "\"" + mnIpAddrs + "\"\n" )
cameron@onlab.us75900962015-03-30 13:22:49 -0700794 cellFile.write( appString + "\n" )
Flavio Castrocc38a542016-03-03 13:15:46 -0800795 cellFile.write( onosGroup + "\n" )
796 cellFile.write( onosUser + "\n" )
Pier88189b62016-09-07 17:01:53 -0700797 if useSSH:
798 cellFile.write( onosUseSSH + "\n" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800799 cellFile.close()
andrewonlab94282092014-10-10 13:00:11 -0400800
kelvin8ec71442015-01-15 16:57:00 -0800801 # We use os.system to send the command to TestON cluster
802 # to account for the case in which TestON is not located
803 # on the same cluster as the ONOS bench
804 # Note that even if TestON is located on the same cluster
805 # as ONOS bench, you must setup passwordless ssh
806 # between TestON and ONOS bench in order to automate the test.
kelvin-onlabc2b79102015-07-14 11:41:20 -0700807 os.system( "scp " + tempDirectory + fileName + " " +
808 self.user_name + "@" + self.ip_address + ":" + cellDirectory )
andrewonlab94282092014-10-10 13:00:11 -0400809
andrewonlab2a6c9342014-10-16 13:40:15 -0400810 return main.TRUE
811
andrewonlab94282092014-10-10 13:00:11 -0400812 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800813 main.log.error( self.name + ": EOF exception found" )
814 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700815 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800816 except Exception:
817 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700818 main.cleanAndExit()
andrewonlab94282092014-10-10 13:00:11 -0400819
kelvin-onlabd3b64892015-01-20 13:26:24 -0800820 def setCell( self, cellname ):
kelvin8ec71442015-01-15 16:57:00 -0800821 """
andrewonlab95ca1462014-10-09 14:04:24 -0400822 Calls 'cell <name>' to set the environment variables on ONOSbench
kelvin8ec71442015-01-15 16:57:00 -0800823 """
Hari Krishna03f530e2015-07-10 17:28:27 -0700824 import re
andrewonlab95ca1462014-10-09 14:04:24 -0400825 try:
826 if not cellname:
kelvin8ec71442015-01-15 16:57:00 -0800827 main.log.error( "Must define cellname" )
Devin Lim44075962017-08-11 10:56:37 -0700828
829 main.cleanAndExit()
andrewonlab95ca1462014-10-09 14:04:24 -0400830 else:
kelvin8ec71442015-01-15 16:57:00 -0800831 self.handle.sendline( "cell " + str( cellname ) )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800832 # Expect the cellname in the ONOSCELL variable.
kelvin8ec71442015-01-15 16:57:00 -0800833 # Note that this variable name is subject to change
andrewonlab95ca1462014-10-09 14:04:24 -0400834 # and that this driver will have to change accordingly
Jon Hall3b489db2015-10-05 14:38:37 -0700835 self.handle.expect( str( cellname ) )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800836 handleBefore = self.handle.before
837 handleAfter = self.handle.after
kelvin8ec71442015-01-15 16:57:00 -0800838 # Get the rest of the handle
Devin Limc20e79a2017-06-07 10:29:57 -0700839 self.handle.expect( self.prompt )
Jon Hall439c8912016-04-15 02:22:03 -0700840 time.sleep(10)
kelvin-onlabd3b64892015-01-20 13:26:24 -0800841 handleMore = self.handle.before
andrewonlab95ca1462014-10-09 14:04:24 -0400842
Hari Krishna03f530e2015-07-10 17:28:27 -0700843 cell_result = handleBefore + handleAfter + handleMore
suibin zhang116647a2016-05-06 16:30:09 -0700844 #print cell_result
Hari Krishna03f530e2015-07-10 17:28:27 -0700845 if( re.search( "No such cell", cell_result ) ):
846 main.log.error( "Cell call returned: " + handleBefore +
kelvin-onlabd3b64892015-01-20 13:26:24 -0800847 handleAfter + handleMore )
Devin Lim44075962017-08-11 10:56:37 -0700848
849 main.cleanAndExit()
andrewonlab95ca1462014-10-09 14:04:24 -0400850 return main.TRUE
andrewonlab95ca1462014-10-09 14:04:24 -0400851 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800852 main.log.error( self.name + ": EOF exception found" )
853 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700854 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800855 except Exception:
856 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700857 main.cleanAndExit()
andrewonlab95ca1462014-10-09 14:04:24 -0400858
kelvin-onlabd3b64892015-01-20 13:26:24 -0800859 def verifyCell( self ):
kelvin8ec71442015-01-15 16:57:00 -0800860 """
andrewonlabc03bf6c2014-10-09 14:56:18 -0400861 Calls 'onos-verify-cell' to check for cell installation
kelvin8ec71442015-01-15 16:57:00 -0800862 """
863 # TODO: Add meaningful expect value
andrewonlab8d0d7d72014-10-09 16:33:15 -0400864
andrewonlabc03bf6c2014-10-09 14:56:18 -0400865 try:
kelvin8ec71442015-01-15 16:57:00 -0800866 # Clean handle by sending empty and expecting $
867 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700868 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -0800869 self.handle.sendline( "onos-verify-cell" )
Devin Limc20e79a2017-06-07 10:29:57 -0700870 self.handle.expect( self.prompt )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800871 handleBefore = self.handle.before
872 handleAfter = self.handle.after
kelvin-onlabd3b64892015-01-20 13:26:24 -0800873 main.log.info( "Verify cell returned: " + handleBefore +
Jon Hall3b489db2015-10-05 14:38:37 -0700874 handleAfter )
andrewonlabc03bf6c2014-10-09 14:56:18 -0400875 return main.TRUE
Jon Halla5cb6172015-02-23 09:28:28 -0800876 except pexpect.ExceptionPexpect as e:
Jon Hall3b489db2015-10-05 14:38:37 -0700877 main.log.exception( self.name + ": Pexpect exception found: " )
kelvin8ec71442015-01-15 16:57:00 -0800878 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700879 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800880 except Exception:
881 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700882 main.cleanAndExit()
Jon Hall7993bfc2014-10-09 16:30:14 -0400883
jenkins1e99e7b2015-04-02 18:15:39 -0700884 def onosCfgSet( self, ONOSIp, configName, configParam ):
885 """
886 Uses 'onos <node-ip> cfg set' to change a parameter value of an
Jon Hall4ba53f02015-07-29 13:07:41 -0700887 application.
888
jenkins1e99e7b2015-04-02 18:15:39 -0700889 ex)
890 onos 10.0.0.1 cfg set org.onosproject.myapp appSetting 1
jenkins1e99e7b2015-04-02 18:15:39 -0700891 ONOSIp = '10.0.0.1'
892 configName = 'org.onosproject.myapp'
893 configParam = 'appSetting 1'
jenkins1e99e7b2015-04-02 18:15:39 -0700894 """
Jon Hall72280bc2016-01-25 14:29:05 -0800895 try:
896 cfgStr = "onos {} cfg set {} {}".format( ONOSIp,
897 configName,
898 configParam )
899 self.handle.sendline( "" )
900 self.handle.expect( ":~" )
901 self.handle.sendline( cfgStr )
902 self.handle.expect("cfg set")
903 self.handle.expect( ":~" )
jenkins1e99e7b2015-04-02 18:15:39 -0700904
Jon Hall72280bc2016-01-25 14:29:05 -0800905 paramValue = configParam.split(" ")[1]
906 paramName = configParam.split(" ")[0]
Jon Hall4ba53f02015-07-29 13:07:41 -0700907
Jon Hall72280bc2016-01-25 14:29:05 -0800908 checkStr = 'onos {} cfg get " {} {} " '.format( ONOSIp, configName, paramName )
Jon Hall4ba53f02015-07-29 13:07:41 -0700909
Jon Hall72280bc2016-01-25 14:29:05 -0800910 self.handle.sendline( checkStr )
911 self.handle.expect( ":~" )
jenkins1e99e7b2015-04-02 18:15:39 -0700912
Jon Hall72280bc2016-01-25 14:29:05 -0800913 if "value=" + paramValue + "," in self.handle.before:
914 main.log.info("cfg " + configName + " successfully set to " + configParam)
915 return main.TRUE
916 except pexpect.ExceptionPexpect as e:
917 main.log.exception( self.name + ": Pexpect exception found: " )
918 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700919 main.cleanAndExit()
Jon Hall72280bc2016-01-25 14:29:05 -0800920 except Exception:
921 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700922 main.cleanAndExit()
Jon Hall4ba53f02015-07-29 13:07:41 -0700923
kelvin-onlabd3b64892015-01-20 13:26:24 -0800924 def onosCli( self, ONOSIp, cmdstr ):
kelvin8ec71442015-01-15 16:57:00 -0800925 """
andrewonlab05e362f2014-10-10 00:40:57 -0400926 Uses 'onos' command to send various ONOS CLI arguments.
927 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800928 * ONOSIp: specify the ip of the cell machine
andrewonlab94282092014-10-10 13:00:11 -0400929 * cmdstr: specify the command string to send
kelvin8ec71442015-01-15 16:57:00 -0800930
931 This function is intended to expose the entire karaf
andrewonlab6e20c342014-10-10 18:08:48 -0400932 CLI commands for ONOS. Try to use this function first
933 before attempting to write a ONOS CLI specific driver
kelvin8ec71442015-01-15 16:57:00 -0800934 function.
935 You can see a list of available 'cmdstr' arguments
andrewonlab6e20c342014-10-10 18:08:48 -0400936 by starting onos, and typing in 'onos' to enter the
937 onos> CLI. Then, type 'help' to see the list of
kelvin8ec71442015-01-15 16:57:00 -0800938 available commands.
939 """
andrewonlab05e362f2014-10-10 00:40:57 -0400940 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800941 if not ONOSIp:
kelvin8ec71442015-01-15 16:57:00 -0800942 main.log.error( "You must specify the IP address" )
andrewonlab05e362f2014-10-10 00:40:57 -0400943 return main.FALSE
944 if not cmdstr:
kelvin8ec71442015-01-15 16:57:00 -0800945 main.log.error( "You must specify the command string" )
andrewonlab05e362f2014-10-10 00:40:57 -0400946 return main.FALSE
947
kelvin8ec71442015-01-15 16:57:00 -0800948 cmdstr = str( cmdstr )
949 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700950 self.handle.expect( self.prompt )
andrewonlab05e362f2014-10-10 00:40:57 -0400951
kelvin-onlabd3b64892015-01-20 13:26:24 -0800952 self.handle.sendline( "onos -w " + ONOSIp + " " + cmdstr )
Devin Limc20e79a2017-06-07 10:29:57 -0700953 self.handle.expect( self.prompt )
andrewonlab05e362f2014-10-10 00:40:57 -0400954
kelvin-onlabd3b64892015-01-20 13:26:24 -0800955 handleBefore = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -0800956 main.log.info( "Command sent successfully" )
kelvin8ec71442015-01-15 16:57:00 -0800957 # Obtain return handle that consists of result from
958 # the onos command. The string may need to be
959 # configured further.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800960 returnString = handleBefore
kelvin-onlabd3b64892015-01-20 13:26:24 -0800961 return returnString
andrewonlab05e362f2014-10-10 00:40:57 -0400962 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800963 main.log.error( self.name + ": EOF exception found" )
964 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700965 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800966 except Exception:
967 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700968 main.cleanAndExit()
Jon Hall7993bfc2014-10-09 16:30:14 -0400969
Pier88189b62016-09-07 17:01:53 -0700970 def onosSecureSSH( self, userName="onos", userPWD="rocks", node=""):
971 """
972 Enables secure access to ONOS console
973 by removing default users & keys.
974
975 onos-secure-ssh -u onos -p rocks node
976
977 Returns: main.TRUE on success and main.FALSE on failure
978 """
979
980 try:
Chiyu Chengef109502016-11-21 15:51:38 -0800981 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700982 self.handle.expect( self.prompt )
Pier88189b62016-09-07 17:01:53 -0700983 self.handle.sendline( " onos-secure-ssh -u " + userName + " -p " + userPWD + " " + node )
984
985 # NOTE: this timeout may need to change depending on the network
986 # and size of ONOS
987 # TODO: Handle the other possible error
988 i = self.handle.expect([ "Network\sis\sunreachable",
Devin Limc20e79a2017-06-07 10:29:57 -0700989 self.prompt,
Pier88189b62016-09-07 17:01:53 -0700990 pexpect.TIMEOUT ], timeout=180 )
991 if i == 0:
992 # can't reach ONOS node
993 main.log.warn( "Network is unreachable" )
Devin Limc20e79a2017-06-07 10:29:57 -0700994 self.handle.expect( self.prompt )
Pier88189b62016-09-07 17:01:53 -0700995 return main.FALSE
996 elif i == 1:
997 # Process started
998 main.log.info(
999 "Secure SSH performed on " +
1000 node)
1001 return main.TRUE
1002 except pexpect.EOF:
1003 main.log.error( self.name + ": EOF exception found" )
1004 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001005 main.cleanAndExit()
Pier88189b62016-09-07 17:01:53 -07001006 except Exception:
1007 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001008 main.cleanAndExit()
Pier88189b62016-09-07 17:01:53 -07001009
1010
kelvin-onlabd3b64892015-01-20 13:26:24 -08001011 def onosInstall( self, options="-f", node="" ):
kelvin8ec71442015-01-15 16:57:00 -08001012 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001013 Installs ONOS bits on the designated cell machine.
kelvin8ec71442015-01-15 16:57:00 -08001014 If -f option is provided, it also forces an uninstall.
1015 Presently, install also includes onos-push-bits and
Jon Hall7993bfc2014-10-09 16:30:14 -04001016 onos-config within.
kelvin8ec71442015-01-15 16:57:00 -08001017 The node option allows you to selectively only push the jar
Jon Hall7993bfc2014-10-09 16:30:14 -04001018 files to certain onos nodes
1019
1020 Returns: main.TRUE on success and main.FALSE on failure
kelvin8ec71442015-01-15 16:57:00 -08001021 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001022 try:
andrewonlab114768a2014-11-14 12:44:44 -05001023 if options:
kelvin8ec71442015-01-15 16:57:00 -08001024 self.handle.sendline( "onos-install " + options + " " + node )
andrewonlab114768a2014-11-14 12:44:44 -05001025 else:
kelvin8ec71442015-01-15 16:57:00 -08001026 self.handle.sendline( "onos-install " + node )
1027 self.handle.expect( "onos-install " )
1028 # NOTE: this timeout may need to change depending on the network
1029 # and size of ONOS
1030 i = self.handle.expect( [ "Network\sis\sunreachable",
kelvin-onlabd3b64892015-01-20 13:26:24 -08001031 "onos\sstart/running,\sprocess",
kelvin8ec71442015-01-15 16:57:00 -08001032 "ONOS\sis\salready\sinstalled",
Jeremyc72b2582016-02-26 18:27:38 -08001033 "already\sup-to-date",
Jon Hall3576f572016-08-23 10:01:07 -07001034 "does not exist",
Devin Limc20e79a2017-06-07 10:29:57 -07001035 self.prompt,
Jon Hall6c44c0b2016-04-20 15:21:00 -07001036 pexpect.TIMEOUT ], timeout=180 )
Jon Hall7993bfc2014-10-09 16:30:14 -04001037 if i == 0:
Jon Hall3576f572016-08-23 10:01:07 -07001038 # can't reach ONOS node
kelvin8ec71442015-01-15 16:57:00 -08001039 main.log.warn( "Network is unreachable" )
Devin Limc20e79a2017-06-07 10:29:57 -07001040 self.handle.expect( self.prompt )
Jon Hall7993bfc2014-10-09 16:30:14 -04001041 return main.FALSE
1042 elif i == 1:
Jon Hall3576f572016-08-23 10:01:07 -07001043 # Process started
kelvin8ec71442015-01-15 16:57:00 -08001044 main.log.info(
1045 "ONOS was installed on " +
1046 node +
1047 " and started" )
Devin Limc20e79a2017-06-07 10:29:57 -07001048 self.handle.expect( self.prompt )
Jon Hall7993bfc2014-10-09 16:30:14 -04001049 return main.TRUE
Jon Hall3576f572016-08-23 10:01:07 -07001050 elif i == 2 or i == 3:
1051 # same bits are already on ONOS node
Jeremyc72b2582016-02-26 18:27:38 -08001052 main.log.info( "ONOS is already installed on " + node )
Devin Limc20e79a2017-06-07 10:29:57 -07001053 self.handle.expect( self.prompt )
Jeremyc72b2582016-02-26 18:27:38 -08001054 return main.TRUE
1055 elif i == 4:
Jon Hall3576f572016-08-23 10:01:07 -07001056 # onos not packaged
1057 main.log.error( "ONOS package not found." )
Devin Limc20e79a2017-06-07 10:29:57 -07001058 self.handle.expect( self.prompt )
Jon Hall3576f572016-08-23 10:01:07 -07001059 return main.FALSE
1060 elif i == 5:
1061 # prompt
Jeremyc72b2582016-02-26 18:27:38 -08001062 main.log.info( "ONOS was installed on " + node )
1063 return main.TRUE
Jon Hall3576f572016-08-23 10:01:07 -07001064 elif i == 6:
1065 # timeout
kelvin8ec71442015-01-15 16:57:00 -08001066 main.log.info(
1067 "Installation of ONOS on " +
1068 node +
1069 " timed out" )
Devin Limc20e79a2017-06-07 10:29:57 -07001070 self.handle.expect( self.prompt )
Jon Hall53c5e662016-04-13 16:06:56 -07001071 main.log.warn( self.handle.before )
Jon Hall7993bfc2014-10-09 16:30:14 -04001072 return main.FALSE
andrewonlabc03bf6c2014-10-09 14:56:18 -04001073 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001074 main.log.error( self.name + ": EOF exception found" )
1075 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001076 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001077 except Exception:
1078 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001079 main.cleanAndExit()
andrewonlab95ca1462014-10-09 14:04:24 -04001080
kelvin-onlabd3b64892015-01-20 13:26:24 -08001081 def onosStart( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001082 """
andrewonlab8d0d7d72014-10-09 16:33:15 -04001083 Calls onos command: 'onos-service [<node-ip>] start'
andrewonlabe8e56fd2014-10-09 17:12:44 -04001084 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -08001085 """
andrewonlab8d0d7d72014-10-09 16:33:15 -04001086 try:
kelvin8ec71442015-01-15 16:57:00 -08001087 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001088 self.handle.expect( self.prompt )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001089 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001090 " start" )
1091 i = self.handle.expect( [
andrewonlab8d0d7d72014-10-09 16:33:15 -04001092 "Job\sis\salready\srunning",
1093 "start/running",
Devin Limc20e79a2017-06-07 10:29:57 -07001094 self.prompt,
andrewonlab8d0d7d72014-10-09 16:33:15 -04001095 "Unknown\sinstance",
Jeremy Songster14c13572016-04-21 17:34:03 -07001096 pexpect.TIMEOUT ], timeout=180 )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001097 if i == 0:
Devin Limc20e79a2017-06-07 10:29:57 -07001098 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -08001099 main.log.info( "Service is already running" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001100 return main.TRUE
1101 elif i == 1:
Devin Limc20e79a2017-06-07 10:29:57 -07001102 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -08001103 main.log.info( "ONOS service started" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001104 return main.TRUE
Jeremyd0e9a6d2016-03-02 11:28:52 -08001105 elif i == 2:
1106 main.log.info( "ONOS service started" )
1107 return main.TRUE
andrewonlab8d0d7d72014-10-09 16:33:15 -04001108 else:
Devin Limc20e79a2017-06-07 10:29:57 -07001109 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -08001110 main.log.error( "ONOS service failed to start" )
Devin Lim44075962017-08-11 10:56:37 -07001111
1112 main.cleanAndExit()
andrewonlab8d0d7d72014-10-09 16:33:15 -04001113 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001114 main.log.error( self.name + ": EOF exception found" )
1115 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001116 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001117 except Exception:
1118 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001119 main.cleanAndExit()
andrewonlab8d0d7d72014-10-09 16:33:15 -04001120
kelvin-onlabd3b64892015-01-20 13:26:24 -08001121 def onosStop( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001122 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001123 Calls onos command: 'onos-service [<node-ip>] stop'
andrewonlabe8e56fd2014-10-09 17:12:44 -04001124 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -08001125 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001126 try:
kelvin8ec71442015-01-15 16:57:00 -08001127 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001128 self.handle.expect( self.prompt )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001129 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001130 " stop" )
1131 i = self.handle.expect( [
andrewonlab2b30bd32014-10-09 16:48:55 -04001132 "stop/waiting",
Jon Hall61282e32015-03-19 11:34:11 -07001133 "Could not resolve hostname",
andrewonlab2b30bd32014-10-09 16:48:55 -04001134 "Unknown\sinstance",
Devin Limc20e79a2017-06-07 10:29:57 -07001135 self.prompt,
Jeremy Songster14c13572016-04-21 17:34:03 -07001136 pexpect.TIMEOUT ], timeout=180 )
andrewonlab2b30bd32014-10-09 16:48:55 -04001137 if i == 0:
Devin Limc20e79a2017-06-07 10:29:57 -07001138 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -08001139 main.log.info( "ONOS service stopped" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001140 return main.TRUE
1141 elif i == 1:
Devin Limc20e79a2017-06-07 10:29:57 -07001142 self.handle.expect( self.prompt )
Jon Hall65844a32015-03-09 19:09:37 -07001143 main.log.info( "onosStop() Unknown ONOS instance specified: " +
kelvin-onlabd3b64892015-01-20 13:26:24 -08001144 str( nodeIp ) )
andrewonlab2b30bd32014-10-09 16:48:55 -04001145 return main.FALSE
Jon Hall61282e32015-03-19 11:34:11 -07001146 elif i == 2:
Devin Limc20e79a2017-06-07 10:29:57 -07001147 self.handle.expect( self.prompt )
Jon Hall61282e32015-03-19 11:34:11 -07001148 main.log.warn( "ONOS wasn't running" )
1149 return main.TRUE
YPZhang77badfc2016-03-09 10:28:59 -08001150 elif i == 3:
1151 main.log.info( "ONOS service stopped" )
1152 return main.TRUE
andrewonlab2b30bd32014-10-09 16:48:55 -04001153 else:
kelvin8ec71442015-01-15 16:57:00 -08001154 main.log.error( "ONOS service failed to stop" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001155 return main.FALSE
andrewonlab2b30bd32014-10-09 16:48:55 -04001156 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001157 main.log.error( self.name + ": EOF exception found" )
1158 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001159 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001160 except Exception:
1161 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001162 main.cleanAndExit()
kelvin8ec71442015-01-15 16:57:00 -08001163
kelvin-onlabd3b64892015-01-20 13:26:24 -08001164 def onosUninstall( self, nodeIp="" ):
kelvin8ec71442015-01-15 16:57:00 -08001165 """
andrewonlabc8d47972014-10-09 16:52:36 -04001166 Calls the command: 'onos-uninstall'
kelvin8ec71442015-01-15 16:57:00 -08001167 Uninstalls ONOS from the designated cell machine, stopping
andrewonlabe8e56fd2014-10-09 17:12:44 -04001168 if needed
kelvin8ec71442015-01-15 16:57:00 -08001169 """
andrewonlabc8d47972014-10-09 16:52:36 -04001170 try:
kelvin8ec71442015-01-15 16:57:00 -08001171 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001172 self.handle.expect( self.prompt, timeout=180 )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001173 self.handle.sendline( "onos-uninstall " + str( nodeIp ) )
Devin Limc20e79a2017-06-07 10:29:57 -07001174 self.handle.expect( self.prompt, timeout=180 )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001175 main.log.info( "ONOS " + nodeIp + " was uninstalled" )
kelvin8ec71442015-01-15 16:57:00 -08001176 # onos-uninstall command does not return any text
andrewonlabc8d47972014-10-09 16:52:36 -04001177 return main.TRUE
pingping-lin763ee042015-05-20 17:45:30 -07001178 except pexpect.TIMEOUT:
1179 main.log.exception( self.name + ": Timeout in onosUninstall" )
1180 return main.FALSE
andrewonlabc8d47972014-10-09 16:52:36 -04001181 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001182 main.log.error( self.name + ": EOF exception found" )
1183 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001184 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001185 except Exception:
1186 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001187 main.cleanAndExit()
andrewonlab2b30bd32014-10-09 16:48:55 -04001188
kelvin-onlabd3b64892015-01-20 13:26:24 -08001189 def onosDie( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001190 """
andrewonlabaedc8332014-12-04 12:43:03 -05001191 Issues the command 'onos-die <node-ip>'
1192 This command calls onos-kill and also stops the node
kelvin8ec71442015-01-15 16:57:00 -08001193 """
andrewonlabaedc8332014-12-04 12:43:03 -05001194 try:
kelvin8ec71442015-01-15 16:57:00 -08001195 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001196 self.handle.expect( self.prompt )
Jeremyf0aecdb2016-03-30 13:19:57 -07001197 cmdStr = "onos-die " + str( nodeIp )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001198 self.handle.sendline( cmdStr )
kelvin8ec71442015-01-15 16:57:00 -08001199 i = self.handle.expect( [
andrewonlabaedc8332014-12-04 12:43:03 -05001200 "Killing\sONOS",
1201 "ONOS\sprocess\sis\snot\srunning",
Jeremy Songster14c13572016-04-21 17:34:03 -07001202 pexpect.TIMEOUT ], timeout=60 )
andrewonlabaedc8332014-12-04 12:43:03 -05001203 if i == 0:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001204 main.log.info( "ONOS instance " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001205 " was killed and stopped" )
Jon Hall53c5e662016-04-13 16:06:56 -07001206 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001207 self.handle.expect( self.prompt )
andrewonlabaedc8332014-12-04 12:43:03 -05001208 return main.TRUE
1209 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001210 main.log.info( "ONOS process was not running" )
Jon Hall53c5e662016-04-13 16:06:56 -07001211 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001212 self.handle.expect( self.prompt )
andrewonlabaedc8332014-12-04 12:43:03 -05001213 return main.FALSE
1214 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001215 main.log.error( self.name + ": EOF exception found" )
1216 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001217 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001218 except Exception:
1219 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001220 main.cleanAndExit()
andrewonlabaedc8332014-12-04 12:43:03 -05001221
kelvin-onlabd3b64892015-01-20 13:26:24 -08001222 def onosKill( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001223 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001224 Calls the command: 'onos-kill [<node-ip>]'
1225 "Remotely, and unceremoniously kills the ONOS instance running on
1226 the specified cell machine" - Tom V
kelvin8ec71442015-01-15 16:57:00 -08001227 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001228 try:
kelvin8ec71442015-01-15 16:57:00 -08001229 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001230 self.handle.expect( self.prompt )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001231 self.handle.sendline( "onos-kill " + str( nodeIp ) )
kelvin8ec71442015-01-15 16:57:00 -08001232 i = self.handle.expect( [
Devin Limc20e79a2017-06-07 10:29:57 -07001233 self.prompt,
andrewonlabe8e56fd2014-10-09 17:12:44 -04001234 "No\sroute\sto\shost",
1235 "password:",
Jeremy Songster14c13572016-04-21 17:34:03 -07001236 pexpect.TIMEOUT ], timeout=60 )
kelvin8ec71442015-01-15 16:57:00 -08001237
andrewonlabe8e56fd2014-10-09 17:12:44 -04001238 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001239 main.log.info(
1240 "ONOS instance " + str(
kelvin-onlabd3b64892015-01-20 13:26:24 -08001241 nodeIp ) + " was killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001242 return main.TRUE
1243 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001244 main.log.info( "No route to host" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001245 return main.FALSE
1246 elif i == 2:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001247 main.log.info(
1248 "Passwordless login for host: " +
1249 str( nodeIp ) +
1250 " not configured" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001251 return main.FALSE
1252 else:
Jon Hallefbd9792015-03-05 16:11:36 -08001253 main.log.info( "ONOS instance was not killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001254 return main.FALSE
kelvin8ec71442015-01-15 16:57:00 -08001255
andrewonlabe8e56fd2014-10-09 17:12:44 -04001256 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001257 main.log.error( self.name + ": EOF exception found" )
1258 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001259 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001260 except Exception:
1261 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001262 main.cleanAndExit()
andrewonlabe8e56fd2014-10-09 17:12:44 -04001263
kelvin-onlabd3b64892015-01-20 13:26:24 -08001264 def onosRemoveRaftLogs( self ):
kelvin8ec71442015-01-15 16:57:00 -08001265 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001266 Removes Raft / Copy cat files from ONOS to ensure
Jon Hallfcc88622014-11-25 13:09:54 -05001267 a cleaner environment.
1268
andrewonlab19fbdca2014-11-14 12:55:59 -05001269 Description:
Jon Hallfcc88622014-11-25 13:09:54 -05001270 Stops all ONOS defined in the cell,
andrewonlab19fbdca2014-11-14 12:55:59 -05001271 wipes the raft / copycat log files
kelvin8ec71442015-01-15 16:57:00 -08001272 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001273 try:
kelvin8ec71442015-01-15 16:57:00 -08001274 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001275 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -08001276 self.handle.sendline( "onos-remove-raft-logs" )
1277 # Sometimes this command hangs
Devin Limc20e79a2017-06-07 10:29:57 -07001278 i = self.handle.expect( [ self.prompt, pexpect.TIMEOUT ],
kelvin8ec71442015-01-15 16:57:00 -08001279 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001280 if i == 1:
Devin Limc20e79a2017-06-07 10:29:57 -07001281 i = self.handle.expect( [ self.prompt, pexpect.TIMEOUT ],
kelvin8ec71442015-01-15 16:57:00 -08001282 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001283 if i == 1:
1284 return main.FALSE
andrewonlab19fbdca2014-11-14 12:55:59 -05001285 return main.TRUE
andrewonlab19fbdca2014-11-14 12:55:59 -05001286 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001287 main.log.error( self.name + ": EOF exception found" )
1288 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001289 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001290 except Exception:
1291 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001292 main.cleanAndExit()
Jon Hallfcc88622014-11-25 13:09:54 -05001293
kelvin-onlabd3b64892015-01-20 13:26:24 -08001294 def onosStartNetwork( self, mntopo ):
kelvin8ec71442015-01-15 16:57:00 -08001295 """
1296 Calls the command 'onos-start-network [ <mininet-topo> ]
1297 "remotely starts the specified topology on the cell's
andrewonlab94282092014-10-10 13:00:11 -04001298 mininet machine against all controllers configured in the
kelvin8ec71442015-01-15 16:57:00 -08001299 cell."
andrewonlab94282092014-10-10 13:00:11 -04001300 * Specify mininet topology file name for mntopo
1301 * Topo files should be placed at:
1302 ~/<your-onos-directory>/tools/test/topos
kelvin8ec71442015-01-15 16:57:00 -08001303
andrewonlab94282092014-10-10 13:00:11 -04001304 NOTE: This function will take you to the mininet prompt
kelvin8ec71442015-01-15 16:57:00 -08001305 """
andrewonlab94282092014-10-10 13:00:11 -04001306 try:
1307 if not mntopo:
kelvin8ec71442015-01-15 16:57:00 -08001308 main.log.error( "You must specify a topo file to execute" )
andrewonlab94282092014-10-10 13:00:11 -04001309 return main.FALSE
andrewonlab94282092014-10-10 13:00:11 -04001310
kelvin8ec71442015-01-15 16:57:00 -08001311 mntopo = str( mntopo )
1312 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001313 self.handle.expect( self.prompt )
andrewonlab94282092014-10-10 13:00:11 -04001314
kelvin8ec71442015-01-15 16:57:00 -08001315 self.handle.sendline( "onos-start-network " + mntopo )
1316 self.handle.expect( "mininet>" )
1317 main.log.info( "Network started, entered mininet prompt" )
1318
1319 # TODO: Think about whether return is necessary or not
andrewonlab94282092014-10-10 13:00:11 -04001320
1321 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001322 main.log.error( self.name + ": EOF exception found" )
1323 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001324 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001325 except Exception:
1326 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001327 main.cleanAndExit()
andrewonlab94282092014-10-10 13:00:11 -04001328
Jeremy Songster14c13572016-04-21 17:34:03 -07001329 def isup( self, node="", timeout=240 ):
kelvin8ec71442015-01-15 16:57:00 -08001330 """
1331 Run's onos-wait-for-start which only returns once ONOS is at run
Cameron Franke9c94fb02015-01-21 10:20:20 -08001332 level 100(ready for use)
andrewonlab8d0d7d72014-10-09 16:33:15 -04001333
Jon Hall7993bfc2014-10-09 16:30:14 -04001334 Returns: main.TRUE if ONOS is running and main.FALSE on timeout
kelvin8ec71442015-01-15 16:57:00 -08001335 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001336 try:
Jon Hall3b489db2015-10-05 14:38:37 -07001337 self.handle.sendline( "onos-wait-for-start " + node )
1338 self.handle.expect( "onos-wait-for-start" )
kelvin8ec71442015-01-15 16:57:00 -08001339 # NOTE: this timeout is arbitrary"
Devin Limc20e79a2017-06-07 10:29:57 -07001340 i = self.handle.expect([self.prompt, pexpect.TIMEOUT], timeout)
Jon Hall7993bfc2014-10-09 16:30:14 -04001341 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001342 main.log.info( self.name + ": " + node + " is up" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001343 return main.TRUE
1344 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001345 # NOTE: since this function won't return until ONOS is ready,
Jon Hall7993bfc2014-10-09 16:30:14 -04001346 # we will kill it on timeout
kelvin8ec71442015-01-15 16:57:00 -08001347 main.log.error( "ONOS has not started yet" )
1348 self.handle.send( "\x03" ) # Control-C
Devin Limc20e79a2017-06-07 10:29:57 -07001349 self.handle.expect( self.prompt )
Jon Hall7993bfc2014-10-09 16:30:14 -04001350 return main.FALSE
1351 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001352 main.log.error( self.name + ": EOF exception found" )
1353 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001354 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001355 except Exception:
1356 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001357 main.cleanAndExit()
andrewonlab05e362f2014-10-10 00:40:57 -04001358
Devin Lim142b5342017-07-20 15:22:39 -07001359 def preventAutoRespawn( self ):
1360 """
1361 Description:
1362 This will prevent ONOSservice to automatically
1363 respawn.
1364 """
1365 try:
1366 self.handle.sendline( "sed -i -e 's/^respawn$/#respawn/g' tools/package/init/onos.conf" )
1367 self.handle.expect( "\$" ) # $ from the command
1368 self.handle.sendline( "sed -i -e 's/^Restart=always/Restart=no/g' tools/package/init/onos.service" )
1369 self.handle.expect( "\$" ) # $ from the command
1370 self.handle.expect( "\$" ) # $ from the prompt
1371 except pexpect.EOF:
1372 main.log.error( self.name + ": EOF exception found" )
1373 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001374 main.cleanAndExit()
Devin Lim142b5342017-07-20 15:22:39 -07001375 except Exception:
1376 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001377 main.cleanAndExit()
Devin Lim142b5342017-07-20 15:22:39 -07001378
1379
kelvin-onlabd3b64892015-01-20 13:26:24 -08001380 def pushTestIntentsShell(
1381 self,
1382 dpidSrc,
1383 dpidDst,
1384 numIntents,
1385 dirFile,
1386 onosIp,
1387 numMult="",
1388 appId="",
1389 report=True,
1390 options="" ):
kelvin8ec71442015-01-15 16:57:00 -08001391 """
andrewonlabb66dfa12014-12-02 15:51:10 -05001392 Description:
kelvin8ec71442015-01-15 16:57:00 -08001393 Use the linux prompt to push test intents to
andrewonlabb66dfa12014-12-02 15:51:10 -05001394 better parallelize the results than the CLI
1395 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001396 * dpidSrc: specify source dpid
1397 * dpidDst: specify destination dpid
1398 * numIntents: specify number of intents to push
1399 * dirFile: specify directory and file name to save
andrewonlabb66dfa12014-12-02 15:51:10 -05001400 results
kelvin-onlabd3b64892015-01-20 13:26:24 -08001401 * onosIp: specify the IP of ONOS to install on
kelvin8ec71442015-01-15 16:57:00 -08001402 NOTE:
andrewonlabb66dfa12014-12-02 15:51:10 -05001403 You must invoke this command at linux shell prompt
kelvin8ec71442015-01-15 16:57:00 -08001404 """
1405 try:
1406 # Create the string to sendline
andrewonlabaedc8332014-12-04 12:43:03 -05001407 if options:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001408 baseCmd = "onos " + str( onosIp ) + " push-test-intents " +\
kelvin8ec71442015-01-15 16:57:00 -08001409 options + " "
andrewonlabaedc8332014-12-04 12:43:03 -05001410 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001411 baseCmd = "onos " + str( onosIp ) + " push-test-intents "
kelvin8ec71442015-01-15 16:57:00 -08001412
kelvin-onlabd3b64892015-01-20 13:26:24 -08001413 addDpid = baseCmd + str( dpidSrc ) + " " + str( dpidDst )
1414 if not numMult:
1415 addIntents = addDpid + " " + str( numIntents )
1416 elif numMult:
1417 addIntents = addDpid + " " + str( numIntents ) + " " +\
1418 str( numMult )
1419 if appId:
1420 addApp = addIntents + " " + str( appId )
andrewonlabb66dfa12014-12-02 15:51:10 -05001421 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001422 addApp = addIntents
andrewonlabb66dfa12014-12-02 15:51:10 -05001423
andrewonlabaedc8332014-12-04 12:43:03 -05001424 if report:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001425 sendCmd = addApp + " > " + str( dirFile ) + " &"
andrewonlabaedc8332014-12-04 12:43:03 -05001426 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001427 sendCmd = addApp + " &"
1428 main.log.info( "Send cmd: " + sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001429
kelvin-onlabd3b64892015-01-20 13:26:24 -08001430 self.handle.sendline( sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001431
1432 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001433 main.log.error( self.name + ": EOF exception found" )
1434 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001435 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001436 except Exception:
1437 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001438 main.cleanAndExit()
andrewonlab05e362f2014-10-10 00:40:57 -04001439
kelvin-onlabd3b64892015-01-20 13:26:24 -08001440 def tsharkPcap( self, interface, dirFile ):
kelvin8ec71442015-01-15 16:57:00 -08001441 """
andrewonlab970399c2014-11-07 13:09:32 -05001442 Capture all packet activity and store in specified
1443 directory/file
1444
1445 Required:
1446 * interface: interface to capture
1447 * dir: directory/filename to store pcap
kelvin8ec71442015-01-15 16:57:00 -08001448 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001449 try:
1450 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001451 self.handle.expect( self.prompt )
andrewonlab970399c2014-11-07 13:09:32 -05001452
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001453 self.handle.sendline( "tshark -i " + str( interface ) + " -t e -w " + str( dirFile ) + " &" )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001454 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001455 self.handle.expect( "Capturing on" )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001456 self.handle.sendline( "\n" )
Devin Limc20e79a2017-06-07 10:29:57 -07001457 self.handle.expect( self.prompt )
andrewonlab970399c2014-11-07 13:09:32 -05001458
Jon Hallfebb1c72015-03-05 13:30:09 -08001459 main.log.info( "Tshark started capturing files on " +
1460 str( interface ) + " and saving to directory: " +
1461 str( dirFile ) )
1462 except pexpect.EOF:
1463 main.log.error( self.name + ": EOF exception found" )
1464 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001465 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001466 except Exception:
1467 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001468 main.cleanAndExit()
Shreya Shaha73aaad2014-10-27 18:03:09 -04001469
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001470 def onosTopoCfg( self, onosIp, jsonFile ):
kelvin8ec71442015-01-15 16:57:00 -08001471 """
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001472 Description:
1473 Execute onos-topo-cfg command
1474 Required:
1475 onosIp - IP of the onos node you want to send the json to
1476 jsonFile - File path of the json file
1477 Return:
1478 Returns main.TRUE if the command is successfull; Returns
1479 main.FALSE if there was an error
kelvin8ec71442015-01-15 16:57:00 -08001480 """
shahshreyae6c7cf42014-11-26 16:39:01 -08001481 try:
kelvin8ec71442015-01-15 16:57:00 -08001482 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001483 self.handle.expect( self.prompt )
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001484 cmd = "onos-topo-cfg "
1485 self.handle.sendline( cmd + str( onosIp ) + " " + jsonFile )
1486 handle = self.handle.before
1487 print handle
1488 if "Error" in handle:
1489 main.log.error( self.name + ": " + self.handle.before )
1490 return main.FALSE
1491 else:
Devin Limc20e79a2017-06-07 10:29:57 -07001492 self.handle.expect( self.prompt )
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001493 return main.TRUE
1494
Jon Hallfebb1c72015-03-05 13:30:09 -08001495 except pexpect.EOF:
1496 main.log.error( self.name + ": EOF exception found" )
1497 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001498 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001499 except Exception:
1500 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001501 main.cleanAndExit()
kelvin8ec71442015-01-15 16:57:00 -08001502
jenkins1e99e7b2015-04-02 18:15:39 -07001503 def tsharkGrep( self, grep, directory, interface='eth0', grepOptions='' ):
kelvin8ec71442015-01-15 16:57:00 -08001504 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001505 Required:
kelvin8ec71442015-01-15 16:57:00 -08001506 * grep string
andrewonlabba44bcf2014-10-16 16:54:41 -04001507 * directory to store results
1508 Optional:
1509 * interface - default: eth0
Jon Hall4ba53f02015-07-29 13:07:41 -07001510 * grepOptions - options for grep
andrewonlabba44bcf2014-10-16 16:54:41 -04001511 Description:
1512 Uses tshark command to grep specific group of packets
1513 and stores the results to specified directory.
kelvin8ec71442015-01-15 16:57:00 -08001514 The timestamp is hardcoded to be in epoch
1515 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001516 try:
1517 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001518 self.handle.expect( self.prompt )
Jon Hallfebb1c72015-03-05 13:30:09 -08001519 self.handle.sendline( "" )
jenkins1e99e7b2015-04-02 18:15:39 -07001520 if grepOptions:
1521 grepStr = "grep "+str(grepOptions)
1522 else:
1523 grepStr = "grep"
Jon Hall4ba53f02015-07-29 13:07:41 -07001524
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001525 cmd = (
1526 "sudo tshark -i " +
Jon Hallfebb1c72015-03-05 13:30:09 -08001527 str( interface ) +
jenkins1e99e7b2015-04-02 18:15:39 -07001528 " -t e | " +
1529 grepStr + " --line-buffered \"" +
Jon Hallfebb1c72015-03-05 13:30:09 -08001530 str(grep) +
1531 "\" >" +
1532 directory +
1533 " &" )
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001534 self.handle.sendline(cmd)
1535 main.log.info(cmd)
Jon Hallfebb1c72015-03-05 13:30:09 -08001536 self.handle.expect( "Capturing on" )
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001537 self.handle.sendline( "\n" )
Devin Limc20e79a2017-06-07 10:29:57 -07001538 self.handle.expect( self.prompt )
Jon Hallfebb1c72015-03-05 13:30:09 -08001539 except pexpect.EOF:
1540 main.log.error( self.name + ": EOF exception found" )
1541 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001542 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001543 except Exception:
1544 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001545 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001546
kelvin-onlabd3b64892015-01-20 13:26:24 -08001547 def tsharkStop( self ):
kelvin8ec71442015-01-15 16:57:00 -08001548 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001549 Removes wireshark files from /tmp and kills all tshark processes
kelvin8ec71442015-01-15 16:57:00 -08001550 """
1551 # Remove all pcap from previous captures
Jon Hallfebb1c72015-03-05 13:30:09 -08001552 try:
1553 self.execute( cmd="sudo rm /tmp/wireshark*" )
1554 self.handle.sendline( "" )
Jon Hallefbd9792015-03-05 16:11:36 -08001555 self.handle.sendline( "sudo kill -9 `ps -ef | grep \"tshark -i\"" +
1556 " | grep -v grep | awk '{print $2}'`" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001557 self.handle.sendline( "" )
1558 main.log.info( "Tshark stopped" )
1559 except pexpect.EOF:
1560 main.log.error( self.name + ": EOF exception found" )
1561 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001562 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001563 except Exception:
1564 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001565 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001566
kelvin8ec71442015-01-15 16:57:00 -08001567 def ptpd( self, args ):
1568 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001569 Initiate ptp with user-specified args.
1570 Required:
1571 * args: specify string of args after command
1572 'sudo ptpd'
kelvin8ec71442015-01-15 16:57:00 -08001573 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001574 try:
kelvin8ec71442015-01-15 16:57:00 -08001575 self.handle.sendline( "sudo ptpd " + str( args ) )
1576 i = self.handle.expect( [
andrewonlab0c38a4a2014-10-28 18:35:35 -04001577 "Multiple",
1578 "Error",
Devin Limc20e79a2017-06-07 10:29:57 -07001579 self.prompt ] )
1580 self.handle.expect( self.prompt )
andrewonlabba44bcf2014-10-16 16:54:41 -04001581
andrewonlab0c38a4a2014-10-28 18:35:35 -04001582 if i == 0:
1583 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001584 main.log.info( "ptpd returned an error: " +
1585 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001586 return handle
1587 elif i == 1:
1588 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001589 main.log.error( "ptpd returned an error: " +
1590 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001591 return handle
1592 else:
1593 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -08001594
andrewonlab0c38a4a2014-10-28 18:35:35 -04001595 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001596 main.log.error( self.name + ": EOF exception found" )
1597 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001598 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001599 except Exception:
1600 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001601 main.cleanAndExit()
andrewonlabba44bcf2014-10-16 16:54:41 -04001602
Pier50f0bc62016-09-07 17:53:40 -07001603 def dumpONOSCmd(self, ONOSIp, CMD, destDir, filename, options=""):
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001604 """
Pier50f0bc62016-09-07 17:53:40 -07001605 Dump Cmd to a desired directory.
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001606 For debugging purposes, you may want to use
Pier50f0bc62016-09-07 17:53:40 -07001607 this function to capture Cmd at a given point in time.
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001608 Localtime will be attached to the filename
1609
1610 Required:
1611 * ONOSIp: the IP of the target ONOS instance
Pier50f0bc62016-09-07 17:53:40 -07001612 * CMD: the command to dump;
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001613 * destDir: specify directory to copy to.
1614 ex ) /tmp/
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001615 * fileName: Name of the file
Pier50f0bc62016-09-07 17:53:40 -07001616 * options: Options for ONOS command
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001617 """
1618
1619 localtime = time.strftime( '%x %X' )
1620 localtime = localtime.replace( "/", "" )
1621 localtime = localtime.replace( " ", "_" )
1622 localtime = localtime.replace( ":", "" )
1623 if destDir[ -1: ] != "/":
1624 destDir += "/"
Pier50f0bc62016-09-07 17:53:40 -07001625 cmd=CMD + " " + options + " > " + str( destDir ) + str( filename ) + localtime
1626 return self.onosCli(ONOSIp, cmd)
Flavio Castrob7718952016-05-18 08:53:41 -07001627
kelvin-onlabd3b64892015-01-20 13:26:24 -08001628 def cpLogsToDir( self, logToCopy,
Jon Hallefbd9792015-03-05 16:11:36 -08001629 destDir, copyFileName="" ):
kelvin8ec71442015-01-15 16:57:00 -08001630 """
1631 Copies logs to a desired directory.
andrewonlab5d7a8f32014-11-10 13:07:56 -05001632 Current implementation of ONOS deletes its karaf
1633 logs on every iteration. For debugging purposes,
kelvin8ec71442015-01-15 16:57:00 -08001634 you may want to use this function to capture
1635 certain karaf logs. ( or any other logs if needed )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001636 Localtime will be attached to the filename
1637
1638 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001639 * logToCopy: specify directory and log name to
andrewonlab5d7a8f32014-11-10 13:07:56 -05001640 copy.
kelvin8ec71442015-01-15 16:57:00 -08001641 ex ) /opt/onos/log/karaf.log.1
kelvin-onlabd3b64892015-01-20 13:26:24 -08001642 For copying multiple files, leave copyFileName
1643 empty and only specify destDir -
kelvin8ec71442015-01-15 16:57:00 -08001644 ex ) /opt/onos/log/karaf*
kelvin-onlabd3b64892015-01-20 13:26:24 -08001645 * destDir: specify directory to copy to.
kelvin8ec71442015-01-15 16:57:00 -08001646 ex ) /tmp/
1647 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001648 * copyFileName: If you want to rename the log
1649 file, specify copyFileName. This will not work
andrewonlab5d7a8f32014-11-10 13:07:56 -05001650 with multiple file copying
kelvin8ec71442015-01-15 16:57:00 -08001651 """
andrewonlab5d7a8f32014-11-10 13:07:56 -05001652 try:
Flavio Castro09ab59d2016-05-25 17:01:35 -07001653 localtime = time.strftime( '%H %M' )
kelvin8ec71442015-01-15 16:57:00 -08001654 localtime = localtime.replace( "/", "" )
1655 localtime = localtime.replace( " ", "_" )
1656 localtime = localtime.replace( ":", "" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001657 if destDir[ -1: ] != "/":
1658 destDir += "/"
andrewonlab5d7a8f32014-11-10 13:07:56 -05001659
kelvin-onlabd3b64892015-01-20 13:26:24 -08001660 if copyFileName:
Jon Hallfebb1c72015-03-05 13:30:09 -08001661 self.handle.sendline( "cp " + str( logToCopy ) + " " +
1662 str( destDir ) + str( copyFileName ) +
1663 localtime )
kelvin8ec71442015-01-15 16:57:00 -08001664 self.handle.expect( "cp" )
Devin Limc20e79a2017-06-07 10:29:57 -07001665 self.handle.expect( self.prompt )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001666 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001667 self.handle.sendline( "cp " + str( logToCopy ) +
1668 " " + str( destDir ) )
kelvin8ec71442015-01-15 16:57:00 -08001669 self.handle.expect( "cp" )
Devin Limc20e79a2017-06-07 10:29:57 -07001670 self.handle.expect( self.prompt )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001671
kelvin8ec71442015-01-15 16:57:00 -08001672 return self.handle.before
1673
1674 except pexpect.EOF:
1675 main.log.error( "Copying files failed" )
1676 main.log.error( self.name + ": EOF exception found" )
1677 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001678 except Exception:
1679 main.log.exception( "Copying files failed" )
1680
Jon Hall16b72c42015-05-20 10:23:36 -07001681 def checkLogs( self, onosIp, restart=False):
kelvin8ec71442015-01-15 16:57:00 -08001682 """
Jon Hall94fd0472014-12-08 11:52:42 -08001683 runs onos-check-logs on the given onos node
Jon Hall80daded2015-05-27 16:07:00 -07001684 If restart is True, use the old version of onos-check-logs which
1685 does not print the full stacktrace, but shows the entire log file,
1686 including across restarts
Jon Hall94fd0472014-12-08 11:52:42 -08001687 returns the response
kelvin8ec71442015-01-15 16:57:00 -08001688 """
Jon Hall94fd0472014-12-08 11:52:42 -08001689 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001690 cmd = "onos-check-logs " + str( onosIp )
Jon Hall16b72c42015-05-20 10:23:36 -07001691 if restart:
1692 cmd += " old"
kelvin8ec71442015-01-15 16:57:00 -08001693 self.handle.sendline( cmd )
1694 self.handle.expect( cmd )
Devin Limdc78e202017-06-09 18:30:07 -07001695 self.handle.expect( self.prompt + " " )
Jon Hall94fd0472014-12-08 11:52:42 -08001696 response = self.handle.before
1697 return response
1698 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001699 main.log.error( "Lost ssh connection" )
1700 main.log.error( self.name + ": EOF exception found" )
1701 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001702 except Exception:
1703 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001704 main.cleanAndExit()
Jon Hall94fd0472014-12-08 11:52:42 -08001705
kelvin-onlabd3b64892015-01-20 13:26:24 -08001706 def onosStatus( self, node="" ):
kelvin8ec71442015-01-15 16:57:00 -08001707 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001708 Calls onos command: 'onos-service [<node-ip>] status'
kelvin8ec71442015-01-15 16:57:00 -08001709 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001710 try:
kelvin8ec71442015-01-15 16:57:00 -08001711 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001712 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -08001713 self.handle.sendline( "onos-service " + str( node ) +
1714 " status" )
1715 i = self.handle.expect( [
You Wangef1e6572016-03-08 12:53:18 -08001716 "start/running",
You Wang7bd83062016-03-01 11:50:00 -08001717 "Running ...",
You Wangef1e6572016-03-08 12:53:18 -08001718 "stop/waiting",
You Wang7bd83062016-03-01 11:50:00 -08001719 "Not Running ...",
kelvin8ec71442015-01-15 16:57:00 -08001720 pexpect.TIMEOUT ], timeout=120 )
YPZhangfebf7302016-05-24 16:45:56 -07001721 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001722 self.handle.expect( self.prompt )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001723
You Wangef1e6572016-03-08 12:53:18 -08001724 if i == 0 or i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001725 main.log.info( "ONOS is running" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001726 return main.TRUE
You Wangef1e6572016-03-08 12:53:18 -08001727 elif i == 2 or i == 3:
kelvin8ec71442015-01-15 16:57:00 -08001728 main.log.info( "ONOS is stopped" )
kelvin8ec71442015-01-15 16:57:00 -08001729 main.log.error( "ONOS service failed to check the status" )
Devin Lim44075962017-08-11 10:56:37 -07001730
1731 main.cleanAndExit()
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001732 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001733 main.log.error( self.name + ": EOF exception found" )
1734 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001735 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001736 except Exception:
1737 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001738 main.cleanAndExit()
Jon Hall21270ac2015-02-16 17:59:55 -08001739
Jon Hall63604932015-02-26 17:09:50 -08001740 def setIpTables( self, ip, port='', action='add', packet_type='',
1741 direction='INPUT', rule='DROP', states=True ):
Jon Hallefbd9792015-03-05 16:11:36 -08001742 """
Jon Hall21270ac2015-02-16 17:59:55 -08001743 Description:
1744 add or remove iptables rule to DROP (default) packets from
1745 specific IP and PORT
1746 Usage:
1747 * specify action ('add' or 'remove')
1748 when removing, pass in the same argument as you would add. It will
1749 delete that specific rule.
1750 * specify the ip to block
1751 * specify the destination port to block (defaults to all ports)
1752 * optional packet type to block (default tcp)
1753 * optional iptables rule (default DROP)
1754 * optional direction to block (default 'INPUT')
Jon Hall63604932015-02-26 17:09:50 -08001755 * States boolean toggles adding all supported tcp states to the
1756 firewall rule
Jon Hall21270ac2015-02-16 17:59:55 -08001757 Returns:
1758 main.TRUE on success or
1759 main.FALSE if given invalid input or
1760 main.ERROR if there is an error in response from iptables
1761 WARNING:
1762 * This function uses root privilege iptables command which may result
1763 in unwanted network errors. USE WITH CAUTION
Jon Hallefbd9792015-03-05 16:11:36 -08001764 """
Jon Hall21270ac2015-02-16 17:59:55 -08001765
1766 # NOTE*********
1767 # The strict checking methods of this driver function is intentional
1768 # to discourage any misuse or error of iptables, which can cause
1769 # severe network errors
1770 # *************
1771
1772 # NOTE: Sleep needed to give some time for rule to be added and
1773 # registered to the instance. If you are calling this function
1774 # multiple times this sleep will prevent any errors.
1775 # DO NOT REMOVE
Jon Hall63604932015-02-26 17:09:50 -08001776 # time.sleep( 5 )
Jon Hall21270ac2015-02-16 17:59:55 -08001777 try:
1778 # input validation
1779 action_type = action.lower()
1780 rule = rule.upper()
1781 direction = direction.upper()
1782 if action_type != 'add' and action_type != 'remove':
1783 main.log.error( "Invalid action type. Use 'add' or "
1784 "'remove' table rule" )
1785 if rule != 'DROP' and rule != 'ACCEPT' and rule != 'LOG':
1786 # NOTE Currently only supports rules DROP, ACCEPT, and LOG
1787 main.log.error( "Invalid rule. Valid rules are 'DROP' or "
1788 "'ACCEPT' or 'LOG' only." )
1789 if direction != 'INPUT' and direction != 'OUTPUT':
1790 # NOTE currently only supports rules INPUT and OUPTUT
1791 main.log.error( "Invalid rule. Valid directions are"
1792 " 'OUTPUT' or 'INPUT'" )
1793 return main.FALSE
1794 return main.FALSE
1795 return main.FALSE
1796 if action_type == 'add':
1797 # -A is the 'append' action of iptables
1798 actionFlag = '-A'
1799 elif action_type == 'remove':
1800 # -D is the 'delete' rule of iptables
1801 actionFlag = '-D'
1802 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001803 self.handle.expect( self.prompt )
Jon Hall21270ac2015-02-16 17:59:55 -08001804 cmd = "sudo iptables " + actionFlag + " " +\
1805 direction +\
Jon Hall21270ac2015-02-16 17:59:55 -08001806 " -s " + str( ip )
Jon Hall63604932015-02-26 17:09:50 -08001807 # " -p " + str( packet_type ) +\
1808 if packet_type:
1809 cmd += " -p " + str( packet_type )
Jon Hall21270ac2015-02-16 17:59:55 -08001810 if port:
1811 cmd += " --dport " + str( port )
Jon Hall63604932015-02-26 17:09:50 -08001812 if states:
1813 cmd += " -m state --state="
1814 #FIXME- Allow user to configure which states to block
1815 cmd += "INVALID,ESTABLISHED,NEW,RELATED,UNTRACKED"
Jon Hall21270ac2015-02-16 17:59:55 -08001816 cmd += " -j " + str( rule )
1817
1818 self.handle.sendline( cmd )
Devin Limc20e79a2017-06-07 10:29:57 -07001819 self.handle.expect( self.prompt )
Jon Hall21270ac2015-02-16 17:59:55 -08001820 main.log.warn( self.handle.before )
1821
1822 info_string = "On " + str( self.name )
1823 info_string += " " + str( action_type )
1824 info_string += " iptable rule [ "
1825 info_string += " IP: " + str( ip )
1826 info_string += " Port: " + str( port )
1827 info_string += " Rule: " + str( rule )
1828 info_string += " Direction: " + str( direction ) + " ]"
1829 main.log.info( info_string )
1830 return main.TRUE
1831 except pexpect.TIMEOUT:
1832 main.log.exception( self.name + ": Timeout exception in "
1833 "setIpTables function" )
1834 return main.ERROR
1835 except pexpect.EOF:
1836 main.log.error( self.name + ": EOF exception found" )
1837 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001838 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001839 except Exception:
1840 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001841 main.cleanAndExit()
Jon Hall21270ac2015-02-16 17:59:55 -08001842
Jon Hall0468b042015-02-19 19:08:21 -08001843 def detailed_status(self, log_filename):
Jon Hallefbd9792015-03-05 16:11:36 -08001844 """
Jon Hall0468b042015-02-19 19:08:21 -08001845 This method is used by STS to check the status of the controller
1846 Reports RUNNING, STARTING, STOPPED, FROZEN, ERROR (and reason)
Jon Hallefbd9792015-03-05 16:11:36 -08001847 """
Jon Hall0468b042015-02-19 19:08:21 -08001848 import re
1849 try:
1850 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001851 self.handle.expect( self.prompt )
Jon Hall0468b042015-02-19 19:08:21 -08001852 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -07001853 self.handle.expect( self.prompt )
Jon Hall0468b042015-02-19 19:08:21 -08001854 self.handle.sendline( "service onos status" )
Devin Limc20e79a2017-06-07 10:29:57 -07001855 self.handle.expect( self.prompt )
Jon Hall0468b042015-02-19 19:08:21 -08001856 response = self.handle.before
1857 if re.search( "onos start/running", response ):
1858 # onos start/running, process 10457
1859 return 'RUNNING'
1860 # FIXME: Implement this case
1861 # elif re.search( pattern, response ):
1862 # return 'STARTING'
1863 elif re.search( "onos stop/", response ):
1864 # onos stop/waiting
1865 # FIXME handle this differently?: onos stop/pre-stop
1866 return 'STOPPED'
1867 # FIXME: Implement this case
1868 # elif re.search( pattern, response ):
1869 # return 'FROZEN'
1870 else:
1871 main.log.warn( self.name +
Jon Hallefbd9792015-03-05 16:11:36 -08001872 " WARNING: status received unknown response" )
Jon Hall0468b042015-02-19 19:08:21 -08001873 main.log.warn( response )
1874 return 'ERROR', "Unknown response: %s" % response
1875 except pexpect.TIMEOUT:
1876 main.log.exception( self.name + ": Timeout exception in "
1877 "setIpTables function" )
1878 return 'ERROR', "Pexpect Timeout"
1879 except pexpect.EOF:
1880 main.log.error( self.name + ": EOF exception found" )
1881 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001882 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001883 except Exception:
1884 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001885 main.cleanAndExit()
Jon Hall0468b042015-02-19 19:08:21 -08001886
andrew@onlab.us3b087132015-03-11 15:00:08 -07001887 def createLinkGraphFile( self, benchIp, ONOSIpList, deviceCount):
1888 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07001889 Create/formats the LinkGraph.cfg file based on arguments
1890 -only creates a linear topology and connects islands
1891 -evenly distributes devices
andrew@onlab.us3b087132015-03-11 15:00:08 -07001892 -must be called by ONOSbench
1893
Jon Hall4ba53f02015-07-29 13:07:41 -07001894 ONOSIpList - list of all of the node IPs to be used
1895
1896 deviceCount - number of switches to be assigned
andrew@onlab.us3b087132015-03-11 15:00:08 -07001897 '''
Jon Hall6509dbf2016-06-21 17:01:17 -07001898 main.log.info("Creating link graph configuration file." )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001899 linkGraphPath = self.home + "/tools/package/etc/linkGraph.cfg"
Jon Hall4ba53f02015-07-29 13:07:41 -07001900 tempFile = "/tmp/linkGraph.cfg"
andrew@onlab.us3b087132015-03-11 15:00:08 -07001901
1902 linkGraph = open(tempFile, 'w+')
1903 linkGraph.write("# NullLinkProvider topology description (config file).\n")
1904 linkGraph.write("# The NodeId is only added if the destination is another node's device.\n")
1905 linkGraph.write("# Bugs: Comments cannot be appended to a line to be read.\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07001906
andrew@onlab.us3b087132015-03-11 15:00:08 -07001907 clusterCount = len(ONOSIpList)
Jon Hall4ba53f02015-07-29 13:07:41 -07001908
1909 if type(deviceCount) is int or type(deviceCount) is str:
andrew@onlab.us3b087132015-03-11 15:00:08 -07001910 deviceCount = int(deviceCount)
1911 switchList = [0]*(clusterCount+1)
1912 baselineSwitchCount = deviceCount/clusterCount
Jon Hall4ba53f02015-07-29 13:07:41 -07001913
andrew@onlab.us3b087132015-03-11 15:00:08 -07001914 for node in range(1, clusterCount + 1):
1915 switchList[node] = baselineSwitchCount
1916
1917 for node in range(1, (deviceCount%clusterCount)+1):
1918 switchList[node] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001919
andrew@onlab.us3b087132015-03-11 15:00:08 -07001920 if type(deviceCount) is list:
1921 main.log.info("Using provided device distribution")
1922 switchList = [0]
1923 for i in deviceCount:
1924 switchList.append(int(i))
1925
1926 tempList = ['0']
1927 tempList.extend(ONOSIpList)
1928 ONOSIpList = tempList
1929
1930 myPort = 6
1931 lastSwitch = 0
1932 for node in range(1, clusterCount+1):
1933 if switchList[node] == 0:
1934 continue
1935
1936 linkGraph.write("graph " + ONOSIpList[node] + " {\n")
Jon Hall4ba53f02015-07-29 13:07:41 -07001937
andrew@onlab.us3b087132015-03-11 15:00:08 -07001938 if node > 1:
1939 #connect to last device on previous node
Jon Hall4ba53f02015-07-29 13:07:41 -07001940 line = ("\t0:5 -> " + str(lastSwitch) + ":6:" + lastIp + "\n") #ONOSIpList[node-1]
1941 linkGraph.write(line)
1942
1943 lastSwitch = 0
1944 for switch in range (0, switchList[node]-1):
andrew@onlab.us3b087132015-03-11 15:00:08 -07001945 line = ""
1946 line = ("\t" + str(switch) + ":" + str(myPort))
1947 line += " -- "
1948 line += (str(switch+1) + ":" + str(myPort-1) + "\n")
1949 linkGraph.write(line)
Jon Hall4ba53f02015-07-29 13:07:41 -07001950 lastSwitch = switch+1
andrew@onlab.us3b087132015-03-11 15:00:08 -07001951 lastIp = ONOSIpList[node]
Jon Hall4ba53f02015-07-29 13:07:41 -07001952
andrew@onlab.us3b087132015-03-11 15:00:08 -07001953 #lastSwitch += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001954 if node < (clusterCount):
andrew@onlab.us3b087132015-03-11 15:00:08 -07001955 #connect to first device on the next node
Jon Hall4ba53f02015-07-29 13:07:41 -07001956 line = ("\t" + str(lastSwitch) + ":6 -> 0:5:" + ONOSIpList[node+1] + "\n")
andrew@onlab.us3b087132015-03-11 15:00:08 -07001957 linkGraph.write(line)
Jon Hall4ba53f02015-07-29 13:07:41 -07001958
andrew@onlab.us3b087132015-03-11 15:00:08 -07001959 linkGraph.write("}\n")
1960 linkGraph.close()
1961
1962 #SCP
Jon Hall4ba53f02015-07-29 13:07:41 -07001963 os.system( "scp " + tempFile + " " + self.user_name + "@" + benchIp + ":" + linkGraphPath)
andrew@onlab.us3b087132015-03-11 15:00:08 -07001964 main.log.info("linkGraph.cfg creation complete")
1965
cameron@onlab.us75900962015-03-30 13:22:49 -07001966 def configNullDev( self, ONOSIpList, deviceCount, numPorts=10):
Jon Hall4ba53f02015-07-29 13:07:41 -07001967
andrew@onlab.us3b087132015-03-11 15:00:08 -07001968 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07001969 ONOSIpList = list of Ip addresses of nodes switches will be devided amongst
1970 deviceCount = number of switches to distribute, or list of values to use as custom distribution
cameron@onlab.us75900962015-03-30 13:22:49 -07001971 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 -07001972 '''
1973
Jon Hall6509dbf2016-06-21 17:01:17 -07001974 main.log.info("Configuring Null Device Provider" )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001975 clusterCount = len(ONOSIpList)
1976
Jon Hall4ba53f02015-07-29 13:07:41 -07001977 try:
1978
cameron@onlab.us75900962015-03-30 13:22:49 -07001979 if type(deviceCount) is int or type(deviceCount) is str:
Jon Hall6509dbf2016-06-21 17:01:17 -07001980 main.log.info("Creating device distribution")
cameron@onlab.us75900962015-03-30 13:22:49 -07001981 deviceCount = int(deviceCount)
1982 switchList = [0]*(clusterCount+1)
1983 baselineSwitchCount = deviceCount/clusterCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001984
cameron@onlab.us75900962015-03-30 13:22:49 -07001985 for node in range(1, clusterCount + 1):
1986 switchList[node] = baselineSwitchCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001987
cameron@onlab.us75900962015-03-30 13:22:49 -07001988 for node in range(1, (deviceCount%clusterCount)+1):
1989 switchList[node] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001990
1991 if type(deviceCount) is list:
1992 main.log.info("Using provided device distribution")
1993
1994 if len(deviceCount) == clusterCount:
cameron@onlab.us75900962015-03-30 13:22:49 -07001995 switchList = ['0']
1996 switchList.extend(deviceCount)
Jon Hall4ba53f02015-07-29 13:07:41 -07001997
1998 if len(deviceCount) == (clusterCount + 1):
1999 if deviceCount[0] == '0' or deviceCount[0] == 0:
cameron@onlab.us75900962015-03-30 13:22:49 -07002000 switchList = deviceCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07002001
cameron@onlab.us75900962015-03-30 13:22:49 -07002002 assert len(switchList) == (clusterCount + 1)
Jon Hall4ba53f02015-07-29 13:07:41 -07002003
cameron@onlab.us75900962015-03-30 13:22:49 -07002004 except AssertionError:
Jon Hall4ba53f02015-07-29 13:07:41 -07002005 main.log.error( "Bad device/Ip list match")
cameron@onlab.us75900962015-03-30 13:22:49 -07002006 except TypeError:
2007 main.log.exception( self.name + ": Object not as expected" )
2008 return None
Jon Hall77ba41c2015-04-06 10:25:40 -07002009 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002010 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07002011 main.cleanAndExit()
cameron@onlab.us75900962015-03-30 13:22:49 -07002012
andrew@onlab.us3b087132015-03-11 15:00:08 -07002013
2014 ONOSIp = [0]
2015 ONOSIp.extend(ONOSIpList)
Jon Hall4ba53f02015-07-29 13:07:41 -07002016
andrew@onlab.us3b087132015-03-11 15:00:08 -07002017 devicesString = "devConfigs = "
2018 for node in range(1, len(ONOSIp)):
2019 devicesString += (ONOSIp[node] + ":" + str(switchList[node] ))
2020 if node < clusterCount:
2021 devicesString += (",")
Jon Hall4ba53f02015-07-29 13:07:41 -07002022
2023 try:
cameron@onlab.us75900962015-03-30 13:22:49 -07002024 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider devConfigs " + devicesString )
2025 self.handle.expect(":~")
2026 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider numPorts " + str(numPorts) )
2027 self.handle.expect(":~")
andrew@onlab.us3b087132015-03-11 15:00:08 -07002028
cameron@onlab.us75900962015-03-30 13:22:49 -07002029 for i in range(10):
2030 self.handle.sendline("onos $OC1 cfg get org.onosproject.provider.nil.device.impl.NullDeviceProvider")
2031 self.handle.expect(":~")
2032 verification = self.handle.before
2033 if (" value=" + str(numPorts)) in verification and (" value=" + devicesString) in verification:
2034 break
2035 else:
2036 time.sleep(1)
andrew@onlab.us3b087132015-03-11 15:00:08 -07002037
cameron@onlab.us2cc8bf12015-04-02 14:12:30 -07002038 assert ("value=" + str(numPorts)) in verification and (" value=" + devicesString) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002039
cameron@onlab.us75900962015-03-30 13:22:49 -07002040 except AssertionError:
2041 main.log.error("Incorrect Config settings: " + verification)
Jon Hall77ba41c2015-04-06 10:25:40 -07002042 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002043 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07002044 main.cleanAndExit()
cameron@onlab.us75900962015-03-30 13:22:49 -07002045
Jon Hall4ba53f02015-07-29 13:07:41 -07002046 def configNullLink( self,fileName="/opt/onos/apache-karaf-3.0.3/etc/linkGraph.cfg", eventRate=0):
andrew@onlab.us3b087132015-03-11 15:00:08 -07002047 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07002048 fileName default is currently the same as the default on ONOS, specify alternate file if
cameron@onlab.us75900962015-03-30 13:22:49 -07002049 you want to use a different topology file than linkGraph.cfg
andrew@onlab.us3b087132015-03-11 15:00:08 -07002050 '''
2051
Jon Hall4ba53f02015-07-29 13:07:41 -07002052
2053 try:
2054 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider eventRate " + str(eventRate))
2055 self.handle.expect(":~")
cameron@onlab.us75900962015-03-30 13:22:49 -07002056 self.handle.sendline("onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider cfgFile " + fileName )
2057 self.handle.expect(":~")
Jon Hall4ba53f02015-07-29 13:07:41 -07002058
2059 for i in range(10):
2060 self.handle.sendline("onos $OC1 cfg get org.onosproject.provider.nil.link.impl.NullLinkProvider")
cameron@onlab.us75900962015-03-30 13:22:49 -07002061 self.handle.expect(":~")
2062 verification = self.handle.before
Jon Hall4ba53f02015-07-29 13:07:41 -07002063 if (" value=" + str(eventRate)) in verification and (" value=" + fileName) in verification:
cameron@onlab.us75900962015-03-30 13:22:49 -07002064 break
Jon Hall4ba53f02015-07-29 13:07:41 -07002065 else:
cameron@onlab.us75900962015-03-30 13:22:49 -07002066 time.sleep(1)
Jon Hall4ba53f02015-07-29 13:07:41 -07002067
cameron@onlab.us75900962015-03-30 13:22:49 -07002068 assert ("value=" + str(eventRate)) in verification and (" value=" + fileName) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002069
cameron@onlab.us75900962015-03-30 13:22:49 -07002070 except pexpect.EOF:
2071 main.log.error( self.name + ": EOF exception found" )
2072 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002073 main.cleanAndExit()
cameron@onlab.us75900962015-03-30 13:22:49 -07002074 except AssertionError:
2075 main.log.info("Settings did not post to ONOS")
Jon Hall4ba53f02015-07-29 13:07:41 -07002076 main.log.error(varification)
Jon Hall77ba41c2015-04-06 10:25:40 -07002077 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002078 main.log.exception( self.name + ": Uncaught exception!" )
2079 main.log.error(varification)
Devin Lim44075962017-08-11 10:56:37 -07002080 main.cleanAndExit()
andrew@onlab.us3b087132015-03-11 15:00:08 -07002081
kelvin-onlaba4074292015-07-09 15:19:49 -07002082 def getOnosIps( self ):
2083 """
2084 Get all onos IPs stored in
2085 """
cameron@onlab.us59d29d92015-05-11 14:31:54 -07002086
kelvin-onlaba4074292015-07-09 15:19:49 -07002087 return sorted( self.onosIps.values() )
cameron@onlab.us59d29d92015-05-11 14:31:54 -07002088
Chiyu Chengec63bde2016-11-17 18:11:36 -08002089 def listLog( self, nodeIp ):
2090 """
2091 Get a list of all the karaf log names
2092 """
2093 try:
2094 cmd = "onos-ssh " + nodeIp + " ls -tr /opt/onos/log"
2095 self.handle.sendline( cmd )
2096 self.handle.expect( ":~" )
2097 before = self.handle.before.splitlines()
2098 logNames = []
2099 for word in before:
2100 if 'karaf.log' in word:
2101 logNames.append( word )
2102 return logNames
2103 except pexpect.EOF:
2104 main.log.error( self.name + ": EOF exception found" )
2105 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002106 main.cleanAndExit()
Chiyu Chengec63bde2016-11-17 18:11:36 -08002107 except pexpect.TIMEOUT:
2108 main.log.error( self.name + ": TIMEOUT exception found" )
2109 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002110 main.cleanAndExit()
Chiyu Chengec63bde2016-11-17 18:11:36 -08002111 except Exception:
2112 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07002113 main.cleanAndExit()
Chiyu Chengec63bde2016-11-17 18:11:36 -08002114
Pratik Parab3b2ab5a2017-02-14 13:15:14 -08002115 def logReport( self, nodeIp, searchTerms, outputMode="s", startStr=None, endStr=None ):
Jon Hallb4242222016-01-25 17:07:04 -08002116 """
2117 Searches the latest ONOS log file for the given search terms and
2118 prints the total occurances of each term. Returns to combined total of
2119 all occurances.
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002120
Jon Hallb4242222016-01-25 17:07:04 -08002121 Arguments:
2122 * nodeIp - The ip of the ONOS node where the log is located
2123 * searchTerms - A string to grep for or a list of strings to grep
2124 for in the ONOS log. Will print out the number of
2125 occurances for each term.
2126 Optional Arguments:
2127 * outputMode - 's' or 'd'. If 'd' will print the last 5 lines
2128 containing each search term as well as the total
2129 number of occurances of each term. Defaults to 's',
2130 which prints the simple output of just the number
2131 of occurances for each term.
Pratik Parab3b2ab5a2017-02-14 13:15:14 -08002132 * startStr - the start string to be given to stream editor command
2133 as the start point for extraction of data
2134 * endStr - the end string to be given to stream editor command as
2135 the end point for extraction of data
Jon Hallb4242222016-01-25 17:07:04 -08002136 """
2137 try:
2138 main.log.info( " Log Report for {} ".format( nodeIp ).center( 70, '=' ) )
2139 if type( searchTerms ) is str:
2140 searchTerms = [searchTerms]
2141 numTerms = len( searchTerms )
2142 outputMode = outputMode.lower()
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002143
Jon Hallb4242222016-01-25 17:07:04 -08002144 totalHits = 0
2145 logLines = []
2146 for termIndex in range( numTerms ):
2147 term = searchTerms[termIndex]
2148 logLines.append( [term] )
Pratik Parab3b2ab5a2017-02-14 13:15:14 -08002149 if startStr and endStr:
2150 cmd = "onos-ssh {} \"sed -n '/{}/,/{}/p' /opt/onos/log/karaf.log | grep {}\"".format( nodeIp,
2151 startStr,
2152 endStr,
2153 term )
2154 else:
2155 cmd = "onos-ssh {} cat /opt/onos/log/karaf.log | grep {}".format( nodeIp,
2156 term )
Jon Hallb4242222016-01-25 17:07:04 -08002157 self.handle.sendline( cmd )
2158 self.handle.expect( ":~" )
2159 before = self.handle.before.splitlines()
2160 count = 0
2161 for line in before:
2162 if term in line and "grep" not in line:
2163 count += 1
2164 if before.index( line ) > ( len( before ) - 7 ):
2165 logLines[termIndex].append( line )
2166 main.log.info( "{}: {}".format( term, count ) )
2167 totalHits += count
2168 if termIndex == numTerms - 1:
2169 print "\n"
2170 if outputMode != "s":
2171 outputString = ""
2172 for term in logLines:
2173 outputString = term[0] + ": \n"
2174 for line in range( 1, len( term ) ):
2175 outputString += ( "\t" + term[line] + "\n" )
2176 if outputString != ( term[0] + ": \n" ):
2177 main.log.info( outputString )
2178 main.log.info( "=" * 70 )
2179 return totalHits
2180 except pexpect.EOF:
2181 main.log.error( self.name + ": EOF exception found" )
2182 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002183 main.cleanAndExit()
Jon Hallb4242222016-01-25 17:07:04 -08002184 except pexpect.TIMEOUT:
2185 main.log.error( self.name + ": TIMEOUT exception found" )
2186 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002187 main.cleanAndExit()
Jon Hallb4242222016-01-25 17:07:04 -08002188 except Exception:
2189 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07002190 main.cleanAndExit()
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002191
2192 def copyMininetFile( self, fileName, localPath, userName, ip,
2193 mnPath='~/mininet/custom/', timeout = 60 ):
2194 """
2195 Description:
2196 Copy mininet topology file from dependency folder in the test folder
2197 and paste it to the mininet machine's mininet/custom folder
2198 Required:
2199 fileName - Name of the topology file to copy
2200 localPath - File path of the mininet topology file
2201 userName - User name of the mininet machine to send the file to
2202 ip - Ip address of the mininet machine
2203 Optional:
2204 mnPath - of the mininet directory to send the file to
2205 Return:
2206 Return main.TRUE if successfully copied the file otherwise
2207 return main.FALSE
2208 """
2209
2210 try:
2211 cmd = "scp " + localPath + fileName + " " + userName + "@" + \
2212 str( ip ) + ":" + mnPath + fileName
2213
2214 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07002215 self.handle.expect( self.prompt )
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002216
2217 main.log.info( self.name + ": Execute: " + cmd )
2218
2219 self.handle.sendline( cmd )
2220
2221 i = self.handle.expect( [ 'No such file',
2222 "100%",
2223 pexpect.TIMEOUT ] )
2224
2225 if i == 0:
2226 main.log.error( self.name + ": File " + fileName +
2227 " does not exist!" )
2228 return main.FALSE
2229
2230 if i == 1:
2231 main.log.info( self.name + ": File " + fileName +
2232 " has been copied!" )
2233 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07002234 self.handle.expect( self.prompt )
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002235 return main.TRUE
2236
2237 except pexpect.EOF:
2238 main.log.error( self.name + ": EOF exception found" )
2239 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002240 main.cleanAndExit()
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002241 except pexpect.TIMEOUT:
2242 main.log.error( self.name + ": TIMEOUT exception found" )
2243 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002244 main.cleanAndExit()
cameron@onlab.us78b89652015-07-08 15:21:03 -07002245
2246 def jvmSet(self, memory=8):
Jon Hall4ba53f02015-07-29 13:07:41 -07002247
cameron@onlab.us78b89652015-07-08 15:21:03 -07002248 import os
2249
2250 homeDir = os.path.expanduser('~')
2251 filename = "/onos/tools/package/bin/onos-service"
2252
2253 serviceConfig = open(homeDir + filename, 'w+')
2254 serviceConfig.write("#!/bin/bash\n ")
2255 serviceConfig.write("#------------------------------------- \n ")
2256 serviceConfig.write("# Starts ONOS Apache Karaf container\n ")
2257 serviceConfig.write("#------------------------------------- \n ")
2258 serviceConfig.write("#export JAVA_HOME=${JAVA_HOME:-/usr/lib/jvm/java-7-openjdk-amd64/}\n ")
2259 serviceConfig.write("""export JAVA_OPTS="${JAVA_OPTS:--Xms""" + str(memory) + "G -Xmx" + str(memory) + """G}" \n """)
2260 serviceConfig.write("[ -d $ONOS_HOME ] && cd $ONOS_HOME || ONOS_HOME=$(dirname $0)/..\n")
2261 serviceConfig.write("""${ONOS_HOME}/apache-karaf-$KARAF_VERSION/bin/karaf "$@" \n """)
2262 serviceConfig.close()
2263
Jon Hall6c44c0b2016-04-20 15:21:00 -07002264 def createDBFile( self, testData ):
Jon Hall4ba53f02015-07-29 13:07:41 -07002265
cameron@onlab.us78b89652015-07-08 15:21:03 -07002266 filename = main.TEST + "DB"
2267 DBString = ""
Jon Hall4ba53f02015-07-29 13:07:41 -07002268
cameron@onlab.us78b89652015-07-08 15:21:03 -07002269 for item in testData:
Jon Hall6c44c0b2016-04-20 15:21:00 -07002270 if type( item ) is string:
cameron@onlab.us78b89652015-07-08 15:21:03 -07002271 item = "'" + item + "'"
Jon Hall6c44c0b2016-04-20 15:21:00 -07002272 if testData.index( item ) < len( testData - 1 ):
cameron@onlab.us78b89652015-07-08 15:21:03 -07002273 item += ","
Jon Hall6c44c0b2016-04-20 15:21:00 -07002274 DBString += str( item )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002275
Jon Hall6c44c0b2016-04-20 15:21:00 -07002276 DBFile = open( filename, "a" )
2277 DBFile.write( DBString )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002278 DBFile.close()
2279
Jon Hall6c44c0b2016-04-20 15:21:00 -07002280 def verifySummary( self, ONOSIp, *deviceCount ):
cameron@onlab.us78b89652015-07-08 15:21:03 -07002281
Jon Hall6c44c0b2016-04-20 15:21:00 -07002282 self.handle.sendline( "onos " + ONOSIp + " summary" )
2283 self.handle.expect( ":~" )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002284
2285 summaryStr = self.handle.before
2286 print "\nSummary\n==============\n" + summaryStr + "\n\n"
2287
2288 #passed = "SCC(s)=1" in summaryStr
2289 #if deviceCount:
2290 # passed = "devices=" + str(deviceCount) + "," not in summaryStr
2291
GlennRC772363b2015-08-25 13:05:57 -07002292 passed = False
cameron@onlab.us78b89652015-07-08 15:21:03 -07002293 if "SCC(s)=1," in summaryStr:
2294 passed = True
Jon Hall6c44c0b2016-04-20 15:21:00 -07002295 print "Summary is verifed"
Jon Hall4ba53f02015-07-29 13:07:41 -07002296 else:
Jon Hall6c44c0b2016-04-20 15:21:00 -07002297 print "Summary failed"
cameron@onlab.us78b89652015-07-08 15:21:03 -07002298
2299 if deviceCount:
2300 print" ============================="
Jon Hall6c44c0b2016-04-20 15:21:00 -07002301 checkStr = "devices=" + str( deviceCount[0] ) + ","
cameron@onlab.us78b89652015-07-08 15:21:03 -07002302 print "Checkstr: " + checkStr
2303 if checkStr not in summaryStr:
2304 passed = False
Jon Hall6c44c0b2016-04-20 15:21:00 -07002305 print "Device count failed"
Jon Hall4ba53f02015-07-29 13:07:41 -07002306 else:
2307 print "device count verified"
cameron@onlab.us78b89652015-07-08 15:21:03 -07002308
2309 return passed
Jon Hall6c44c0b2016-04-20 15:21:00 -07002310
Jon Hall8f6d4622016-05-23 15:27:18 -07002311 def getIpAddr( self, iface=None ):
Jon Hall6c44c0b2016-04-20 15:21:00 -07002312 """
2313 Update self.ip_address with numerical ip address. If multiple IP's are
2314 located on the device, will attempt to use self.nicAddr to choose the
2315 right one. Defaults to 127.0.0.1 if no other address is found or cannot
2316 determine the correct address.
2317
2318 ONLY WORKS WITH IPV4 ADDRESSES
2319 """
2320 try:
Jon Hall8f6d4622016-05-23 15:27:18 -07002321 LOCALHOST = "127.0.0.1"
Jon Hall6c44c0b2016-04-20 15:21:00 -07002322 ipPat = "\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"
2323 pattern = re.compile( ipPat )
2324 match = re.search( pattern, self.ip_address )
2325 if self.nicAddr:
2326 nicPat = self.nicAddr.replace( ".", "\." ).replace( "\*", r"\d{1,3}" )
2327 nicPat = re.compile( nicPat )
2328 else:
2329 nicPat = None
2330 # IF self.ip_address is an ip address and matches
2331 # self.nicAddr: return self.ip_address
2332 if match:
2333 curIp = match.group(0)
2334 if nicPat:
2335 nicMatch = re.search( nicPat, curIp )
2336 if nicMatch:
2337 return self.ip_address
Jon Hall8f6d4622016-05-23 15:27:18 -07002338 # ELSE: IF iface, return ip of interface
2339 cmd = "ifconfig"
2340 ifPat = re.compile( "inet addr:({})".format( ipPat ) )
2341 if iface:
2342 cmd += " " + str( iface )
2343 raw = subprocess.check_output( cmd.split() )
Jon Hall6c44c0b2016-04-20 15:21:00 -07002344 ifPat = re.compile( "inet addr:({})".format( ipPat ) )
2345 ips = re.findall( ifPat, raw )
Jon Hall8f6d4622016-05-23 15:27:18 -07002346 if iface:
2347 if ips:
2348 ip = ips[0]
2349 self.ip_address = ip
2350 return ip
2351 else:
2352 main.log.error( "Error finding ip, ifconfig output:".format( raw ) )
2353 # ELSE: attempt to get address matching nicPat.
Jon Hall6c44c0b2016-04-20 15:21:00 -07002354 if nicPat:
2355 for ip in ips:
2356 curMatch = re.search( nicPat, ip )
2357 if curMatch:
2358 self.ip_address = ip
2359 return ip
Jon Hall8f6d4622016-05-23 15:27:18 -07002360 else: # If only one non-localhost ip, return that
2361 tmpList = [ ip for ip in ips if ip is not LOCALHOST ]
Jon Hall6c44c0b2016-04-20 15:21:00 -07002362 if len(tmpList) == 1:
2363 curIp = tmpList[0]
2364 self.ip_address = curIp
2365 return curIp
Jon Hall8f6d4622016-05-23 15:27:18 -07002366 # Either no non-localhost IPs, or more than 1
Jon Hallebccd352016-05-20 15:17:17 -07002367 main.log.warn( "getIpAddr failed to find a public IP address" )
Jon Hall8f6d4622016-05-23 15:27:18 -07002368 return LOCALHOST
Jon Halle1790952016-05-23 15:51:46 -07002369 except subprocess.CalledProcessError:
Jon Hall8f6d4622016-05-23 15:27:18 -07002370 main.log.exception( "Error executing ifconfig" )
2371 except IndexError:
2372 main.log.exception( "Error getting IP Address" )
Jon Hall6c44c0b2016-04-20 15:21:00 -07002373 except Exception:
2374 main.log.exception( "Uncaught exception" )
suibin zhang116647a2016-05-06 16:30:09 -07002375
Devin Lim461f0872017-06-05 16:49:33 -07002376 def startBasicONOS( self, nodeList, opSleep=60, onosStartupSleep=30, onosUser="sdn" ):
suibin zhang116647a2016-05-06 16:30:09 -07002377 '''
2378 Start onos cluster with defined nodes, but only with drivers app
suibin zhang116647a2016-05-06 16:30:09 -07002379 '''
2380 import time
2381
2382 self.createCellFile( self.ip_address,
2383 "temp",
2384 self.ip_address,
2385 "drivers",
Devin Lim461f0872017-06-05 16:49:33 -07002386 nodeList, onosUser )
suibin zhang116647a2016-05-06 16:30:09 -07002387
2388 main.log.info( self.name + ": Apply cell to environment" )
2389 cellResult = self.setCell( "temp" )
2390 verifyResult = self.verifyCell()
2391
2392 main.log.info( self.name + ": Creating ONOS package" )
You Wangd1bcaca2016-10-24 15:23:26 -07002393 packageResult = self.buckBuild( timeout=opSleep )
suibin zhang116647a2016-05-06 16:30:09 -07002394
You Wangc669d212017-01-25 11:09:48 -08002395 main.log.info( self.name + ": Uninstalling ONOS" )
2396 for nd in nodeList:
2397 self.onosUninstall( nodeIp=nd )
2398
suibin zhang116647a2016-05-06 16:30:09 -07002399 main.log.info( self.name + ": Installing ONOS package" )
2400 for nd in nodeList:
You Wangc669d212017-01-25 11:09:48 -08002401 self.onosInstall( node=nd )
2402
2403 main.log.info( self.name + ": Set up ONOS secure SSH" )
2404 for nd in nodeList:
2405 self.onosSecureSSH( node=nd )
suibin zhang116647a2016-05-06 16:30:09 -07002406
2407 main.log.info( self.name + ": Starting ONOS service" )
2408 time.sleep( onosStartupSleep )
2409
2410 onosStatus = True
2411 for nd in nodeList:
2412 onosStatus = onosStatus & self.isup( node = nd )
2413 #print "onosStatus is: " + str( onosStatus )
2414
2415 return main.TRUE if onosStatus else main.FALSE
2416
Devin Lim02075272017-07-10 15:33:21 -07002417 def onosNetCfg( self, controllerIp, path, fileName ):
Jeremy Songster5665f1b2016-06-20 14:38:22 -07002418 """
2419 Push a specified json file to ONOS through the onos-netcfg service
2420
2421 Required:
Devin Lim02075272017-07-10 15:33:21 -07002422 controllerIp - the Ip of the ONOS node in the cluster
Jeremy Songster5665f1b2016-06-20 14:38:22 -07002423 path - the location of the file to be sent
2424 fileName - name of the json file to be sent
2425
2426 Returns main.TRUE on successfully sending json file, and main.FALSE if
2427 there is an error.
2428 """
2429 try:
Devin Lim02075272017-07-10 15:33:21 -07002430 cmd = "onos-netcfg {0} {1}{2}".format( controllerIp, path, fileName )
2431 main.log.info( "Sending: " + cmd )
2432 main.ONOSbench.handle.sendline( cmd )
Jeremy Ronquillo3008aa32017-07-07 15:38:57 -07002433 main.ONOSbench.handle.expect( self.prompt )
Devin Lim02075272017-07-10 15:33:21 -07002434 handle = self.handle.before
Jeremy Ronquillo3008aa32017-07-07 15:38:57 -07002435 if "Error" in handle or "No such file or directory" in handle or "curl: " in handle:
2436 main.log.error( self.name + ": " + handle + self.handle.after )
Devin Lim02075272017-07-10 15:33:21 -07002437 return main.FALSE
Devin Lim752dd7b2017-06-27 14:40:03 -07002438 return main.TRUE
Jeremy Songster5665f1b2016-06-20 14:38:22 -07002439 except pexpect.EOF:
2440 main.log.error( self.name + ": EOF exception found" )
2441 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002442 main.cleanAndExit()
Jeremy Songster5665f1b2016-06-20 14:38:22 -07002443 except Exception:
2444 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07002445 main.cleanAndExit()