blob: 6afc3a097ee049ed169cd5f7f4d580bf760168ed [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"""
Jeremy Ronquilloec916a42018-02-02 13:05:57 -08004Copyright 2014 Open Networking Foundation (ONF)
5
kelvin8ec71442015-01-15 16:57:00 -08006This driver interacts with ONOS bench, the OSGi platform
7that configures the ONOS nodes. ( aka ONOS-next )
andrewonlabe8e56fd2014-10-09 17:12:44 -04008
kelvin8ec71442015-01-15 16:57:00 -08009Please follow the coding style demonstrated by existing
andrewonlabe8e56fd2014-10-09 17:12:44 -040010functions and document properly.
11
12If you are a contributor to the driver, please
13list your email here for future contact:
14
15jhall@onlab.us
16andrew@onlab.us
17
18OCT 9 2014
Jeremy Songsterae01bba2016-07-11 15:39:17 -070019Modified 2016 by ON.Lab
20
21Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>,
22the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>,
23or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg>
andrewonlabe8e56fd2014-10-09 17:12:44 -040024
kelvin8ec71442015-01-15 16:57:00 -080025"""
Jon Hall05b2b432014-10-08 19:53:25 -040026import time
Jon Hall6801cda2015-07-15 14:13:45 -070027import types
Jon Hall05b2b432014-10-08 19:53:25 -040028import pexpect
kelvin-onlaba4074292015-07-09 15:19:49 -070029import os
Jon Hall6c44c0b2016-04-20 15:21:00 -070030import re
31import subprocess
pingping-lin6d23d9e2015-02-02 16:54:24 -080032from requests.models import Response
Jon Hall05b2b432014-10-08 19:53:25 -040033from drivers.common.clidriver import CLI
34
kelvin8ec71442015-01-15 16:57:00 -080035class OnosDriver( CLI ):
Jon Hall05b2b432014-10-08 19:53:25 -040036
kelvin8ec71442015-01-15 16:57:00 -080037 def __init__( self ):
38 """
39 Initialize client
40 """
Jon Hallefbd9792015-03-05 16:11:36 -080041 self.name = None
42 self.home = None
43 self.handle = None
Jon Hall6c44c0b2016-04-20 15:21:00 -070044 self.nicAddr = None
Devin Limdc78e202017-06-09 18:30:07 -070045 super( OnosDriver, self ).__init__()
kelvin8ec71442015-01-15 16:57:00 -080046
47 def connect( self, **connectargs ):
48 """
Jon Hall05b2b432014-10-08 19:53:25 -040049 Creates ssh handle for ONOS "bench".
kelvin-onlaba4074292015-07-09 15:19:49 -070050 NOTE:
51 The ip_address would come from the topo file using the host tag, the
52 value can be an environment variable as well as a "localhost" to get
53 the ip address needed to ssh to the "bench"
kelvin8ec71442015-01-15 16:57:00 -080054 """
Jon Hall05b2b432014-10-08 19:53:25 -040055 try:
Devin Limdc78e202017-06-09 18:30:07 -070056
Jon Hall05b2b432014-10-08 19:53:25 -040057 for key in connectargs:
kelvin8ec71442015-01-15 16:57:00 -080058 vars( self )[ key ] = connectargs[ key ]
andrew@onlab.us3b087132015-03-11 15:00:08 -070059 self.home = "~/onos"
Jon Hall05b2b432014-10-08 19:53:25 -040060 for key in self.options:
61 if key == "home":
kelvin8ec71442015-01-15 16:57:00 -080062 self.home = self.options[ 'home' ]
Jon Hall05b2b432014-10-08 19:53:25 -040063 break
Jon Hall274b6642015-02-17 11:57:17 -080064 if self.home is None or self.home == "":
Jon Halle94919c2015-03-23 11:42:57 -070065 self.home = "~/onos"
Jon Hall21270ac2015-02-16 17:59:55 -080066
kelvin8ec71442015-01-15 16:57:00 -080067 self.name = self.options[ 'name' ]
kelvin-onlaba4074292015-07-09 15:19:49 -070068
kelvin-onlabc2b79102015-07-14 11:41:20 -070069 # The 'nodes' tag is optional and it is not required in .topo file
kelvin-onlaba4074292015-07-09 15:19:49 -070070 for key in self.options:
71 if key == "nodes":
kelvin-onlabc2b79102015-07-14 11:41:20 -070072 # Maximum number of ONOS nodes to run, if there is any
kelvin-onlaba4074292015-07-09 15:19:49 -070073 self.maxNodes = int( self.options[ 'nodes' ] )
74 break
75 self.maxNodes = None
76
Jeremy Ronquillo82705492017-10-18 14:19:55 -070077 if self.maxNodes is None or self.maxNodes == "":
kelvin-onlabc2b79102015-07-14 11:41:20 -070078 self.maxNodes = 100
kelvin-onlaba4074292015-07-09 15:19:49 -070079
kelvin-onlabc2b79102015-07-14 11:41:20 -070080 # Grabs all OC environment variables based on max number of nodes
kelvin-onlaba4074292015-07-09 15:19:49 -070081 self.onosIps = {} # Dictionary of all possible ONOS ip
82
83 try:
84 if self.maxNodes:
kelvin-onlaba4074292015-07-09 15:19:49 -070085 for i in range( self.maxNodes ):
86 envString = "OC" + str( i + 1 )
kelvin-onlabc2b79102015-07-14 11:41:20 -070087 # If there is no more OC# then break the loop
88 if os.getenv( envString ):
89 self.onosIps[ envString ] = os.getenv( envString )
90 else:
91 self.maxNodes = len( self.onosIps )
92 main.log.info( self.name +
93 ": Created cluster data with " +
94 str( self.maxNodes ) +
95 " maximum number" +
96 " of nodes" )
97 break
kelvin-onlaba4074292015-07-09 15:19:49 -070098
99 if not self.onosIps:
100 main.log.info( "Could not read any environment variable"
101 + " please load a cell file with all" +
102 " onos IP" )
Jon Hall5cf14d52015-07-16 12:15:19 -0700103 self.maxNodes = None
kelvin-onlaba4074292015-07-09 15:19:49 -0700104 else:
105 main.log.info( self.name + ": Found " +
106 str( self.onosIps.values() ) +
107 " ONOS IPs" )
kelvin-onlaba4074292015-07-09 15:19:49 -0700108 except KeyError:
109 main.log.info( "Invalid environment variable" )
110 except Exception as inst:
111 main.log.error( "Uncaught exception: " + str( inst ) )
112
113 try:
Jeremy Ronquillo82705492017-10-18 14:19:55 -0700114 if os.getenv( str( self.ip_address ) ) is not None:
kelvin-onlaba4074292015-07-09 15:19:49 -0700115 self.ip_address = os.getenv( str( self.ip_address ) )
116 else:
117 main.log.info( self.name +
118 ": Trying to connect to " +
119 self.ip_address )
kelvin-onlaba4074292015-07-09 15:19:49 -0700120 except KeyError:
121 main.log.info( "Invalid host name," +
122 " connecting to local host instead" )
123 self.ip_address = 'localhost'
124 except Exception as inst:
125 main.log.error( "Uncaught exception: " + str( inst ) )
126
kelvin8ec71442015-01-15 16:57:00 -0800127 self.handle = super( OnosDriver, self ).connect(
128 user_name=self.user_name,
kelvin-onlab08679eb2015-01-21 16:11:48 -0800129 ip_address=self.ip_address,
kelvin-onlabd3b64892015-01-20 13:26:24 -0800130 port=self.port,
131 pwd=self.pwd,
132 home=self.home )
Jon Hall05b2b432014-10-08 19:53:25 -0400133
Jon Hall05b2b432014-10-08 19:53:25 -0400134 if self.handle:
Jon Hall0fc0d452015-07-14 09:49:58 -0700135 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -0700136 self.handle.expect( self.prompt )
Jon Hall05b2b432014-10-08 19:53:25 -0400137 return self.handle
kelvin8ec71442015-01-15 16:57:00 -0800138 else:
Jon Hall0fc0d452015-07-14 09:49:58 -0700139 main.log.info( "Failed to create ONOS handle" )
Jon Hall05b2b432014-10-08 19:53:25 -0400140 return main.FALSE
141 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800142 main.log.error( self.name + ": EOF exception found" )
143 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700144 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800145 except Exception:
146 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700147 main.cleanAndExit()
Jon Hall05b2b432014-10-08 19:53:25 -0400148
kelvin8ec71442015-01-15 16:57:00 -0800149 def disconnect( self ):
150 """
Jon Hall05b2b432014-10-08 19:53:25 -0400151 Called when Test is complete to disconnect the ONOS handle.
kelvin8ec71442015-01-15 16:57:00 -0800152 """
Jon Halld61331b2015-02-17 16:35:47 -0800153 response = main.TRUE
Jon Hall05b2b432014-10-08 19:53:25 -0400154 try:
Jon Hall61282e32015-03-19 11:34:11 -0700155 if self.handle:
156 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700157 self.handle.expect( self.prompt )
Jon Hall61282e32015-03-19 11:34:11 -0700158 self.handle.sendline( "exit" )
159 self.handle.expect( "closed" )
Jon Hall05b2b432014-10-08 19:53:25 -0400160 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800161 main.log.error( self.name + ": EOF exception found" )
162 main.log.error( self.name + ": " + self.handle.before )
Jon Hall61282e32015-03-19 11:34:11 -0700163 except ValueError:
Jon Hall1a77a1e2015-04-06 10:41:13 -0700164 main.log.exception( "Exception in disconnect of " + self.name )
Jon Hall61282e32015-03-19 11:34:11 -0700165 response = main.TRUE
Jon Hallfebb1c72015-03-05 13:30:09 -0800166 except Exception:
167 main.log.exception( self.name + ": Connection failed to the host" )
Jon Hall05b2b432014-10-08 19:53:25 -0400168 response = main.FALSE
169 return response
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400170
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400171 def getEpochMs( self ):
172 """
173 Returns milliseconds since epoch
Jon Hall4ba53f02015-07-29 13:07:41 -0700174
175 When checking multiple nodes in a for loop,
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +0000176 around a hundred milliseconds of difference (ascending) is
Jon Hall4ba53f02015-07-29 13:07:41 -0700177 generally acceptable due to calltime of the function.
178 Few seconds, however, is not and it means clocks
179 are off sync.
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400180 """
181 try:
182 self.handle.sendline( 'date +%s.%N' )
183 self.handle.expect( 'date \+\%s\.\%N' )
Devin Limdc78e202017-06-09 18:30:07 -0700184 self.handle.expect( self.prompt )
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400185 epochMs = self.handle.before
186 return epochMs
187 except Exception:
188 main.log.exception( 'Uncaught exception getting epoch time' )
Devin Lim44075962017-08-11 10:56:37 -0700189 main.cleanAndExit()
andrew@onlab.usaee415a2015-06-05 14:38:58 -0400190
Jon Hall6c44c0b2016-04-20 15:21:00 -0700191 def onosPackage( self, opTimeout=180 ):
kelvin8ec71442015-01-15 16:57:00 -0800192 """
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400193 Produce a self-contained tar.gz file that can be deployed
Jon Hall64af8502015-12-15 10:09:33 -0800194 and executed on any platform with Java 8 JRE.
kelvin8ec71442015-01-15 16:57:00 -0800195 """
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400196 try:
Jon Hall64af8502015-12-15 10:09:33 -0800197 ret = main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800198 self.handle.sendline( "onos-package" )
199 self.handle.expect( "onos-package" )
Jon Hall96451092016-05-04 09:42:30 -0700200 while True:
201 i = self.handle.expect( [ "Downloading",
202 "Unknown options",
203 "No such file or directory",
204 "tar.gz",
Devin Limc20e79a2017-06-07 10:29:57 -0700205 self.prompt ],
Jon Hall96451092016-05-04 09:42:30 -0700206 opTimeout )
207 handle = str( self.handle.before + self.handle.after )
208 if i == 0:
209 # Give more time to download the file
210 continue # expect again
211 elif i == 1:
212 # Incorrect usage
213 main.log.error( "onos-package does not recognize the given options" )
214 ret = main.FALSE
215 continue # expect again
216 elif i == 2:
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +0000217 # File(s) not found
Jon Hall96451092016-05-04 09:42:30 -0700218 main.log.error( "onos-package could not find a file or directory" )
219 ret = main.FALSE
220 continue # expect again
221 elif i == 3:
222 # tar.gz
223 continue # expect again
224 elif i == 4:
225 # Prompt returned
226 break
Jon Hallc6793552016-01-19 14:18:37 -0800227 main.log.info( "onos-package command returned: " + handle )
kelvin8ec71442015-01-15 16:57:00 -0800228 # As long as the sendline does not time out,
229 # return true. However, be careful to interpret
230 # the results of the onos-package command return
Jon Hall64af8502015-12-15 10:09:33 -0800231 return ret
232 except pexpect.TIMEOUT:
233 main.log.exception( self.name + ": TIMEOUT exception found in onosPackage" )
234 main.log.error( self.name + ": " + self.handle.before )
235 return main.FALSE
andrewonlab7735d852014-10-09 13:02:47 -0400236 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800237 main.log.error( self.name + ": EOF exception found" )
238 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700239 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800240 except Exception:
241 main.log.exception( "Failed to package ONOS" )
Devin Lim44075962017-08-11 10:56:37 -0700242 main.cleanAndExit()
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400243
kelvin-onlabd3b64892015-01-20 13:26:24 -0800244 def onosBuild( self ):
kelvin8ec71442015-01-15 16:57:00 -0800245 """
andrewonlab8790abb2014-11-06 13:51:54 -0500246 Use the pre defined script to build onos via mvn
kelvin8ec71442015-01-15 16:57:00 -0800247 """
andrewonlab8790abb2014-11-06 13:51:54 -0500248 try:
kelvin8ec71442015-01-15 16:57:00 -0800249 self.handle.sendline( "onos-build" )
250 self.handle.expect( "onos-build" )
251 i = self.handle.expect( [
kelvin-onlabd3b64892015-01-20 13:26:24 -0800252 "BUILD SUCCESS",
253 "ERROR",
254 "BUILD FAILED" ],
255 timeout=120 )
kelvin8ec71442015-01-15 16:57:00 -0800256 handle = str( self.handle.before )
Devin Limc20e79a2017-06-07 10:29:57 -0700257 self.handle.expect( self.prompt )
andrewonlab8790abb2014-11-06 13:51:54 -0500258
kelvin8ec71442015-01-15 16:57:00 -0800259 main.log.info( "onos-build command returned: " +
260 handle )
andrewonlab8790abb2014-11-06 13:51:54 -0500261
262 if i == 0:
263 return main.TRUE
264 else:
265 return handle
266
267 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800268 main.log.error( self.name + ": EOF exception found" )
269 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -0800270 except Exception:
271 main.log.exception( "Failed to build ONOS" )
Devin Lim44075962017-08-11 10:56:37 -0700272 main.cleanAndExit()
andrewonlab8790abb2014-11-06 13:51:54 -0500273
shahshreya9f531fe2015-06-10 12:03:51 -0700274 def cleanInstall( self, skipTest=False, mciTimeout=600 ):
kelvin8ec71442015-01-15 16:57:00 -0800275 """
276 Runs mvn clean install in the root of the ONOS directory.
277 This will clean all ONOS artifacts then compile each module
shahshreya9f531fe2015-06-10 12:03:51 -0700278 Optional:
279 skipTest - Does "-DskipTests -Dcheckstyle.skip -U -T 1C" which
280 skip the test. This will make the building faster.
281 Disregarding the credibility of the build
kelvin8ec71442015-01-15 16:57:00 -0800282 Returns: main.TRUE on success
Jon Hallde9d9aa2014-10-08 20:36:02 -0400283 On Failure, exits the test
kelvin8ec71442015-01-15 16:57:00 -0800284 """
Jon Hallde9d9aa2014-10-08 20:36:02 -0400285 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800286 main.log.info( "Running 'mvn clean install' on " +
287 str( self.name ) +
kelvin8ec71442015-01-15 16:57:00 -0800288 ". This may take some time." )
289 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -0700290 self.handle.expect( self.prompt )
Jon Hallea7818b2014-10-09 14:30:59 -0400291
kelvin8ec71442015-01-15 16:57:00 -0800292 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700293 self.handle.expect( self.prompt )
shahshreya9f531fe2015-06-10 12:03:51 -0700294
295 if not skipTest:
296 self.handle.sendline( "mvn clean install" )
297 self.handle.expect( "mvn clean install" )
298 else:
299 self.handle.sendline( "mvn clean install -DskipTests" +
300 " -Dcheckstyle.skip -U -T 1C" )
301 self.handle.expect( "mvn clean install -DskipTests" +
302 " -Dcheckstyle.skip -U -T 1C" )
kelvin8ec71442015-01-15 16:57:00 -0800303 while True:
304 i = self.handle.expect( [
Jon Hall274b6642015-02-17 11:57:17 -0800305 'There\sis\sinsufficient\smemory\sfor\sthe\sJava\s' +
Jon Hallefbd9792015-03-05 16:11:36 -0800306 'Runtime\sEnvironment\sto\scontinue',
Jon Hallde9d9aa2014-10-08 20:36:02 -0400307 'BUILD\sFAILURE',
308 'BUILD\sSUCCESS',
Jeremy Ronquillo82705492017-10-18 14:19:55 -0700309 'onos' + self.prompt, # TODO: fix this to be more generic?
Devin Limdc78e202017-06-09 18:30:07 -0700310 'ONOS' + self.prompt,
pingping-lin57a56ce2015-05-20 16:43:48 -0700311 pexpect.TIMEOUT ], mciTimeout )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400312 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -0800313 main.log.error( self.name + ":There is insufficient memory \
314 for the Java Runtime Environment to continue." )
315 # return main.FALSE
Devin Lim44075962017-08-11 10:56:37 -0700316
317 main.cleanAndExit()
Jon Hallde9d9aa2014-10-08 20:36:02 -0400318 if i == 1:
kelvin8ec71442015-01-15 16:57:00 -0800319 main.log.error( self.name + ": Build failure!" )
320 # return main.FALSE
Devin Lim44075962017-08-11 10:56:37 -0700321
322 main.cleanAndExit()
Jon Hallde9d9aa2014-10-08 20:36:02 -0400323 elif i == 2:
kelvin8ec71442015-01-15 16:57:00 -0800324 main.log.info( self.name + ": Build success!" )
Jon Halle94919c2015-03-23 11:42:57 -0700325 elif i == 3 or i == 4:
kelvin8ec71442015-01-15 16:57:00 -0800326 main.log.info( self.name + ": Build complete" )
327 # Print the build time
Jon Hallf8ef52c2014-10-09 19:37:33 -0400328 for line in self.handle.before.splitlines():
329 if "Total time:" in line:
kelvin8ec71442015-01-15 16:57:00 -0800330 main.log.info( line )
331 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700332 self.handle.expect( self.prompt, timeout=60 )
Jon Hallde9d9aa2014-10-08 20:36:02 -0400333 return main.TRUE
Jon Halle94919c2015-03-23 11:42:57 -0700334 elif i == 5:
kelvin8ec71442015-01-15 16:57:00 -0800335 main.log.error(
336 self.name +
337 ": mvn clean install TIMEOUT!" )
338 # return main.FALSE
Devin Lim44075962017-08-11 10:56:37 -0700339
340 main.cleanAndExit()
Jon Hallde9d9aa2014-10-08 20:36:02 -0400341 else:
Jon Hall274b6642015-02-17 11:57:17 -0800342 main.log.error( self.name + ": unexpected response from " +
Jon Hallefbd9792015-03-05 16:11:36 -0800343 "mvn clean install" )
kelvin8ec71442015-01-15 16:57:00 -0800344 # return main.FALSE
Devin Lim44075962017-08-11 10:56:37 -0700345
346 main.cleanAndExit()
Jon Hallde9d9aa2014-10-08 20:36:02 -0400347 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800348 main.log.error( self.name + ": EOF exception found" )
349 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700350 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800351 except Exception:
352 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700353 main.cleanAndExit()
Jon Hallacabffd2014-10-09 12:36:53 -0400354
Jon Hall3576f572016-08-23 10:01:07 -0700355 def buckBuild( self, timeout=180 ):
356 """
357 Build onos using buck.
358 """
359 try:
360 ret = main.TRUE
361 self.handle.sendline( "buck build onos" )
362 self.handle.expect( "buck build onos" )
363 output = ""
364 while True:
365 i = self.handle.expect( [ "This does not appear to be the root of a Buck project.",
366 "\n",
367 "BUILD FAILED",
Jon Halld9066132018-03-01 14:52:53 -0800368 "no buck in",
Devin Limc20e79a2017-06-07 10:29:57 -0700369 self.prompt ],
Jon Hall3576f572016-08-23 10:01:07 -0700370 timeout=timeout )
371 output += str( self.handle.before + self.handle.after )
372 if i == 0:
373 main.log.error( "Wrong location" )
374 ret = main.FALSE
375 elif i == 1:
376 # end of a line, buck is still printing output
377 pass
378 elif i == 2:
379 # Build failed
380 main.log.error( "Build failed" )
381 ret = main.FALSE
382 elif i == 3:
Jon Halld9066132018-03-01 14:52:53 -0800383 main.log.error( "Could not find buck in your PATH." )
384 ret = main.FALSE
385 elif i == 4:
Jon Hall3576f572016-08-23 10:01:07 -0700386 # Prompt returned
387 break
388 main.log.debug( output )
389 return ret
390 except pexpect.TIMEOUT:
391 main.log.exception( self.name + ": TIMEOUT exception found" )
392 main.log.error( self.name + ": " + self.handle.before )
393 return main.FALSE
394 except pexpect.EOF:
395 main.log.error( self.name + ": EOF exception found" )
396 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700397 main.cleanAndExit()
Jon Hall3576f572016-08-23 10:01:07 -0700398 except Exception:
399 main.log.exception( "Failed to build and package ONOS" )
Devin Lim44075962017-08-11 10:56:37 -0700400 main.cleanAndExit()
Jon Hall3576f572016-08-23 10:01:07 -0700401
Jon Hall61282e32015-03-19 11:34:11 -0700402 def gitPull( self, comp1="", fastForward=True ):
kelvin8ec71442015-01-15 16:57:00 -0800403 """
Jon Hallacabffd2014-10-09 12:36:53 -0400404 Assumes that "git pull" works without login
Jon Hall47a93fb2015-01-06 16:46:06 -0800405
Jon Hall61282e32015-03-19 11:34:11 -0700406 If the fastForward boolean is set to true, only git pulls that can
407 be fast forwarded will be performed. IE if you have not local commits
408 in your branch.
409
Jon Hallacabffd2014-10-09 12:36:53 -0400410 This function will perform a git pull on the ONOS instance.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800411 If used as gitPull( "NODE" ) it will do git pull + NODE. This is
Jon Hallacabffd2014-10-09 12:36:53 -0400412 for the purpose of pulling from other nodes if necessary.
413
Jon Hall47a93fb2015-01-06 16:46:06 -0800414 Otherwise, this function will perform a git pull in the
Jon Hallacabffd2014-10-09 12:36:53 -0400415 ONOS repository. If it has any problems, it will return main.ERROR
kelvin-onlabd3b64892015-01-20 13:26:24 -0800416 If it successfully does a gitPull, it will return a 1 ( main.TRUE )
Shreya Shahee15f6c2014-10-28 18:12:30 -0400417 If it has no updates, it will return 3.
Jon Hallacabffd2014-10-09 12:36:53 -0400418
kelvin8ec71442015-01-15 16:57:00 -0800419 """
Jon Hallacabffd2014-10-09 12:36:53 -0400420 try:
kelvin8ec71442015-01-15 16:57:00 -0800421 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -0700422 self.handle.expect( self.prompt )
Jon Hall61282e32015-03-19 11:34:11 -0700423 cmd = "git pull"
424 if comp1 != "":
Jeremy Ronquillo82705492017-10-18 14:19:55 -0700425 cmd += ' ' + comp1
Jon Hall61282e32015-03-19 11:34:11 -0700426 if fastForward:
427 cmd += ' ' + " --ff-only"
428 self.handle.sendline( cmd )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800429 i = self.handle.expect(
430 [
431 'fatal',
432 'Username\sfor\s(.*):\s',
433 '\sfile(s*) changed,\s',
434 'Already up-to-date',
435 'Aborting',
436 'You\sare\snot\scurrently\son\sa\sbranch',
Jon Hall274b6642015-02-17 11:57:17 -0800437 'You asked me to pull without telling me which branch you',
438 'Pull is not possible because you have unmerged files',
Jon Hall61282e32015-03-19 11:34:11 -0700439 'Please enter a commit message to explain why this merge',
440 'Found a swap file by the name',
441 'Please, commit your changes before you can merge.',
kelvin-onlabd3b64892015-01-20 13:26:24 -0800442 pexpect.TIMEOUT ],
443 timeout=300 )
kelvin8ec71442015-01-15 16:57:00 -0800444 if i == 0:
Jon Hall61282e32015-03-19 11:34:11 -0700445 main.log.error( self.name + ": Git pull had some issue" )
446 output = self.handle.after
Devin Limdc78e202017-06-09 18:30:07 -0700447 self.handle.expect( self.prompt )
Jon Hall61282e32015-03-19 11:34:11 -0700448 output += self.handle.before
449 main.log.warn( output )
Jon Hallacabffd2014-10-09 12:36:53 -0400450 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800451 elif i == 1:
452 main.log.error(
453 self.name +
454 ": Git Pull Asking for username. " )
Jon Hallacabffd2014-10-09 12:36:53 -0400455 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800456 elif i == 2:
457 main.log.info(
458 self.name +
459 ": Git Pull - pulling repository now" )
Devin Limc20e79a2017-06-07 10:29:57 -0700460 self.handle.expect( self.prompt, 120 )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800461 # So that only when git pull is done, we do mvn clean compile
462 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800463 elif i == 3:
464 main.log.info( self.name + ": Git Pull - Already up to date" )
Devin Limc20e79a2017-06-07 10:29:57 -0700465 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800466 elif i == 4:
467 main.log.info(
468 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800469 ": Git Pull - Aborting..." +
470 "Are there conflicting git files?" )
Jon Hallacabffd2014-10-09 12:36:53 -0400471 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800472 elif i == 5:
473 main.log.info(
474 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800475 ": Git Pull - You are not currently " +
476 "on a branch so git pull failed!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400477 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800478 elif i == 6:
479 main.log.info(
480 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800481 ": Git Pull - You have not configured an upstream " +
482 "branch to pull from. Git pull failed!" )
Jon Hallacabffd2014-10-09 12:36:53 -0400483 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800484 elif i == 7:
485 main.log.info(
486 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800487 ": Git Pull - Pull is not possible because " +
488 "you have unmerged files." )
Jon Hallacabffd2014-10-09 12:36:53 -0400489 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800490 elif i == 8:
Jon Hall61282e32015-03-19 11:34:11 -0700491 # NOTE: abandoning test since we can't reliably handle this
492 # there could be different default text editors and we
493 # also don't know if we actually want to make the commit
494 main.log.error( "Git pull resulted in a merge commit message" +
495 ". Exiting test!" )
Devin Lim44075962017-08-11 10:56:37 -0700496
497 main.cleanAndExit()
Jon Hall61282e32015-03-19 11:34:11 -0700498 elif i == 9: # Merge commit message but swap file exists
499 main.log.error( "Git pull resulted in a merge commit message" +
500 " but a swap file exists." )
501 try:
502 self.handle.send( 'A' ) # Abort
Devin Limc20e79a2017-06-07 10:29:57 -0700503 self.handle.expect( self.prompt )
Jon Hall61282e32015-03-19 11:34:11 -0700504 return main.ERROR
505 except Exception:
Jeremy Ronquillo82705492017-10-18 14:19:55 -0700506 main.log.exception( "Couldn't exit editor prompt!" )
Devin Lim44075962017-08-11 10:56:37 -0700507
508 main.cleanAndExit()
Jon Hall61282e32015-03-19 11:34:11 -0700509 elif i == 10: # In the middle of a merge commit
510 main.log.error( "Git branch is in the middle of a merge. " )
511 main.log.warn( self.handle.before + self.handle.after )
512 return main.ERROR
513 elif i == 11:
kelvin8ec71442015-01-15 16:57:00 -0800514 main.log.error( self.name + ": Git Pull - TIMEOUT" )
515 main.log.error(
516 self.name + " Response was: " + str(
517 self.handle.before ) )
Jon Hallacabffd2014-10-09 12:36:53 -0400518 return main.ERROR
519 else:
kelvin8ec71442015-01-15 16:57:00 -0800520 main.log.error(
521 self.name +
522 ": Git Pull - Unexpected response, check for pull errors" )
Jon Hallacabffd2014-10-09 12:36:53 -0400523 return main.ERROR
524 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800525 main.log.error( self.name + ": EOF exception found" )
526 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700527 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800528 except Exception:
529 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700530 main.cleanAndExit()
Jon Hallacabffd2014-10-09 12:36:53 -0400531
kelvin-onlabd3b64892015-01-20 13:26:24 -0800532 def gitCheckout( self, branch="master" ):
kelvin8ec71442015-01-15 16:57:00 -0800533 """
Jon Hallacabffd2014-10-09 12:36:53 -0400534 Assumes that "git pull" works without login
kelvin8ec71442015-01-15 16:57:00 -0800535
Jon Hallacabffd2014-10-09 12:36:53 -0400536 This function will perform a git git checkout on the ONOS instance.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800537 If used as gitCheckout( "branch" ) it will do git checkout
538 of the "branch".
Jon Hallacabffd2014-10-09 12:36:53 -0400539
540 Otherwise, this function will perform a git checkout of the master
kelvin8ec71442015-01-15 16:57:00 -0800541 branch of the ONOS repository. If it has any problems, it will return
542 main.ERROR.
543 If the branch was already the specified branch, or the git checkout was
Jon Hallacabffd2014-10-09 12:36:53 -0400544 successful then the function will return main.TRUE.
545
kelvin8ec71442015-01-15 16:57:00 -0800546 """
Jon Hallacabffd2014-10-09 12:36:53 -0400547 try:
kelvin8ec71442015-01-15 16:57:00 -0800548 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -0700549 self.handle.expect( self.prompt )
Jon Hall274b6642015-02-17 11:57:17 -0800550 main.log.info( self.name +
551 ": Checking out git branch/ref: " + branch + "..." )
kelvin8ec71442015-01-15 16:57:00 -0800552 cmd = "git checkout " + branch
553 self.handle.sendline( cmd )
554 self.handle.expect( cmd )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800555 i = self.handle.expect(
Jon Hall274b6642015-02-17 11:57:17 -0800556 [ 'fatal',
Jon Hall61282e32015-03-19 11:34:11 -0700557 'Username for (.*): ',
558 'Already on \'',
Jon Hall7a8354f2015-06-10 15:37:00 -0700559 'Switched to (a new )?branch \'' + str( branch ),
Jon Hall274b6642015-02-17 11:57:17 -0800560 pexpect.TIMEOUT,
561 'error: Your local changes to the following files' +
Jon Hallefbd9792015-03-05 16:11:36 -0800562 'would be overwritten by checkout:',
Jon Hall274b6642015-02-17 11:57:17 -0800563 'error: you need to resolve your current index first',
564 "You are in 'detached HEAD' state.",
565 "HEAD is now at " ],
kelvin-onlabd3b64892015-01-20 13:26:24 -0800566 timeout=60 )
kelvin8ec71442015-01-15 16:57:00 -0800567 if i == 0:
568 main.log.error(
569 self.name +
570 ": Git checkout had some issue..." )
571 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400572 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800573 elif i == 1:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800574 main.log.error(
575 self.name +
576 ": Git checkout asking for username." +
577 " Please configure your local git repository to be able " +
578 "to access your remote repository passwordlessly" )
Jon Hall274b6642015-02-17 11:57:17 -0800579 # TODO add support for authenticating
Jon Hallacabffd2014-10-09 12:36:53 -0400580 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800581 elif i == 2:
582 main.log.info(
583 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800584 ": Git Checkout %s : Already on this branch" % branch )
Devin Limc20e79a2017-06-07 10:29:57 -0700585 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -0800586 # main.log.info( "DEBUG: after checkout cmd = "+
587 # self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400588 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800589 elif i == 3:
590 main.log.info(
591 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800592 ": Git checkout %s - Switched to this branch" % branch )
Devin Limc20e79a2017-06-07 10:29:57 -0700593 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -0800594 # main.log.info( "DEBUG: after checkout cmd = "+
595 # self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400596 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800597 elif i == 4:
598 main.log.error( self.name + ": Git Checkout- TIMEOUT" )
599 main.log.error(
Jon Hall274b6642015-02-17 11:57:17 -0800600 self.name + " Response was: " + str( self.handle.before ) )
Jon Hallacabffd2014-10-09 12:36:53 -0400601 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800602 elif i == 5:
603 self.handle.expect( "Aborting" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800604 main.log.error(
605 self.name +
606 ": Git checkout error: \n" +
Jon Hall274b6642015-02-17 11:57:17 -0800607 "Your local changes to the following files would" +
608 " be overwritten by checkout:" +
609 str( self.handle.before ) )
Devin Limc20e79a2017-06-07 10:29:57 -0700610 self.handle.expect( self.prompt )
Jon Hall81e29af2014-11-04 20:41:23 -0500611 return main.ERROR
kelvin8ec71442015-01-15 16:57:00 -0800612 elif i == 6:
Jon Hall274b6642015-02-17 11:57:17 -0800613 main.log.error(
614 self.name +
615 ": Git checkout error: \n" +
616 "You need to resolve your current index first:" +
617 str( self.handle.before ) )
Devin Limc20e79a2017-06-07 10:29:57 -0700618 self.handle.expect( self.prompt )
Jon Hall81e29af2014-11-04 20:41:23 -0500619 return main.ERROR
Jon Hall274b6642015-02-17 11:57:17 -0800620 elif i == 7:
621 main.log.info(
622 self.name +
623 ": Git checkout " + str( branch ) +
624 " - You are in 'detached HEAD' state. HEAD is now at " +
625 str( branch ) )
Devin Limc20e79a2017-06-07 10:29:57 -0700626 self.handle.expect( self.prompt )
Jon Hall274b6642015-02-17 11:57:17 -0800627 return main.TRUE
628 elif i == 8: # Already in detached HEAD on the specified commit
629 main.log.info(
630 self.name +
631 ": Git Checkout %s : Already on commit" % branch )
Devin Limc20e79a2017-06-07 10:29:57 -0700632 self.handle.expect( self.prompt )
Jon Hall274b6642015-02-17 11:57:17 -0800633 return main.TRUE
Jon Hallacabffd2014-10-09 12:36:53 -0400634 else:
kelvin8ec71442015-01-15 16:57:00 -0800635 main.log.error(
636 self.name +
Jon Hall274b6642015-02-17 11:57:17 -0800637 ": Git Checkout - Unexpected response, " +
638 "check for pull errors" )
kelvin8ec71442015-01-15 16:57:00 -0800639 main.log.error( self.name + ": " + self.handle.before )
Jon Hallacabffd2014-10-09 12:36:53 -0400640 return main.ERROR
641
642 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800643 main.log.error( self.name + ": EOF exception found" )
644 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700645 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800646 except Exception:
647 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700648 main.cleanAndExit()
andrewonlab95ca1462014-10-09 14:04:24 -0400649
pingping-lin6d23d9e2015-02-02 16:54:24 -0800650 def getBranchName( self ):
You Wang9cdf9a22017-05-01 13:44:18 -0700651 import re
652 try:
653 main.log.info( "self.home = " )
654 main.log.info( self.home )
655 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -0700656 self.handle.expect( self.prompt )
You Wang9cdf9a22017-05-01 13:44:18 -0700657 self.handle.sendline( "git name-rev --name-only HEAD" )
658 self.handle.expect( "git name-rev --name-only HEAD" )
Devin Limc20e79a2017-06-07 10:29:57 -0700659 self.handle.expect( self.prompt )
Jeremy Ronquillo82705492017-10-18 14:19:55 -0700660 lines = self.handle.before.splitlines()
661 if lines[ 1 ] == "master" or re.search( "^onos-\d+(\.\d+)+$", lines[ 1 ] ):
662 return lines[ 1 ]
You Wang9cdf9a22017-05-01 13:44:18 -0700663 else:
Jeremy Ronquillo82705492017-10-18 14:19:55 -0700664 main.log.info( lines[ 1 ] )
You Wang9cdf9a22017-05-01 13:44:18 -0700665 return "unexpected ONOS branch"
666 except pexpect.EOF:
667 main.log.error( self.name + ": EOF exception found" )
668 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700669 main.cleanAndExit()
You Wang9cdf9a22017-05-01 13:44:18 -0700670 except pexpect.TIMEOUT:
671 main.log.error( self.name + ": TIMEOUT exception found" )
672 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700673 main.cleanAndExit()
You Wang9cdf9a22017-05-01 13:44:18 -0700674 except Exception:
675 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700676 main.cleanAndExit()
pingping-lin6d23d9e2015-02-02 16:54:24 -0800677
kelvin-onlabd3b64892015-01-20 13:26:24 -0800678 def getVersion( self, report=False ):
kelvin8ec71442015-01-15 16:57:00 -0800679 """
Jon Hall274b6642015-02-17 11:57:17 -0800680 Writes the COMMIT number to the report to be parsed
Jon Hallefbd9792015-03-05 16:11:36 -0800681 by Jenkins data collector.
kelvin8ec71442015-01-15 16:57:00 -0800682 """
Jon Hall45ec0922014-10-10 19:33:49 -0400683 try:
kelvin8ec71442015-01-15 16:57:00 -0800684 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700685 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -0800686 self.handle.sendline(
687 "cd " +
688 self.home +
Jon Hall274b6642015-02-17 11:57:17 -0800689 "; git log -1 --pretty=fuller --decorate=short | grep -A 6 " +
690 " \"commit\" --color=never" )
kelvin8ec71442015-01-15 16:57:00 -0800691 # NOTE: for some reason there are backspaces inserted in this
692 # phrase when run from Jenkins on some tests
693 self.handle.expect( "never" )
Devin Limc20e79a2017-06-07 10:29:57 -0700694 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -0800695 response = ( self.name + ": \n" + str(
696 self.handle.before + self.handle.after ) )
697 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -0700698 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -0800699 lines = response.splitlines()
Jon Hall45ec0922014-10-10 19:33:49 -0400700 for line in lines:
Jon Hallfd191202014-11-07 18:36:09 -0500701 print line
702 if report:
pingping-lin763ee042015-05-20 17:45:30 -0700703 main.log.wiki( "<blockquote>" )
kelvin8ec71442015-01-15 16:57:00 -0800704 for line in lines[ 2:-1 ]:
705 # Bracket replacement is for Wiki-compliant
706 # formatting. '<' or '>' are interpreted
707 # as xml specific tags that cause errors
708 line = line.replace( "<", "[" )
709 line = line.replace( ">", "]" )
Jeremy Ronquillo82705492017-10-18 14:19:55 -0700710 # main.log.wiki( "\t" + line )
pingping-lin763ee042015-05-20 17:45:30 -0700711 main.log.wiki( line + "<br /> " )
712 main.log.summary( line )
713 main.log.wiki( "</blockquote>" )
Jeremy Ronquillo82705492017-10-18 14:19:55 -0700714 main.log.summary( "\n" )
kelvin8ec71442015-01-15 16:57:00 -0800715 return lines[ 2 ]
Jon Hall45ec0922014-10-10 19:33:49 -0400716 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800717 main.log.error( self.name + ": EOF exception found" )
718 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700719 main.cleanAndExit()
Jon Hall368769f2014-11-19 15:43:35 -0800720 except pexpect.TIMEOUT:
kelvin8ec71442015-01-15 16:57:00 -0800721 main.log.error( self.name + ": TIMEOUT exception found" )
722 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700723 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800724 except Exception:
725 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700726 main.cleanAndExit()
Jon Hall45ec0922014-10-10 19:33:49 -0400727
kelvin-onlabd3b64892015-01-20 13:26:24 -0800728 def createCellFile( self, benchIp, fileName, mnIpAddrs,
Jon Hall810b67d2016-12-05 10:19:01 -0800729 appString, onosIpAddrs, onosUser="sdn", useSSH=True ):
kelvin8ec71442015-01-15 16:57:00 -0800730 """
andrewonlab94282092014-10-10 13:00:11 -0400731 Creates a cell file based on arguments
732 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800733 * Bench IP address ( benchIp )
andrewonlab94282092014-10-10 13:00:11 -0400734 - Needed to copy the cell file over
kelvin-onlabd3b64892015-01-20 13:26:24 -0800735 * File name of the cell file ( fileName )
736 * Mininet IP address ( mnIpAddrs )
kelvin8ec71442015-01-15 16:57:00 -0800737 - Note that only 1 ip address is
andrewonlab94282092014-10-10 13:00:11 -0400738 supported currently
kelvin-onlabd3b64892015-01-20 13:26:24 -0800739 * ONOS IP addresses ( onosIpAddrs )
andrewonlab94282092014-10-10 13:00:11 -0400740 - Must be passed in as last arguments
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +0000741 * ONOS USER (onosUser)
Flavio Castrocc38a542016-03-03 13:15:46 -0800742 - optional argument to set ONOS_USER environment variable
kelvin8ec71442015-01-15 16:57:00 -0800743
andrewonlab94282092014-10-10 13:00:11 -0400744 NOTE: Assumes cells are located at:
745 ~/<self.home>/tools/test/cells/
kelvin8ec71442015-01-15 16:57:00 -0800746 """
andrewonlab94282092014-10-10 13:00:11 -0400747 try:
Devin Lim461f0872017-06-05 16:49:33 -0700748
Jon Hall2c8959e2016-12-16 12:17:34 -0800749 # Variable initialization
750 cellDirectory = self.home + "/tools/test/cells/"
751 # We want to create the cell file in the dependencies directory
752 # of TestON first, then copy over to ONOS bench
753 tempDirectory = "/tmp/"
754 # Create the cell file in the directory for writing ( w+ )
755 cellFile = open( tempDirectory + fileName, 'w+' )
756 if isinstance( onosIpAddrs, types.StringType ):
757 onosIpAddrs = [ onosIpAddrs ]
758
759 # App string is hardcoded environment variables
760 # That you may wish to use by default on startup.
761 # Note that you may not want certain apps listed
762 # on here.
763 appString = "export ONOS_APPS=" + appString
764 onosGroup = "export ONOS_GROUP=" + onosUser
765 onosUser = "export ONOS_USER=" + onosUser
766 if useSSH:
767 onosUseSSH = "export ONOS_USE_SSH=true"
768 mnString = "export OCN="
769 if mnIpAddrs == "":
770 mnString = ""
771 onosString = "export OC"
772 tempCount = 1
773
774 # Create ONOSNIC ip address prefix
775 tempOnosIp = str( onosIpAddrs[ 0 ] )
776 tempList = []
777 tempList = tempOnosIp.split( "." )
778 # Omit last element of list to format for NIC
779 tempList = tempList[ :-1 ]
780 # Structure the nic string ip
781 nicAddr = ".".join( tempList ) + ".*"
782 self.nicAddr = nicAddr
783 onosNicString = "export ONOS_NIC=" + nicAddr
784
kelvin8ec71442015-01-15 16:57:00 -0800785 # Start writing to file
kelvin-onlabd3b64892015-01-20 13:26:24 -0800786 cellFile.write( onosNicString + "\n" )
andrewonlab94282092014-10-10 13:00:11 -0400787
kelvin-onlabd3b64892015-01-20 13:26:24 -0800788 for arg in onosIpAddrs:
789 # For each argument in onosIpAddrs, write to file
kelvin8ec71442015-01-15 16:57:00 -0800790 # Output should look like the following:
andrewonlabd4940492014-10-24 12:21:27 -0400791 # export OC1="10.128.20.11"
792 # export OC2="10.128.20.12"
kelvin-onlabd3b64892015-01-20 13:26:24 -0800793 cellFile.write( onosString + str( tempCount ) +
Jon Hall6f665652015-09-18 10:08:07 -0700794 "=\"" + arg + "\"\n" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800795 tempCount = tempCount + 1
kelvin8ec71442015-01-15 16:57:00 -0800796
Jon Hall6f665652015-09-18 10:08:07 -0700797 cellFile.write( "export OCI=$OC1\n" )
Jon Hallab611372018-02-21 15:26:05 -0800798 if mnString:
799 cellFile.write( mnString + "\"" + str( mnIpAddrs ) + "\"\n" )
cameron@onlab.us75900962015-03-30 13:22:49 -0700800 cellFile.write( appString + "\n" )
Flavio Castrocc38a542016-03-03 13:15:46 -0800801 cellFile.write( onosGroup + "\n" )
802 cellFile.write( onosUser + "\n" )
Pier88189b62016-09-07 17:01:53 -0700803 if useSSH:
804 cellFile.write( onosUseSSH + "\n" )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800805 cellFile.close()
andrewonlab94282092014-10-10 13:00:11 -0400806
kelvin8ec71442015-01-15 16:57:00 -0800807 # We use os.system to send the command to TestON cluster
808 # to account for the case in which TestON is not located
809 # on the same cluster as the ONOS bench
810 # Note that even if TestON is located on the same cluster
811 # as ONOS bench, you must setup passwordless ssh
812 # between TestON and ONOS bench in order to automate the test.
kelvin-onlabc2b79102015-07-14 11:41:20 -0700813 os.system( "scp " + tempDirectory + fileName + " " +
814 self.user_name + "@" + self.ip_address + ":" + cellDirectory )
andrewonlab94282092014-10-10 13:00:11 -0400815
andrewonlab2a6c9342014-10-16 13:40:15 -0400816 return main.TRUE
817
andrewonlab94282092014-10-10 13:00:11 -0400818 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800819 main.log.error( self.name + ": EOF exception found" )
820 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700821 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800822 except Exception:
823 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700824 main.cleanAndExit()
andrewonlab94282092014-10-10 13:00:11 -0400825
kelvin-onlabd3b64892015-01-20 13:26:24 -0800826 def setCell( self, cellname ):
kelvin8ec71442015-01-15 16:57:00 -0800827 """
andrewonlab95ca1462014-10-09 14:04:24 -0400828 Calls 'cell <name>' to set the environment variables on ONOSbench
kelvin8ec71442015-01-15 16:57:00 -0800829 """
andrewonlab95ca1462014-10-09 14:04:24 -0400830 try:
831 if not cellname:
You Wang1cdc5f52017-12-19 16:47:51 -0800832 main.log.error( self.name + ": Must define cellname" )
Devin Lim44075962017-08-11 10:56:37 -0700833 main.cleanAndExit()
andrewonlab95ca1462014-10-09 14:04:24 -0400834 else:
kelvin8ec71442015-01-15 16:57:00 -0800835 self.handle.sendline( "cell " + str( cellname ) )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800836 # Expect the cellname in the ONOSCELL variable.
kelvin8ec71442015-01-15 16:57:00 -0800837 # Note that this variable name is subject to change
andrewonlab95ca1462014-10-09 14:04:24 -0400838 # and that this driver will have to change accordingly
Jon Hall3b489db2015-10-05 14:38:37 -0700839 self.handle.expect( str( cellname ) )
Jon Hallab611372018-02-21 15:26:05 -0800840 response = self.handle.before + self.handle.after
You Wang1cdc5f52017-12-19 16:47:51 -0800841 i = self.handle.expect( [ "No such cell",
Jon Hallab611372018-02-21 15:26:05 -0800842 "command not found",
843 self.prompt ], timeout=10 )
844 response += self.handle.before + self.handle.after
You Wang1cdc5f52017-12-19 16:47:51 -0800845 if i == 0:
Jon Hallab611372018-02-21 15:26:05 -0800846 main.log.error( self.name + ": No such cell. Response: " + str( response ) )
You Wang1cdc5f52017-12-19 16:47:51 -0800847 main.cleanAndExit()
848 elif i == 1:
Jon Hallab611372018-02-21 15:26:05 -0800849 main.log.error( self.name + ": Error setting cell. Response: " + str( response ) )
850 main.cleanAndExit()
You Wang1cdc5f52017-12-19 16:47:51 -0800851 elif i == 2:
Jon Hallab611372018-02-21 15:26:05 -0800852 main.log.info( self.name + ": Successfully set cell: " + str( response ) )
andrewonlab95ca1462014-10-09 14:04:24 -0400853 return main.TRUE
You Wang1cdc5f52017-12-19 16:47:51 -0800854 except pexpect.TIMEOUT:
855 main.log.error( self.name + ": TIMEOUT exception found" )
856 main.log.error( self.name + ": " + self.handle.before )
857 main.cleanAndExit()
andrewonlab95ca1462014-10-09 14:04:24 -0400858 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800859 main.log.error( self.name + ": EOF exception found" )
860 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700861 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800862 except Exception:
863 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700864 main.cleanAndExit()
andrewonlab95ca1462014-10-09 14:04:24 -0400865
kelvin-onlabd3b64892015-01-20 13:26:24 -0800866 def verifyCell( self ):
kelvin8ec71442015-01-15 16:57:00 -0800867 """
andrewonlabc03bf6c2014-10-09 14:56:18 -0400868 Calls 'onos-verify-cell' to check for cell installation
kelvin8ec71442015-01-15 16:57:00 -0800869 """
870 # TODO: Add meaningful expect value
andrewonlab8d0d7d72014-10-09 16:33:15 -0400871
andrewonlabc03bf6c2014-10-09 14:56:18 -0400872 try:
kelvin8ec71442015-01-15 16:57:00 -0800873 # Clean handle by sending empty and expecting $
874 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700875 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -0800876 self.handle.sendline( "onos-verify-cell" )
Devin Limc20e79a2017-06-07 10:29:57 -0700877 self.handle.expect( self.prompt )
kelvin-onlabd3b64892015-01-20 13:26:24 -0800878 handleBefore = self.handle.before
879 handleAfter = self.handle.after
kelvin-onlabd3b64892015-01-20 13:26:24 -0800880 main.log.info( "Verify cell returned: " + handleBefore +
Jon Hall3b489db2015-10-05 14:38:37 -0700881 handleAfter )
andrewonlabc03bf6c2014-10-09 14:56:18 -0400882 return main.TRUE
Jon Halla5cb6172015-02-23 09:28:28 -0800883 except pexpect.ExceptionPexpect as e:
Jon Hall3b489db2015-10-05 14:38:37 -0700884 main.log.exception( self.name + ": Pexpect exception found: " )
kelvin8ec71442015-01-15 16:57:00 -0800885 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700886 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800887 except Exception:
888 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700889 main.cleanAndExit()
Jon Hall7993bfc2014-10-09 16:30:14 -0400890
jenkins1e99e7b2015-04-02 18:15:39 -0700891 def onosCfgSet( self, ONOSIp, configName, configParam ):
892 """
893 Uses 'onos <node-ip> cfg set' to change a parameter value of an
Jon Hall4ba53f02015-07-29 13:07:41 -0700894 application.
895
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +0000896 ex)
jenkins1e99e7b2015-04-02 18:15:39 -0700897 onos 10.0.0.1 cfg set org.onosproject.myapp appSetting 1
jenkins1e99e7b2015-04-02 18:15:39 -0700898 ONOSIp = '10.0.0.1'
899 configName = 'org.onosproject.myapp'
900 configParam = 'appSetting 1'
jenkins1e99e7b2015-04-02 18:15:39 -0700901 """
Jon Hall72280bc2016-01-25 14:29:05 -0800902 try:
903 cfgStr = "onos {} cfg set {} {}".format( ONOSIp,
904 configName,
905 configParam )
906 self.handle.sendline( "" )
907 self.handle.expect( ":~" )
908 self.handle.sendline( cfgStr )
Jeremy Ronquillo82705492017-10-18 14:19:55 -0700909 self.handle.expect( "cfg set" )
Jon Hall72280bc2016-01-25 14:29:05 -0800910 self.handle.expect( ":~" )
jenkins1e99e7b2015-04-02 18:15:39 -0700911
Jeremy Ronquillo82705492017-10-18 14:19:55 -0700912 paramValue = configParam.split( " " )[ 1 ]
913 paramName = configParam.split( " " )[ 0 ]
Jon Hall4ba53f02015-07-29 13:07:41 -0700914
Jon Hall72280bc2016-01-25 14:29:05 -0800915 checkStr = 'onos {} cfg get " {} {} " '.format( ONOSIp, configName, paramName )
Jon Hall4ba53f02015-07-29 13:07:41 -0700916
Jon Hall72280bc2016-01-25 14:29:05 -0800917 self.handle.sendline( checkStr )
918 self.handle.expect( ":~" )
jenkins1e99e7b2015-04-02 18:15:39 -0700919
Jon Hall72280bc2016-01-25 14:29:05 -0800920 if "value=" + paramValue + "," in self.handle.before:
Jeremy Ronquillo82705492017-10-18 14:19:55 -0700921 main.log.info( "cfg " + configName + " successfully set to " + configParam )
Jon Hall72280bc2016-01-25 14:29:05 -0800922 return main.TRUE
923 except pexpect.ExceptionPexpect as e:
924 main.log.exception( self.name + ": Pexpect exception found: " )
925 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700926 main.cleanAndExit()
Jon Hall72280bc2016-01-25 14:29:05 -0800927 except Exception:
928 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700929 main.cleanAndExit()
Jon Hall4ba53f02015-07-29 13:07:41 -0700930
kelvin-onlabd3b64892015-01-20 13:26:24 -0800931 def onosCli( self, ONOSIp, cmdstr ):
kelvin8ec71442015-01-15 16:57:00 -0800932 """
andrewonlab05e362f2014-10-10 00:40:57 -0400933 Uses 'onos' command to send various ONOS CLI arguments.
934 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800935 * ONOSIp: specify the ip of the cell machine
andrewonlab94282092014-10-10 13:00:11 -0400936 * cmdstr: specify the command string to send
kelvin8ec71442015-01-15 16:57:00 -0800937
938 This function is intended to expose the entire karaf
andrewonlab6e20c342014-10-10 18:08:48 -0400939 CLI commands for ONOS. Try to use this function first
940 before attempting to write a ONOS CLI specific driver
kelvin8ec71442015-01-15 16:57:00 -0800941 function.
942 You can see a list of available 'cmdstr' arguments
andrewonlab6e20c342014-10-10 18:08:48 -0400943 by starting onos, and typing in 'onos' to enter the
944 onos> CLI. Then, type 'help' to see the list of
kelvin8ec71442015-01-15 16:57:00 -0800945 available commands.
946 """
andrewonlab05e362f2014-10-10 00:40:57 -0400947 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -0800948 if not ONOSIp:
kelvin8ec71442015-01-15 16:57:00 -0800949 main.log.error( "You must specify the IP address" )
andrewonlab05e362f2014-10-10 00:40:57 -0400950 return main.FALSE
951 if not cmdstr:
kelvin8ec71442015-01-15 16:57:00 -0800952 main.log.error( "You must specify the command string" )
andrewonlab05e362f2014-10-10 00:40:57 -0400953 return main.FALSE
954
kelvin8ec71442015-01-15 16:57:00 -0800955 cmdstr = str( cmdstr )
956 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700957 self.handle.expect( self.prompt )
andrewonlab05e362f2014-10-10 00:40:57 -0400958
You Wangdd3dae52018-02-15 13:31:25 -0800959 self.handle.sendline( "onos-wait-for-start " + ONOSIp )
960 self.handle.expect( self.prompt )
961
962 self.handle.sendline( "onos " + ONOSIp + " " + cmdstr )
Devin Limc20e79a2017-06-07 10:29:57 -0700963 self.handle.expect( self.prompt )
andrewonlab05e362f2014-10-10 00:40:57 -0400964
kelvin-onlabd3b64892015-01-20 13:26:24 -0800965 handleBefore = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -0800966 main.log.info( "Command sent successfully" )
kelvin8ec71442015-01-15 16:57:00 -0800967 # Obtain return handle that consists of result from
968 # the onos command. The string may need to be
969 # configured further.
kelvin-onlabd3b64892015-01-20 13:26:24 -0800970 returnString = handleBefore
kelvin-onlabd3b64892015-01-20 13:26:24 -0800971 return returnString
andrewonlab05e362f2014-10-10 00:40:57 -0400972 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -0800973 main.log.error( self.name + ": EOF exception found" )
974 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -0700975 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -0800976 except Exception:
977 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -0700978 main.cleanAndExit()
Jon Hall7993bfc2014-10-09 16:30:14 -0400979
Jeremy Ronquillo82705492017-10-18 14:19:55 -0700980 def onosSecureSSH( self, userName="onos", userPWD="rocks", node="" ):
Pier88189b62016-09-07 17:01:53 -0700981 """
982 Enables secure access to ONOS console
983 by removing default users & keys.
984
985 onos-secure-ssh -u onos -p rocks node
986
987 Returns: main.TRUE on success and main.FALSE on failure
988 """
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +0000989
Pier88189b62016-09-07 17:01:53 -0700990 try:
Chiyu Chengef109502016-11-21 15:51:38 -0800991 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -0700992 self.handle.expect( self.prompt )
Pier88189b62016-09-07 17:01:53 -0700993 self.handle.sendline( " onos-secure-ssh -u " + userName + " -p " + userPWD + " " + node )
994
995 # NOTE: this timeout may need to change depending on the network
996 # and size of ONOS
997 # TODO: Handle the other possible error
Jeremy Ronquillo82705492017-10-18 14:19:55 -0700998 i = self.handle.expect( [ "Network\sis\sunreachable",
999 self.prompt,
1000 pexpect.TIMEOUT ], timeout=180 )
Pier88189b62016-09-07 17:01:53 -07001001 if i == 0:
1002 # can't reach ONOS node
1003 main.log.warn( "Network is unreachable" )
Devin Limc20e79a2017-06-07 10:29:57 -07001004 self.handle.expect( self.prompt )
Pier88189b62016-09-07 17:01:53 -07001005 return main.FALSE
1006 elif i == 1:
1007 # Process started
1008 main.log.info(
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001009 "Secure SSH performed on " +
1010 node )
Pier88189b62016-09-07 17:01:53 -07001011 return main.TRUE
1012 except pexpect.EOF:
1013 main.log.error( self.name + ": EOF exception found" )
1014 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001015 main.cleanAndExit()
Pier88189b62016-09-07 17:01:53 -07001016 except Exception:
1017 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001018 main.cleanAndExit()
Pier88189b62016-09-07 17:01:53 -07001019
kelvin-onlabd3b64892015-01-20 13:26:24 -08001020 def onosInstall( self, options="-f", node="" ):
kelvin8ec71442015-01-15 16:57:00 -08001021 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001022 Installs ONOS bits on the designated cell machine.
kelvin8ec71442015-01-15 16:57:00 -08001023 If -f option is provided, it also forces an uninstall.
1024 Presently, install also includes onos-push-bits and
Jon Hall7993bfc2014-10-09 16:30:14 -04001025 onos-config within.
kelvin8ec71442015-01-15 16:57:00 -08001026 The node option allows you to selectively only push the jar
Jon Hall7993bfc2014-10-09 16:30:14 -04001027 files to certain onos nodes
1028
1029 Returns: main.TRUE on success and main.FALSE on failure
kelvin8ec71442015-01-15 16:57:00 -08001030 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001031 try:
andrewonlab114768a2014-11-14 12:44:44 -05001032 if options:
kelvin8ec71442015-01-15 16:57:00 -08001033 self.handle.sendline( "onos-install " + options + " " + node )
andrewonlab114768a2014-11-14 12:44:44 -05001034 else:
kelvin8ec71442015-01-15 16:57:00 -08001035 self.handle.sendline( "onos-install " + node )
1036 self.handle.expect( "onos-install " )
1037 # NOTE: this timeout may need to change depending on the network
1038 # and size of ONOS
1039 i = self.handle.expect( [ "Network\sis\sunreachable",
kelvin-onlabd3b64892015-01-20 13:26:24 -08001040 "onos\sstart/running,\sprocess",
kelvin8ec71442015-01-15 16:57:00 -08001041 "ONOS\sis\salready\sinstalled",
Jeremyc72b2582016-02-26 18:27:38 -08001042 "already\sup-to-date",
Jon Hall3576f572016-08-23 10:01:07 -07001043 "does not exist",
Devin Limc20e79a2017-06-07 10:29:57 -07001044 self.prompt,
Jon Hall6c44c0b2016-04-20 15:21:00 -07001045 pexpect.TIMEOUT ], timeout=180 )
Jon Hall7993bfc2014-10-09 16:30:14 -04001046 if i == 0:
Jon Hall3576f572016-08-23 10:01:07 -07001047 # can't reach ONOS node
kelvin8ec71442015-01-15 16:57:00 -08001048 main.log.warn( "Network is unreachable" )
Devin Limc20e79a2017-06-07 10:29:57 -07001049 self.handle.expect( self.prompt )
Jon Hall7993bfc2014-10-09 16:30:14 -04001050 return main.FALSE
1051 elif i == 1:
Jon Hall3576f572016-08-23 10:01:07 -07001052 # Process started
kelvin8ec71442015-01-15 16:57:00 -08001053 main.log.info(
1054 "ONOS was installed on " +
1055 node +
1056 " and started" )
Devin Limc20e79a2017-06-07 10:29:57 -07001057 self.handle.expect( self.prompt )
Jon Hall7993bfc2014-10-09 16:30:14 -04001058 return main.TRUE
Jon Hall3576f572016-08-23 10:01:07 -07001059 elif i == 2 or i == 3:
1060 # same bits are already on ONOS node
Jeremyc72b2582016-02-26 18:27:38 -08001061 main.log.info( "ONOS is already installed on " + node )
Devin Limc20e79a2017-06-07 10:29:57 -07001062 self.handle.expect( self.prompt )
Jeremyc72b2582016-02-26 18:27:38 -08001063 return main.TRUE
1064 elif i == 4:
Jon Hall3576f572016-08-23 10:01:07 -07001065 # onos not packaged
1066 main.log.error( "ONOS package not found." )
Devin Limc20e79a2017-06-07 10:29:57 -07001067 self.handle.expect( self.prompt )
Jon Hall3576f572016-08-23 10:01:07 -07001068 return main.FALSE
1069 elif i == 5:
1070 # prompt
Jeremyc72b2582016-02-26 18:27:38 -08001071 main.log.info( "ONOS was installed on " + node )
1072 return main.TRUE
Jon Hall3576f572016-08-23 10:01:07 -07001073 elif i == 6:
1074 # timeout
kelvin8ec71442015-01-15 16:57:00 -08001075 main.log.info(
1076 "Installation of ONOS on " +
1077 node +
1078 " timed out" )
Devin Limc20e79a2017-06-07 10:29:57 -07001079 self.handle.expect( self.prompt )
Jon Hall53c5e662016-04-13 16:06:56 -07001080 main.log.warn( self.handle.before )
Jon Hall7993bfc2014-10-09 16:30:14 -04001081 return main.FALSE
andrewonlabc03bf6c2014-10-09 14:56:18 -04001082 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001083 main.log.error( self.name + ": EOF exception found" )
1084 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001085 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001086 except Exception:
1087 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001088 main.cleanAndExit()
andrewonlab95ca1462014-10-09 14:04:24 -04001089
kelvin-onlabd3b64892015-01-20 13:26:24 -08001090 def onosStart( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001091 """
andrewonlab8d0d7d72014-10-09 16:33:15 -04001092 Calls onos command: 'onos-service [<node-ip>] start'
andrewonlabe8e56fd2014-10-09 17:12:44 -04001093 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -08001094 """
andrewonlab8d0d7d72014-10-09 16:33:15 -04001095 try:
kelvin8ec71442015-01-15 16:57:00 -08001096 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001097 self.handle.expect( self.prompt )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001098 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001099 " start" )
1100 i = self.handle.expect( [
andrewonlab8d0d7d72014-10-09 16:33:15 -04001101 "Job\sis\salready\srunning",
1102 "start/running",
Devin Limc20e79a2017-06-07 10:29:57 -07001103 self.prompt,
andrewonlab8d0d7d72014-10-09 16:33:15 -04001104 "Unknown\sinstance",
Jeremy Songster14c13572016-04-21 17:34:03 -07001105 pexpect.TIMEOUT ], timeout=180 )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001106 if i == 0:
Devin Limc20e79a2017-06-07 10:29:57 -07001107 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -08001108 main.log.info( "Service is already running" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001109 return main.TRUE
1110 elif i == 1:
Devin Limc20e79a2017-06-07 10:29:57 -07001111 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -08001112 main.log.info( "ONOS service started" )
andrewonlab8d0d7d72014-10-09 16:33:15 -04001113 return main.TRUE
Jeremyd0e9a6d2016-03-02 11:28:52 -08001114 elif i == 2:
1115 main.log.info( "ONOS service started" )
1116 return main.TRUE
andrewonlab8d0d7d72014-10-09 16:33:15 -04001117 else:
Devin Limc20e79a2017-06-07 10:29:57 -07001118 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -08001119 main.log.error( "ONOS service failed to start" )
Devin Lim44075962017-08-11 10:56:37 -07001120
1121 main.cleanAndExit()
andrewonlab8d0d7d72014-10-09 16:33:15 -04001122 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001123 main.log.error( self.name + ": EOF exception found" )
1124 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001125 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001126 except Exception:
1127 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001128 main.cleanAndExit()
andrewonlab8d0d7d72014-10-09 16:33:15 -04001129
kelvin-onlabd3b64892015-01-20 13:26:24 -08001130 def onosStop( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001131 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001132 Calls onos command: 'onos-service [<node-ip>] stop'
andrewonlabe8e56fd2014-10-09 17:12:44 -04001133 This command is a remote management of the ONOS upstart daemon
kelvin8ec71442015-01-15 16:57:00 -08001134 """
andrewonlab2b30bd32014-10-09 16:48:55 -04001135 try:
kelvin8ec71442015-01-15 16:57:00 -08001136 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001137 self.handle.expect( self.prompt )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001138 self.handle.sendline( "onos-service " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001139 " stop" )
1140 i = self.handle.expect( [
andrewonlab2b30bd32014-10-09 16:48:55 -04001141 "stop/waiting",
Jon Hall61282e32015-03-19 11:34:11 -07001142 "Could not resolve hostname",
andrewonlab2b30bd32014-10-09 16:48:55 -04001143 "Unknown\sinstance",
Devin Limc20e79a2017-06-07 10:29:57 -07001144 self.prompt,
Jeremy Songster14c13572016-04-21 17:34:03 -07001145 pexpect.TIMEOUT ], timeout=180 )
andrewonlab2b30bd32014-10-09 16:48:55 -04001146 if i == 0:
Devin Limc20e79a2017-06-07 10:29:57 -07001147 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -08001148 main.log.info( "ONOS service stopped" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001149 return main.TRUE
1150 elif i == 1:
Devin Limc20e79a2017-06-07 10:29:57 -07001151 self.handle.expect( self.prompt )
Jon Hall65844a32015-03-09 19:09:37 -07001152 main.log.info( "onosStop() Unknown ONOS instance specified: " +
kelvin-onlabd3b64892015-01-20 13:26:24 -08001153 str( nodeIp ) )
andrewonlab2b30bd32014-10-09 16:48:55 -04001154 return main.FALSE
Jon Hall61282e32015-03-19 11:34:11 -07001155 elif i == 2:
Devin Limc20e79a2017-06-07 10:29:57 -07001156 self.handle.expect( self.prompt )
Jon Hall61282e32015-03-19 11:34:11 -07001157 main.log.warn( "ONOS wasn't running" )
1158 return main.TRUE
YPZhang77badfc2016-03-09 10:28:59 -08001159 elif i == 3:
1160 main.log.info( "ONOS service stopped" )
1161 return main.TRUE
andrewonlab2b30bd32014-10-09 16:48:55 -04001162 else:
kelvin8ec71442015-01-15 16:57:00 -08001163 main.log.error( "ONOS service failed to stop" )
andrewonlab2b30bd32014-10-09 16:48:55 -04001164 return main.FALSE
andrewonlab2b30bd32014-10-09 16:48:55 -04001165 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001166 main.log.error( self.name + ": EOF exception found" )
1167 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001168 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001169 except Exception:
1170 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001171 main.cleanAndExit()
kelvin8ec71442015-01-15 16:57:00 -08001172
kelvin-onlabd3b64892015-01-20 13:26:24 -08001173 def onosUninstall( self, nodeIp="" ):
kelvin8ec71442015-01-15 16:57:00 -08001174 """
andrewonlabc8d47972014-10-09 16:52:36 -04001175 Calls the command: 'onos-uninstall'
kelvin8ec71442015-01-15 16:57:00 -08001176 Uninstalls ONOS from the designated cell machine, stopping
andrewonlabe8e56fd2014-10-09 17:12:44 -04001177 if needed
kelvin8ec71442015-01-15 16:57:00 -08001178 """
andrewonlabc8d47972014-10-09 16:52:36 -04001179 try:
kelvin8ec71442015-01-15 16:57:00 -08001180 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001181 self.handle.expect( self.prompt, timeout=180 )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001182 self.handle.sendline( "onos-uninstall " + str( nodeIp ) )
Devin Limc20e79a2017-06-07 10:29:57 -07001183 self.handle.expect( self.prompt, timeout=180 )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001184 main.log.info( "ONOS " + nodeIp + " was uninstalled" )
kelvin8ec71442015-01-15 16:57:00 -08001185 # onos-uninstall command does not return any text
andrewonlabc8d47972014-10-09 16:52:36 -04001186 return main.TRUE
pingping-lin763ee042015-05-20 17:45:30 -07001187 except pexpect.TIMEOUT:
1188 main.log.exception( self.name + ": Timeout in onosUninstall" )
1189 return main.FALSE
andrewonlabc8d47972014-10-09 16:52:36 -04001190 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001191 main.log.error( self.name + ": EOF exception found" )
1192 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001193 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001194 except Exception:
1195 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001196 main.cleanAndExit()
andrewonlab2b30bd32014-10-09 16:48:55 -04001197
kelvin-onlabd3b64892015-01-20 13:26:24 -08001198 def onosDie( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001199 """
andrewonlabaedc8332014-12-04 12:43:03 -05001200 Issues the command 'onos-die <node-ip>'
1201 This command calls onos-kill and also stops the node
kelvin8ec71442015-01-15 16:57:00 -08001202 """
andrewonlabaedc8332014-12-04 12:43:03 -05001203 try:
kelvin8ec71442015-01-15 16:57:00 -08001204 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001205 self.handle.expect( self.prompt )
Jeremyf0aecdb2016-03-30 13:19:57 -07001206 cmdStr = "onos-die " + str( nodeIp )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001207 self.handle.sendline( cmdStr )
kelvin8ec71442015-01-15 16:57:00 -08001208 i = self.handle.expect( [
andrewonlabaedc8332014-12-04 12:43:03 -05001209 "Killing\sONOS",
1210 "ONOS\sprocess\sis\snot\srunning",
Jeremy Songster14c13572016-04-21 17:34:03 -07001211 pexpect.TIMEOUT ], timeout=60 )
andrewonlabaedc8332014-12-04 12:43:03 -05001212 if i == 0:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001213 main.log.info( "ONOS instance " + str( nodeIp ) +
kelvin8ec71442015-01-15 16:57:00 -08001214 " was killed and stopped" )
Jon Hall53c5e662016-04-13 16:06:56 -07001215 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001216 self.handle.expect( self.prompt )
andrewonlabaedc8332014-12-04 12:43:03 -05001217 return main.TRUE
1218 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001219 main.log.info( "ONOS process was not running" )
Jon Hall53c5e662016-04-13 16:06:56 -07001220 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001221 self.handle.expect( self.prompt )
andrewonlabaedc8332014-12-04 12:43:03 -05001222 return main.FALSE
1223 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001224 main.log.error( self.name + ": EOF exception found" )
1225 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001226 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001227 except Exception:
1228 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001229 main.cleanAndExit()
andrewonlabaedc8332014-12-04 12:43:03 -05001230
kelvin-onlabd3b64892015-01-20 13:26:24 -08001231 def onosKill( self, nodeIp ):
kelvin8ec71442015-01-15 16:57:00 -08001232 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001233 Calls the command: 'onos-kill [<node-ip>]'
1234 "Remotely, and unceremoniously kills the ONOS instance running on
1235 the specified cell machine" - Tom V
kelvin8ec71442015-01-15 16:57:00 -08001236 """
andrewonlabe8e56fd2014-10-09 17:12:44 -04001237 try:
kelvin8ec71442015-01-15 16:57:00 -08001238 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001239 self.handle.expect( self.prompt )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001240 self.handle.sendline( "onos-kill " + str( nodeIp ) )
kelvin8ec71442015-01-15 16:57:00 -08001241 i = self.handle.expect( [
Devin Limc20e79a2017-06-07 10:29:57 -07001242 self.prompt,
andrewonlabe8e56fd2014-10-09 17:12:44 -04001243 "No\sroute\sto\shost",
1244 "password:",
Jeremy Songster14c13572016-04-21 17:34:03 -07001245 pexpect.TIMEOUT ], timeout=60 )
kelvin8ec71442015-01-15 16:57:00 -08001246
andrewonlabe8e56fd2014-10-09 17:12:44 -04001247 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001248 main.log.info(
1249 "ONOS instance " + str(
kelvin-onlabd3b64892015-01-20 13:26:24 -08001250 nodeIp ) + " was killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001251 return main.TRUE
1252 elif i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001253 main.log.info( "No route to host" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001254 return main.FALSE
1255 elif i == 2:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001256 main.log.info(
1257 "Passwordless login for host: " +
1258 str( nodeIp ) +
1259 " not configured" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001260 return main.FALSE
1261 else:
Jon Hallefbd9792015-03-05 16:11:36 -08001262 main.log.info( "ONOS instance was not killed" )
andrewonlabe8e56fd2014-10-09 17:12:44 -04001263 return main.FALSE
kelvin8ec71442015-01-15 16:57:00 -08001264
andrewonlabe8e56fd2014-10-09 17:12:44 -04001265 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001266 main.log.error( self.name + ": EOF exception found" )
1267 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001268 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001269 except Exception:
1270 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001271 main.cleanAndExit()
andrewonlabe8e56fd2014-10-09 17:12:44 -04001272
kelvin-onlabd3b64892015-01-20 13:26:24 -08001273 def onosRemoveRaftLogs( self ):
kelvin8ec71442015-01-15 16:57:00 -08001274 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001275 Removes Raft / Copy cat files from ONOS to ensure
Jon Hallfcc88622014-11-25 13:09:54 -05001276 a cleaner environment.
1277
andrewonlab19fbdca2014-11-14 12:55:59 -05001278 Description:
Jon Hallfcc88622014-11-25 13:09:54 -05001279 Stops all ONOS defined in the cell,
andrewonlab19fbdca2014-11-14 12:55:59 -05001280 wipes the raft / copycat log files
kelvin8ec71442015-01-15 16:57:00 -08001281 """
andrewonlab19fbdca2014-11-14 12:55:59 -05001282 try:
kelvin8ec71442015-01-15 16:57:00 -08001283 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001284 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -08001285 self.handle.sendline( "onos-remove-raft-logs" )
1286 # Sometimes this command hangs
Devin Limc20e79a2017-06-07 10:29:57 -07001287 i = self.handle.expect( [ self.prompt, pexpect.TIMEOUT ],
kelvin8ec71442015-01-15 16:57:00 -08001288 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001289 if i == 1:
Devin Limc20e79a2017-06-07 10:29:57 -07001290 i = self.handle.expect( [ self.prompt, pexpect.TIMEOUT ],
kelvin8ec71442015-01-15 16:57:00 -08001291 timeout=120 )
Jon Hallfcc88622014-11-25 13:09:54 -05001292 if i == 1:
1293 return main.FALSE
andrewonlab19fbdca2014-11-14 12:55:59 -05001294 return main.TRUE
andrewonlab19fbdca2014-11-14 12:55:59 -05001295 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001296 main.log.error( self.name + ": EOF exception found" )
1297 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001298 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001299 except Exception:
1300 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001301 main.cleanAndExit()
Jon Hallfcc88622014-11-25 13:09:54 -05001302
kelvin-onlabd3b64892015-01-20 13:26:24 -08001303 def onosStartNetwork( self, mntopo ):
kelvin8ec71442015-01-15 16:57:00 -08001304 """
1305 Calls the command 'onos-start-network [ <mininet-topo> ]
1306 "remotely starts the specified topology on the cell's
andrewonlab94282092014-10-10 13:00:11 -04001307 mininet machine against all controllers configured in the
kelvin8ec71442015-01-15 16:57:00 -08001308 cell."
andrewonlab94282092014-10-10 13:00:11 -04001309 * Specify mininet topology file name for mntopo
1310 * Topo files should be placed at:
1311 ~/<your-onos-directory>/tools/test/topos
kelvin8ec71442015-01-15 16:57:00 -08001312
andrewonlab94282092014-10-10 13:00:11 -04001313 NOTE: This function will take you to the mininet prompt
kelvin8ec71442015-01-15 16:57:00 -08001314 """
andrewonlab94282092014-10-10 13:00:11 -04001315 try:
1316 if not mntopo:
kelvin8ec71442015-01-15 16:57:00 -08001317 main.log.error( "You must specify a topo file to execute" )
andrewonlab94282092014-10-10 13:00:11 -04001318 return main.FALSE
andrewonlab94282092014-10-10 13:00:11 -04001319
kelvin8ec71442015-01-15 16:57:00 -08001320 mntopo = str( mntopo )
1321 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001322 self.handle.expect( self.prompt )
andrewonlab94282092014-10-10 13:00:11 -04001323
kelvin8ec71442015-01-15 16:57:00 -08001324 self.handle.sendline( "onos-start-network " + mntopo )
1325 self.handle.expect( "mininet>" )
1326 main.log.info( "Network started, entered mininet prompt" )
1327
1328 # TODO: Think about whether return is necessary or not
andrewonlab94282092014-10-10 13:00:11 -04001329
1330 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001331 main.log.error( self.name + ": EOF exception found" )
1332 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001333 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001334 except Exception:
1335 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001336 main.cleanAndExit()
andrewonlab94282092014-10-10 13:00:11 -04001337
Jeremy Songster14c13572016-04-21 17:34:03 -07001338 def isup( self, node="", timeout=240 ):
kelvin8ec71442015-01-15 16:57:00 -08001339 """
1340 Run's onos-wait-for-start which only returns once ONOS is at run
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001341 level 100(ready for use)
andrewonlab8d0d7d72014-10-09 16:33:15 -04001342
Jon Hall7993bfc2014-10-09 16:30:14 -04001343 Returns: main.TRUE if ONOS is running and main.FALSE on timeout
kelvin8ec71442015-01-15 16:57:00 -08001344 """
Jon Hall7993bfc2014-10-09 16:30:14 -04001345 try:
Jon Hall3b489db2015-10-05 14:38:37 -07001346 self.handle.sendline( "onos-wait-for-start " + node )
1347 self.handle.expect( "onos-wait-for-start" )
kelvin8ec71442015-01-15 16:57:00 -08001348 # NOTE: this timeout is arbitrary"
Jon Hallcababf72018-02-05 12:05:19 -08001349 i = self.handle.expect( [ self.prompt, pexpect.TIMEOUT, "Password:" ], timeout )
Jon Hall7993bfc2014-10-09 16:30:14 -04001350 if i == 0:
kelvin8ec71442015-01-15 16:57:00 -08001351 main.log.info( self.name + ": " + node + " is up" )
Jon Hall7993bfc2014-10-09 16:30:14 -04001352 return main.TRUE
Jon Hallcababf72018-02-05 12:05:19 -08001353 elif i == 1 or i == 2:
kelvin8ec71442015-01-15 16:57:00 -08001354 # NOTE: since this function won't return until ONOS is ready,
Jon Hall7993bfc2014-10-09 16:30:14 -04001355 # we will kill it on timeout
Jon Hallcababf72018-02-05 12:05:19 -08001356 if i == 1:
1357 main.log.error( "ONOS has not started yet" )
1358 elif i == 2:
1359 main.log.error( "Cannot login to ONOS CLI, try using onos-secure-ssh" )
kelvin8ec71442015-01-15 16:57:00 -08001360 self.handle.send( "\x03" ) # Control-C
Devin Limc20e79a2017-06-07 10:29:57 -07001361 self.handle.expect( self.prompt )
Jon Hall7993bfc2014-10-09 16:30:14 -04001362 return main.FALSE
1363 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001364 main.log.error( self.name + ": EOF exception found" )
1365 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001366 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001367 except Exception:
1368 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001369 main.cleanAndExit()
andrewonlab05e362f2014-10-10 00:40:57 -04001370
Devin Lim142b5342017-07-20 15:22:39 -07001371 def preventAutoRespawn( self ):
1372 """
1373 Description:
1374 This will prevent ONOSservice to automatically
1375 respawn.
1376 """
1377 try:
1378 self.handle.sendline( "sed -i -e 's/^respawn$/#respawn/g' tools/package/init/onos.conf" )
1379 self.handle.expect( "\$" ) # $ from the command
1380 self.handle.sendline( "sed -i -e 's/^Restart=always/Restart=no/g' tools/package/init/onos.service" )
1381 self.handle.expect( "\$" ) # $ from the command
1382 self.handle.expect( "\$" ) # $ from the prompt
1383 except pexpect.EOF:
1384 main.log.error( self.name + ": EOF exception found" )
1385 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001386 main.cleanAndExit()
Devin Lim142b5342017-07-20 15:22:39 -07001387 except Exception:
1388 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001389 main.cleanAndExit()
Devin Lim142b5342017-07-20 15:22:39 -07001390
kelvin-onlabd3b64892015-01-20 13:26:24 -08001391 def pushTestIntentsShell(
1392 self,
1393 dpidSrc,
1394 dpidDst,
1395 numIntents,
1396 dirFile,
1397 onosIp,
1398 numMult="",
1399 appId="",
1400 report=True,
1401 options="" ):
kelvin8ec71442015-01-15 16:57:00 -08001402 """
andrewonlabb66dfa12014-12-02 15:51:10 -05001403 Description:
kelvin8ec71442015-01-15 16:57:00 -08001404 Use the linux prompt to push test intents to
andrewonlabb66dfa12014-12-02 15:51:10 -05001405 better parallelize the results than the CLI
1406 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001407 * dpidSrc: specify source dpid
1408 * dpidDst: specify destination dpid
1409 * numIntents: specify number of intents to push
1410 * dirFile: specify directory and file name to save
andrewonlabb66dfa12014-12-02 15:51:10 -05001411 results
kelvin-onlabd3b64892015-01-20 13:26:24 -08001412 * onosIp: specify the IP of ONOS to install on
kelvin8ec71442015-01-15 16:57:00 -08001413 NOTE:
andrewonlabb66dfa12014-12-02 15:51:10 -05001414 You must invoke this command at linux shell prompt
kelvin8ec71442015-01-15 16:57:00 -08001415 """
1416 try:
1417 # Create the string to sendline
andrewonlabaedc8332014-12-04 12:43:03 -05001418 if options:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001419 baseCmd = "onos " + str( onosIp ) + " push-test-intents " +\
kelvin8ec71442015-01-15 16:57:00 -08001420 options + " "
andrewonlabaedc8332014-12-04 12:43:03 -05001421 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001422 baseCmd = "onos " + str( onosIp ) + " push-test-intents "
kelvin8ec71442015-01-15 16:57:00 -08001423
kelvin-onlabd3b64892015-01-20 13:26:24 -08001424 addDpid = baseCmd + str( dpidSrc ) + " " + str( dpidDst )
1425 if not numMult:
1426 addIntents = addDpid + " " + str( numIntents )
1427 elif numMult:
1428 addIntents = addDpid + " " + str( numIntents ) + " " +\
1429 str( numMult )
1430 if appId:
1431 addApp = addIntents + " " + str( appId )
andrewonlabb66dfa12014-12-02 15:51:10 -05001432 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001433 addApp = addIntents
andrewonlabb66dfa12014-12-02 15:51:10 -05001434
andrewonlabaedc8332014-12-04 12:43:03 -05001435 if report:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001436 sendCmd = addApp + " > " + str( dirFile ) + " &"
andrewonlabaedc8332014-12-04 12:43:03 -05001437 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001438 sendCmd = addApp + " &"
1439 main.log.info( "Send cmd: " + sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001440
kelvin-onlabd3b64892015-01-20 13:26:24 -08001441 self.handle.sendline( sendCmd )
andrewonlabb66dfa12014-12-02 15:51:10 -05001442
1443 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001444 main.log.error( self.name + ": EOF exception found" )
1445 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001446 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001447 except Exception:
1448 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001449 main.cleanAndExit()
andrewonlab05e362f2014-10-10 00:40:57 -04001450
kelvin-onlabd3b64892015-01-20 13:26:24 -08001451 def tsharkPcap( self, interface, dirFile ):
kelvin8ec71442015-01-15 16:57:00 -08001452 """
andrewonlab970399c2014-11-07 13:09:32 -05001453 Capture all packet activity and store in specified
1454 directory/file
1455
1456 Required:
1457 * interface: interface to capture
1458 * dir: directory/filename to store pcap
kelvin8ec71442015-01-15 16:57:00 -08001459 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001460 try:
1461 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001462 self.handle.expect( self.prompt )
andrewonlab970399c2014-11-07 13:09:32 -05001463
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001464 self.handle.sendline( "tshark -i " + str( interface ) + " -t e -w " + str( dirFile ) + " &" )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001465 self.handle.sendline( "\n" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001466 self.handle.expect( "Capturing on" )
Jon Hall5ec6b1b2015-09-17 18:20:14 -07001467 self.handle.sendline( "\n" )
Devin Limc20e79a2017-06-07 10:29:57 -07001468 self.handle.expect( self.prompt )
andrewonlab970399c2014-11-07 13:09:32 -05001469
Jon Hallfebb1c72015-03-05 13:30:09 -08001470 main.log.info( "Tshark started capturing files on " +
1471 str( interface ) + " and saving to directory: " +
1472 str( dirFile ) )
1473 except pexpect.EOF:
1474 main.log.error( self.name + ": EOF exception found" )
1475 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001476 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001477 except Exception:
1478 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001479 main.cleanAndExit()
Shreya Shaha73aaad2014-10-27 18:03:09 -04001480
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001481 def onosTopoCfg( self, onosIp, jsonFile ):
kelvin8ec71442015-01-15 16:57:00 -08001482 """
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001483 Description:
1484 Execute onos-topo-cfg command
1485 Required:
1486 onosIp - IP of the onos node you want to send the json to
1487 jsonFile - File path of the json file
1488 Return:
1489 Returns main.TRUE if the command is successfull; Returns
1490 main.FALSE if there was an error
kelvin8ec71442015-01-15 16:57:00 -08001491 """
shahshreyae6c7cf42014-11-26 16:39:01 -08001492 try:
kelvin8ec71442015-01-15 16:57:00 -08001493 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001494 self.handle.expect( self.prompt )
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001495 cmd = "onos-topo-cfg "
1496 self.handle.sendline( cmd + str( onosIp ) + " " + jsonFile )
1497 handle = self.handle.before
1498 print handle
1499 if "Error" in handle:
1500 main.log.error( self.name + ": " + self.handle.before )
1501 return main.FALSE
1502 else:
Devin Limc20e79a2017-06-07 10:29:57 -07001503 self.handle.expect( self.prompt )
kelvin-onlabd9e23de2015-08-06 10:34:44 -07001504 return main.TRUE
1505
Jon Hallfebb1c72015-03-05 13:30:09 -08001506 except pexpect.EOF:
1507 main.log.error( self.name + ": EOF exception found" )
1508 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001509 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001510 except Exception:
1511 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001512 main.cleanAndExit()
kelvin8ec71442015-01-15 16:57:00 -08001513
jenkins1e99e7b2015-04-02 18:15:39 -07001514 def tsharkGrep( self, grep, directory, interface='eth0', grepOptions='' ):
kelvin8ec71442015-01-15 16:57:00 -08001515 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001516 Required:
kelvin8ec71442015-01-15 16:57:00 -08001517 * grep string
andrewonlabba44bcf2014-10-16 16:54:41 -04001518 * directory to store results
1519 Optional:
1520 * interface - default: eth0
Jon Hall4ba53f02015-07-29 13:07:41 -07001521 * grepOptions - options for grep
andrewonlabba44bcf2014-10-16 16:54:41 -04001522 Description:
1523 Uses tshark command to grep specific group of packets
1524 and stores the results to specified directory.
kelvin8ec71442015-01-15 16:57:00 -08001525 The timestamp is hardcoded to be in epoch
1526 """
Jon Hallfebb1c72015-03-05 13:30:09 -08001527 try:
1528 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001529 self.handle.expect( self.prompt )
Jon Hallfebb1c72015-03-05 13:30:09 -08001530 self.handle.sendline( "" )
jenkins1e99e7b2015-04-02 18:15:39 -07001531 if grepOptions:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001532 grepStr = "grep " + str( grepOptions )
jenkins1e99e7b2015-04-02 18:15:39 -07001533 else:
1534 grepStr = "grep"
Jon Hall4ba53f02015-07-29 13:07:41 -07001535
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001536 cmd = (
1537 "sudo tshark -i " +
Jon Hallfebb1c72015-03-05 13:30:09 -08001538 str( interface ) +
jenkins1e99e7b2015-04-02 18:15:39 -07001539 " -t e | " +
1540 grepStr + " --line-buffered \"" +
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001541 str( grep ) +
Jon Hallfebb1c72015-03-05 13:30:09 -08001542 "\" >" +
1543 directory +
1544 " &" )
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001545 self.handle.sendline( cmd )
1546 main.log.info( cmd )
Jon Hallfebb1c72015-03-05 13:30:09 -08001547 self.handle.expect( "Capturing on" )
cameron@onlab.us21106ea2015-07-23 15:32:51 -07001548 self.handle.sendline( "\n" )
Devin Limc20e79a2017-06-07 10:29:57 -07001549 self.handle.expect( self.prompt )
Jon Hallfebb1c72015-03-05 13:30:09 -08001550 except pexpect.EOF:
1551 main.log.error( self.name + ": EOF exception found" )
1552 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001553 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001554 except Exception:
1555 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001556 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001557
kelvin-onlabd3b64892015-01-20 13:26:24 -08001558 def tsharkStop( self ):
kelvin8ec71442015-01-15 16:57:00 -08001559 """
andrewonlabba44bcf2014-10-16 16:54:41 -04001560 Removes wireshark files from /tmp and kills all tshark processes
kelvin8ec71442015-01-15 16:57:00 -08001561 """
1562 # Remove all pcap from previous captures
Jon Hallfebb1c72015-03-05 13:30:09 -08001563 try:
1564 self.execute( cmd="sudo rm /tmp/wireshark*" )
1565 self.handle.sendline( "" )
Jon Hallefbd9792015-03-05 16:11:36 -08001566 self.handle.sendline( "sudo kill -9 `ps -ef | grep \"tshark -i\"" +
1567 " | grep -v grep | awk '{print $2}'`" )
Jon Hallfebb1c72015-03-05 13:30:09 -08001568 self.handle.sendline( "" )
1569 main.log.info( "Tshark stopped" )
1570 except pexpect.EOF:
1571 main.log.error( self.name + ": EOF exception found" )
1572 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001573 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001574 except Exception:
1575 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001576 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001577
kelvin8ec71442015-01-15 16:57:00 -08001578 def ptpd( self, args ):
1579 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001580 Initiate ptp with user-specified args.
1581 Required:
1582 * args: specify string of args after command
1583 'sudo ptpd'
kelvin8ec71442015-01-15 16:57:00 -08001584 """
andrewonlab0c38a4a2014-10-28 18:35:35 -04001585 try:
kelvin8ec71442015-01-15 16:57:00 -08001586 self.handle.sendline( "sudo ptpd " + str( args ) )
1587 i = self.handle.expect( [
andrewonlab0c38a4a2014-10-28 18:35:35 -04001588 "Multiple",
1589 "Error",
Devin Limc20e79a2017-06-07 10:29:57 -07001590 self.prompt ] )
1591 self.handle.expect( self.prompt )
andrewonlabba44bcf2014-10-16 16:54:41 -04001592
andrewonlab0c38a4a2014-10-28 18:35:35 -04001593 if i == 0:
1594 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001595 main.log.info( "ptpd returned an error: " +
1596 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001597 return handle
1598 elif i == 1:
1599 handle = self.handle.before
kelvin8ec71442015-01-15 16:57:00 -08001600 main.log.error( "ptpd returned an error: " +
1601 str( handle ) )
andrewonlab0c38a4a2014-10-28 18:35:35 -04001602 return handle
1603 else:
1604 return main.TRUE
kelvin8ec71442015-01-15 16:57:00 -08001605
andrewonlab0c38a4a2014-10-28 18:35:35 -04001606 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001607 main.log.error( self.name + ": EOF exception found" )
1608 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001609 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001610 except Exception:
1611 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001612 main.cleanAndExit()
andrewonlabba44bcf2014-10-16 16:54:41 -04001613
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001614 def dumpONOSCmd( self, ONOSIp, CMD, destDir, filename, options="" ):
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001615 """
Pier50f0bc62016-09-07 17:53:40 -07001616 Dump Cmd to a desired directory.
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001617 For debugging purposes, you may want to use
Pier50f0bc62016-09-07 17:53:40 -07001618 this function to capture Cmd at a given point in time.
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001619 Localtime will be attached to the filename
1620
1621 Required:
1622 * ONOSIp: the IP of the target ONOS instance
Pier50f0bc62016-09-07 17:53:40 -07001623 * CMD: the command to dump;
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001624 * destDir: specify directory to copy to.
1625 ex ) /tmp/
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001626 * fileName: Name of the file
Pier50f0bc62016-09-07 17:53:40 -07001627 * options: Options for ONOS command
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001628 """
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001629
Flavio Castrod2ffffa2016-04-26 15:56:56 -07001630 localtime = time.strftime( '%x %X' )
1631 localtime = localtime.replace( "/", "" )
1632 localtime = localtime.replace( " ", "_" )
1633 localtime = localtime.replace( ":", "" )
1634 if destDir[ -1: ] != "/":
1635 destDir += "/"
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001636 cmd = CMD + " " + options + " > " + str( destDir ) + str( filename ) + localtime
1637 return self.onosCli( ONOSIp, cmd )
Flavio Castrob7718952016-05-18 08:53:41 -07001638
kelvin-onlabd3b64892015-01-20 13:26:24 -08001639 def cpLogsToDir( self, logToCopy,
Jon Hallefbd9792015-03-05 16:11:36 -08001640 destDir, copyFileName="" ):
kelvin8ec71442015-01-15 16:57:00 -08001641 """
1642 Copies logs to a desired directory.
andrewonlab5d7a8f32014-11-10 13:07:56 -05001643 Current implementation of ONOS deletes its karaf
1644 logs on every iteration. For debugging purposes,
kelvin8ec71442015-01-15 16:57:00 -08001645 you may want to use this function to capture
1646 certain karaf logs. ( or any other logs if needed )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001647 Localtime will be attached to the filename
1648
1649 Required:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001650 * logToCopy: specify directory and log name to
andrewonlab5d7a8f32014-11-10 13:07:56 -05001651 copy.
kelvin8ec71442015-01-15 16:57:00 -08001652 ex ) /opt/onos/log/karaf.log.1
kelvin-onlabd3b64892015-01-20 13:26:24 -08001653 For copying multiple files, leave copyFileName
1654 empty and only specify destDir -
kelvin8ec71442015-01-15 16:57:00 -08001655 ex ) /opt/onos/log/karaf*
kelvin-onlabd3b64892015-01-20 13:26:24 -08001656 * destDir: specify directory to copy to.
kelvin8ec71442015-01-15 16:57:00 -08001657 ex ) /tmp/
1658 Optional:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001659 * copyFileName: If you want to rename the log
1660 file, specify copyFileName. This will not work
andrewonlab5d7a8f32014-11-10 13:07:56 -05001661 with multiple file copying
kelvin8ec71442015-01-15 16:57:00 -08001662 """
andrewonlab5d7a8f32014-11-10 13:07:56 -05001663 try:
Flavio Castro09ab59d2016-05-25 17:01:35 -07001664 localtime = time.strftime( '%H %M' )
kelvin8ec71442015-01-15 16:57:00 -08001665 localtime = localtime.replace( "/", "" )
1666 localtime = localtime.replace( " ", "_" )
1667 localtime = localtime.replace( ":", "" )
kelvin-onlabd3b64892015-01-20 13:26:24 -08001668 if destDir[ -1: ] != "/":
1669 destDir += "/"
andrewonlab5d7a8f32014-11-10 13:07:56 -05001670
kelvin-onlabd3b64892015-01-20 13:26:24 -08001671 if copyFileName:
Jon Hallfebb1c72015-03-05 13:30:09 -08001672 self.handle.sendline( "cp " + str( logToCopy ) + " " +
1673 str( destDir ) + str( copyFileName ) +
1674 localtime )
kelvin8ec71442015-01-15 16:57:00 -08001675 self.handle.expect( "cp" )
Devin Limc20e79a2017-06-07 10:29:57 -07001676 self.handle.expect( self.prompt )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001677 else:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001678 self.handle.sendline( "cp " + str( logToCopy ) +
1679 " " + str( destDir ) )
kelvin8ec71442015-01-15 16:57:00 -08001680 self.handle.expect( "cp" )
Devin Limc20e79a2017-06-07 10:29:57 -07001681 self.handle.expect( self.prompt )
andrewonlab5d7a8f32014-11-10 13:07:56 -05001682
kelvin8ec71442015-01-15 16:57:00 -08001683 return self.handle.before
1684
1685 except pexpect.EOF:
1686 main.log.error( "Copying files failed" )
1687 main.log.error( self.name + ": EOF exception found" )
1688 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001689 except Exception:
1690 main.log.exception( "Copying files failed" )
1691
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001692 def checkLogs( self, onosIp, restart=False ):
kelvin8ec71442015-01-15 16:57:00 -08001693 """
Jon Hall94fd0472014-12-08 11:52:42 -08001694 runs onos-check-logs on the given onos node
Jon Hall80daded2015-05-27 16:07:00 -07001695 If restart is True, use the old version of onos-check-logs which
1696 does not print the full stacktrace, but shows the entire log file,
1697 including across restarts
Jon Hall94fd0472014-12-08 11:52:42 -08001698 returns the response
kelvin8ec71442015-01-15 16:57:00 -08001699 """
Jon Hall94fd0472014-12-08 11:52:42 -08001700 try:
kelvin-onlabd3b64892015-01-20 13:26:24 -08001701 cmd = "onos-check-logs " + str( onosIp )
Jon Hall16b72c42015-05-20 10:23:36 -07001702 if restart:
1703 cmd += " old"
kelvin8ec71442015-01-15 16:57:00 -08001704 self.handle.sendline( cmd )
1705 self.handle.expect( cmd )
Devin Limdc78e202017-06-09 18:30:07 -07001706 self.handle.expect( self.prompt + " " )
Jon Hall94fd0472014-12-08 11:52:42 -08001707 response = self.handle.before
1708 return response
1709 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001710 main.log.error( "Lost ssh connection" )
1711 main.log.error( self.name + ": EOF exception found" )
1712 main.log.error( self.name + ": " + self.handle.before )
Jon Hallfebb1c72015-03-05 13:30:09 -08001713 except Exception:
1714 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001715 main.cleanAndExit()
Jon Hall94fd0472014-12-08 11:52:42 -08001716
kelvin-onlabd3b64892015-01-20 13:26:24 -08001717 def onosStatus( self, node="" ):
kelvin8ec71442015-01-15 16:57:00 -08001718 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001719 Calls onos command: 'onos-service [<node-ip>] status'
kelvin8ec71442015-01-15 16:57:00 -08001720 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001721 try:
kelvin8ec71442015-01-15 16:57:00 -08001722 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001723 self.handle.expect( self.prompt )
kelvin8ec71442015-01-15 16:57:00 -08001724 self.handle.sendline( "onos-service " + str( node ) +
1725 " status" )
1726 i = self.handle.expect( [
You Wangef1e6572016-03-08 12:53:18 -08001727 "start/running",
You Wang7bd83062016-03-01 11:50:00 -08001728 "Running ...",
You Wangef1e6572016-03-08 12:53:18 -08001729 "stop/waiting",
You Wang7bd83062016-03-01 11:50:00 -08001730 "Not Running ...",
kelvin8ec71442015-01-15 16:57:00 -08001731 pexpect.TIMEOUT ], timeout=120 )
YPZhangfebf7302016-05-24 16:45:56 -07001732 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001733 self.handle.expect( self.prompt )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001734
You Wangef1e6572016-03-08 12:53:18 -08001735 if i == 0 or i == 1:
kelvin8ec71442015-01-15 16:57:00 -08001736 main.log.info( "ONOS is running" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001737 return main.TRUE
You Wangef1e6572016-03-08 12:53:18 -08001738 elif i == 2 or i == 3:
kelvin8ec71442015-01-15 16:57:00 -08001739 main.log.info( "ONOS is stopped" )
kelvin8ec71442015-01-15 16:57:00 -08001740 main.log.error( "ONOS service failed to check the status" )
Devin Lim44075962017-08-11 10:56:37 -07001741
1742 main.cleanAndExit()
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001743 except pexpect.EOF:
kelvin8ec71442015-01-15 16:57:00 -08001744 main.log.error( self.name + ": EOF exception found" )
1745 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001746 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001747 except Exception:
1748 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001749 main.cleanAndExit()
Jon Hall21270ac2015-02-16 17:59:55 -08001750
Jon Hall63604932015-02-26 17:09:50 -08001751 def setIpTables( self, ip, port='', action='add', packet_type='',
1752 direction='INPUT', rule='DROP', states=True ):
Jon Hallefbd9792015-03-05 16:11:36 -08001753 """
Jon Hall21270ac2015-02-16 17:59:55 -08001754 Description:
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001755 add or remove iptables rule to DROP (default) packets from
Jon Hall21270ac2015-02-16 17:59:55 -08001756 specific IP and PORT
1757 Usage:
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001758 * specify action ('add' or 'remove')
Jon Hall21270ac2015-02-16 17:59:55 -08001759 when removing, pass in the same argument as you would add. It will
1760 delete that specific rule.
1761 * specify the ip to block
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001762 * specify the destination port to block (defaults to all ports)
1763 * optional packet type to block (default tcp)
1764 * optional iptables rule (default DROP)
1765 * optional direction to block (default 'INPUT')
Jon Hall63604932015-02-26 17:09:50 -08001766 * States boolean toggles adding all supported tcp states to the
1767 firewall rule
Jon Hall21270ac2015-02-16 17:59:55 -08001768 Returns:
1769 main.TRUE on success or
1770 main.FALSE if given invalid input or
1771 main.ERROR if there is an error in response from iptables
1772 WARNING:
1773 * This function uses root privilege iptables command which may result
1774 in unwanted network errors. USE WITH CAUTION
Jon Hallefbd9792015-03-05 16:11:36 -08001775 """
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001776
Jon Hall21270ac2015-02-16 17:59:55 -08001777 # NOTE*********
1778 # The strict checking methods of this driver function is intentional
1779 # to discourage any misuse or error of iptables, which can cause
1780 # severe network errors
1781 # *************
1782
1783 # NOTE: Sleep needed to give some time for rule to be added and
1784 # registered to the instance. If you are calling this function
1785 # multiple times this sleep will prevent any errors.
1786 # DO NOT REMOVE
Jon Hall63604932015-02-26 17:09:50 -08001787 # time.sleep( 5 )
Jon Hall21270ac2015-02-16 17:59:55 -08001788 try:
1789 # input validation
1790 action_type = action.lower()
1791 rule = rule.upper()
1792 direction = direction.upper()
1793 if action_type != 'add' and action_type != 'remove':
1794 main.log.error( "Invalid action type. Use 'add' or "
1795 "'remove' table rule" )
1796 if rule != 'DROP' and rule != 'ACCEPT' and rule != 'LOG':
1797 # NOTE Currently only supports rules DROP, ACCEPT, and LOG
1798 main.log.error( "Invalid rule. Valid rules are 'DROP' or "
1799 "'ACCEPT' or 'LOG' only." )
1800 if direction != 'INPUT' and direction != 'OUTPUT':
1801 # NOTE currently only supports rules INPUT and OUPTUT
1802 main.log.error( "Invalid rule. Valid directions are"
1803 " 'OUTPUT' or 'INPUT'" )
1804 return main.FALSE
1805 return main.FALSE
1806 return main.FALSE
1807 if action_type == 'add':
1808 # -A is the 'append' action of iptables
1809 actionFlag = '-A'
1810 elif action_type == 'remove':
1811 # -D is the 'delete' rule of iptables
1812 actionFlag = '-D'
1813 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001814 self.handle.expect( self.prompt )
Jon Hall21270ac2015-02-16 17:59:55 -08001815 cmd = "sudo iptables " + actionFlag + " " +\
1816 direction +\
Jon Hall21270ac2015-02-16 17:59:55 -08001817 " -s " + str( ip )
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001818 # " -p " + str( packet_type ) +\
Jon Hall63604932015-02-26 17:09:50 -08001819 if packet_type:
1820 cmd += " -p " + str( packet_type )
Jon Hall21270ac2015-02-16 17:59:55 -08001821 if port:
1822 cmd += " --dport " + str( port )
Jon Hall63604932015-02-26 17:09:50 -08001823 if states:
1824 cmd += " -m state --state="
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001825 # FIXME- Allow user to configure which states to block
Jon Hall63604932015-02-26 17:09:50 -08001826 cmd += "INVALID,ESTABLISHED,NEW,RELATED,UNTRACKED"
Jon Hall21270ac2015-02-16 17:59:55 -08001827 cmd += " -j " + str( rule )
1828
1829 self.handle.sendline( cmd )
Devin Limc20e79a2017-06-07 10:29:57 -07001830 self.handle.expect( self.prompt )
Jon Hall21270ac2015-02-16 17:59:55 -08001831 main.log.warn( self.handle.before )
1832
1833 info_string = "On " + str( self.name )
1834 info_string += " " + str( action_type )
1835 info_string += " iptable rule [ "
1836 info_string += " IP: " + str( ip )
1837 info_string += " Port: " + str( port )
1838 info_string += " Rule: " + str( rule )
1839 info_string += " Direction: " + str( direction ) + " ]"
1840 main.log.info( info_string )
1841 return main.TRUE
1842 except pexpect.TIMEOUT:
1843 main.log.exception( self.name + ": Timeout exception in "
1844 "setIpTables function" )
1845 return main.ERROR
1846 except pexpect.EOF:
1847 main.log.error( self.name + ": EOF exception found" )
1848 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001849 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001850 except Exception:
1851 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001852 main.cleanAndExit()
Jon Hall21270ac2015-02-16 17:59:55 -08001853
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001854 def detailed_status( self, log_filename ):
Jon Hallefbd9792015-03-05 16:11:36 -08001855 """
Jon Hall0468b042015-02-19 19:08:21 -08001856 This method is used by STS to check the status of the controller
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001857 Reports RUNNING, STARTING, STOPPED, FROZEN, ERROR (and reason)
Jon Hallefbd9792015-03-05 16:11:36 -08001858 """
Jon Hall0468b042015-02-19 19:08:21 -08001859 import re
1860 try:
1861 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07001862 self.handle.expect( self.prompt )
Jon Hall0468b042015-02-19 19:08:21 -08001863 self.handle.sendline( "cd " + self.home )
Devin Limc20e79a2017-06-07 10:29:57 -07001864 self.handle.expect( self.prompt )
Jon Hall0468b042015-02-19 19:08:21 -08001865 self.handle.sendline( "service onos status" )
Devin Limc20e79a2017-06-07 10:29:57 -07001866 self.handle.expect( self.prompt )
Jon Hall0468b042015-02-19 19:08:21 -08001867 response = self.handle.before
1868 if re.search( "onos start/running", response ):
1869 # onos start/running, process 10457
1870 return 'RUNNING'
1871 # FIXME: Implement this case
1872 # elif re.search( pattern, response ):
1873 # return 'STARTING'
1874 elif re.search( "onos stop/", response ):
1875 # onos stop/waiting
1876 # FIXME handle this differently?: onos stop/pre-stop
1877 return 'STOPPED'
1878 # FIXME: Implement this case
1879 # elif re.search( pattern, response ):
1880 # return 'FROZEN'
1881 else:
1882 main.log.warn( self.name +
Jon Hallefbd9792015-03-05 16:11:36 -08001883 " WARNING: status received unknown response" )
Jon Hall0468b042015-02-19 19:08:21 -08001884 main.log.warn( response )
1885 return 'ERROR', "Unknown response: %s" % response
1886 except pexpect.TIMEOUT:
1887 main.log.exception( self.name + ": Timeout exception in "
1888 "setIpTables function" )
1889 return 'ERROR', "Pexpect Timeout"
1890 except pexpect.EOF:
1891 main.log.error( self.name + ": EOF exception found" )
1892 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07001893 main.cleanAndExit()
Jon Hallfebb1c72015-03-05 13:30:09 -08001894 except Exception:
1895 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07001896 main.cleanAndExit()
Jon Hall0468b042015-02-19 19:08:21 -08001897
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001898 def createLinkGraphFile( self, benchIp, ONOSIpList, deviceCount ):
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001899 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07001900 Create/formats the LinkGraph.cfg file based on arguments
1901 -only creates a linear topology and connects islands
1902 -evenly distributes devices
andrew@onlab.us3b087132015-03-11 15:00:08 -07001903 -must be called by ONOSbench
1904
Jon Hall4ba53f02015-07-29 13:07:41 -07001905 ONOSIpList - list of all of the node IPs to be used
1906
1907 deviceCount - number of switches to be assigned
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001908 '''
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001909 main.log.info( "Creating link graph configuration file." )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001910 linkGraphPath = self.home + "/tools/package/etc/linkGraph.cfg"
Jon Hall4ba53f02015-07-29 13:07:41 -07001911 tempFile = "/tmp/linkGraph.cfg"
andrew@onlab.us3b087132015-03-11 15:00:08 -07001912
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001913 linkGraph = open( tempFile, 'w+' )
1914 linkGraph.write( "# NullLinkProvider topology description (config file).\n" )
1915 linkGraph.write( "# The NodeId is only added if the destination is another node's device.\n" )
1916 linkGraph.write( "# Bugs: Comments cannot be appended to a line to be read.\n" )
Jon Hall4ba53f02015-07-29 13:07:41 -07001917
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001918 clusterCount = len( ONOSIpList )
Jon Hall4ba53f02015-07-29 13:07:41 -07001919
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001920 if isinstance( deviceCount, int ) or isinstance( deviceCount, str ):
1921 deviceCount = int( deviceCount )
1922 switchList = [ 0 ]*( clusterCount+1 )
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001923 baselineSwitchCount = deviceCount/clusterCount
Jon Hall4ba53f02015-07-29 13:07:41 -07001924
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001925 for node in range( 1, clusterCount + 1 ):
1926 switchList[ node ] = baselineSwitchCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001927
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001928 for node in range( 1, ( deviceCount % clusterCount )+1 ):
1929 switchList[ node ] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07001930
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001931 if isinstance( deviceCount, list ):
1932 main.log.info( "Using provided device distribution" )
1933 switchList = [ 0 ]
andrew@onlab.us3b087132015-03-11 15:00:08 -07001934 for i in deviceCount:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001935 switchList.append( int( i ) )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001936
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001937 tempList = [ '0' ]
1938 tempList.extend( ONOSIpList )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001939 ONOSIpList = tempList
1940
1941 myPort = 6
1942 lastSwitch = 0
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001943 for node in range( 1, clusterCount+1 ):
1944 if switchList[ node ] == 0:
andrew@onlab.us3b087132015-03-11 15:00:08 -07001945 continue
1946
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001947 linkGraph.write( "graph " + ONOSIpList[ node ] + " {\n" )
Jon Hall4ba53f02015-07-29 13:07:41 -07001948
andrew@onlab.us3b087132015-03-11 15:00:08 -07001949 if node > 1:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001950 # connect to last device on previous node
1951 line = ( "\t0:5 -> " + str( lastSwitch ) + ":6:" + lastIp + "\n" ) # ONOSIpList[node-1]
1952 linkGraph.write( line )
Jon Hall4ba53f02015-07-29 13:07:41 -07001953
1954 lastSwitch = 0
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001955 for switch in range( 0, switchList[ node ]-1 ):
andrew@onlab.us3b087132015-03-11 15:00:08 -07001956 line = ""
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001957 line = ( "\t" + str( switch ) + ":" + str( myPort ) )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001958 line += " -- "
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001959 line += ( str( switch+1 ) + ":" + str( myPort-1 ) + "\n" )
1960 linkGraph.write( line )
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001961 lastSwitch = switch+1
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001962 lastIp = ONOSIpList[ node ]
Jon Hall4ba53f02015-07-29 13:07:41 -07001963
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001964 # lastSwitch += 1
1965 if node < ( clusterCount ):
1966 # connect to first device on the next node
1967 line = ( "\t" + str( lastSwitch ) + ":6 -> 0:5:" + ONOSIpList[ node+1 ] + "\n" )
1968 linkGraph.write( line )
Jon Hall4ba53f02015-07-29 13:07:41 -07001969
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001970 linkGraph.write( "}\n" )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001971 linkGraph.close()
1972
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001973 # SCP
1974 os.system( "scp " + tempFile + " " + self.user_name + "@" + benchIp + ":" + linkGraphPath )
1975 main.log.info( "linkGraph.cfg creation complete" )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001976
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001977 def configNullDev( self, ONOSIpList, deviceCount, numPorts=10 ):
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001978 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07001979 ONOSIpList = list of Ip addresses of nodes switches will be devided amongst
1980 deviceCount = number of switches to distribute, or list of values to use as custom distribution
cameron@onlab.us75900962015-03-30 13:22:49 -07001981 numPorts = number of ports per device. Defaults to 10 both in this function and in ONOS. Optional arg
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001982 '''
1983
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001984 main.log.info( "Configuring Null Device Provider" )
1985 clusterCount = len( ONOSIpList )
andrew@onlab.us3b087132015-03-11 15:00:08 -07001986
Jon Hall4ba53f02015-07-29 13:07:41 -07001987 try:
1988
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001989 if isinstance( deviceCount, int ) or isinstance( deviceCount, str ):
1990 main.log.info( "Creating device distribution" )
1991 deviceCount = int( deviceCount )
1992 switchList = [ 0 ]*( clusterCount+1 )
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00001993 baselineSwitchCount = deviceCount/clusterCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001994
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001995 for node in range( 1, clusterCount + 1 ):
1996 switchList[ node ] = baselineSwitchCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07001997
Jeremy Ronquillo82705492017-10-18 14:19:55 -07001998 for node in range( 1, ( deviceCount % clusterCount )+1 ):
1999 switchList[ node ] += 1
Jon Hall4ba53f02015-07-29 13:07:41 -07002000
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002001 if isinstance( deviceCount, list ):
2002 main.log.info( "Using provided device distribution" )
Jon Hall4ba53f02015-07-29 13:07:41 -07002003
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002004 if len( deviceCount ) == clusterCount:
2005 switchList = [ '0' ]
2006 switchList.extend( deviceCount )
Jon Hall4ba53f02015-07-29 13:07:41 -07002007
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002008 if len( deviceCount ) == ( clusterCount + 1 ):
2009 if deviceCount[ 0 ] == '0' or deviceCount[ 0 ] == 0:
cameron@onlab.us75900962015-03-30 13:22:49 -07002010 switchList = deviceCount
andrew@onlab.us3b087132015-03-11 15:00:08 -07002011
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002012 assert len( switchList ) == ( clusterCount + 1 )
Jon Hall4ba53f02015-07-29 13:07:41 -07002013
cameron@onlab.us75900962015-03-30 13:22:49 -07002014 except AssertionError:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002015 main.log.error( "Bad device/Ip list match" )
cameron@onlab.us75900962015-03-30 13:22:49 -07002016 except TypeError:
2017 main.log.exception( self.name + ": Object not as expected" )
2018 return None
Jon Hall77ba41c2015-04-06 10:25:40 -07002019 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002020 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07002021 main.cleanAndExit()
cameron@onlab.us75900962015-03-30 13:22:49 -07002022
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002023 ONOSIp = [ 0 ]
2024 ONOSIp.extend( ONOSIpList )
andrew@onlab.us3b087132015-03-11 15:00:08 -07002025
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002026 devicesString = "devConfigs = "
2027 for node in range( 1, len( ONOSIp ) ):
2028 devicesString += ( ONOSIp[ node ] + ":" + str( switchList[ node ] ) )
andrew@onlab.us3b087132015-03-11 15:00:08 -07002029 if node < clusterCount:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002030 devicesString += ( "," )
Jon Hall4ba53f02015-07-29 13:07:41 -07002031
2032 try:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002033 self.handle.sendline( "onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider devConfigs " + devicesString )
2034 self.handle.expect( ":~" )
2035 self.handle.sendline( "onos $OC1 cfg set org.onosproject.provider.nil.device.impl.NullDeviceProvider numPorts " + str( numPorts ) )
2036 self.handle.expect( ":~" )
andrew@onlab.us3b087132015-03-11 15:00:08 -07002037
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002038 for i in range( 10 ):
2039 self.handle.sendline( "onos $OC1 cfg get org.onosproject.provider.nil.device.impl.NullDeviceProvider" )
2040 self.handle.expect( ":~" )
cameron@onlab.us75900962015-03-30 13:22:49 -07002041 verification = self.handle.before
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002042 if ( " value=" + str( numPorts ) ) in verification and ( " value=" + devicesString ) in verification:
cameron@onlab.us75900962015-03-30 13:22:49 -07002043 break
2044 else:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002045 time.sleep( 1 )
andrew@onlab.us3b087132015-03-11 15:00:08 -07002046
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002047 assert ( "value=" + str( numPorts ) ) in verification and ( " value=" + devicesString ) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002048
cameron@onlab.us75900962015-03-30 13:22:49 -07002049 except AssertionError:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002050 main.log.error( "Incorrect Config settings: " + verification )
Jon Hall77ba41c2015-04-06 10:25:40 -07002051 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002052 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07002053 main.cleanAndExit()
cameron@onlab.us75900962015-03-30 13:22:49 -07002054
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002055 def configNullLink( self, fileName="/opt/onos/apache-karaf-3.0.3/etc/linkGraph.cfg", eventRate=0 ):
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00002056 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07002057 fileName default is currently the same as the default on ONOS, specify alternate file if
cameron@onlab.us75900962015-03-30 13:22:49 -07002058 you want to use a different topology file than linkGraph.cfg
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00002059 '''
Jon Hall4ba53f02015-07-29 13:07:41 -07002060
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00002061 try:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002062 self.handle.sendline( "onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider eventRate " + str( eventRate ) )
2063 self.handle.expect( ":~" )
2064 self.handle.sendline( "onos $OC1 cfg set org.onosproject.provider.nil.link.impl.NullLinkProvider cfgFile " + fileName )
2065 self.handle.expect( ":~" )
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00002066
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002067 for i in range( 10 ):
2068 self.handle.sendline( "onos $OC1 cfg get org.onosproject.provider.nil.link.impl.NullLinkProvider" )
2069 self.handle.expect( ":~" )
cameron@onlab.us75900962015-03-30 13:22:49 -07002070 verification = self.handle.before
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002071 if ( " value=" + str( eventRate ) ) in verification and ( " value=" + fileName ) in verification:
cameron@onlab.us75900962015-03-30 13:22:49 -07002072 break
Jon Hall4ba53f02015-07-29 13:07:41 -07002073 else:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002074 time.sleep( 1 )
Jon Hall4ba53f02015-07-29 13:07:41 -07002075
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002076 assert ( "value=" + str( eventRate ) ) in verification and ( " value=" + fileName ) in verification
Jon Hall4ba53f02015-07-29 13:07:41 -07002077
cameron@onlab.us75900962015-03-30 13:22:49 -07002078 except pexpect.EOF:
2079 main.log.error( self.name + ": EOF exception found" )
2080 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002081 main.cleanAndExit()
cameron@onlab.us75900962015-03-30 13:22:49 -07002082 except AssertionError:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002083 main.log.info( "Settings did not post to ONOS" )
2084 main.log.error( varification )
Jon Hall77ba41c2015-04-06 10:25:40 -07002085 except Exception:
cameron@onlab.us75900962015-03-30 13:22:49 -07002086 main.log.exception( self.name + ": Uncaught exception!" )
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002087 main.log.error( varification )
Devin Lim44075962017-08-11 10:56:37 -07002088 main.cleanAndExit()
andrew@onlab.us3b087132015-03-11 15:00:08 -07002089
kelvin-onlaba4074292015-07-09 15:19:49 -07002090 def getOnosIps( self ):
2091 """
2092 Get all onos IPs stored in
2093 """
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00002094
kelvin-onlaba4074292015-07-09 15:19:49 -07002095 return sorted( self.onosIps.values() )
cameron@onlab.us59d29d92015-05-11 14:31:54 -07002096
Chiyu Chengec63bde2016-11-17 18:11:36 -08002097 def listLog( self, nodeIp ):
2098 """
2099 Get a list of all the karaf log names
2100 """
2101 try:
2102 cmd = "onos-ssh " + nodeIp + " ls -tr /opt/onos/log"
2103 self.handle.sendline( cmd )
2104 self.handle.expect( ":~" )
2105 before = self.handle.before.splitlines()
2106 logNames = []
2107 for word in before:
2108 if 'karaf.log' in word:
2109 logNames.append( word )
2110 return logNames
2111 except pexpect.EOF:
2112 main.log.error( self.name + ": EOF exception found" )
2113 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002114 main.cleanAndExit()
Chiyu Chengec63bde2016-11-17 18:11:36 -08002115 except pexpect.TIMEOUT:
2116 main.log.error( self.name + ": TIMEOUT exception found" )
2117 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002118 main.cleanAndExit()
Chiyu Chengec63bde2016-11-17 18:11:36 -08002119 except Exception:
2120 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07002121 main.cleanAndExit()
Chiyu Chengec63bde2016-11-17 18:11:36 -08002122
Pratik Parab3b2ab5a2017-02-14 13:15:14 -08002123 def logReport( self, nodeIp, searchTerms, outputMode="s", startStr=None, endStr=None ):
Jon Hallb4242222016-01-25 17:07:04 -08002124 """
2125 Searches the latest ONOS log file for the given search terms and
2126 prints the total occurances of each term. Returns to combined total of
2127 all occurances.
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002128
Jon Hallb4242222016-01-25 17:07:04 -08002129 Arguments:
2130 * nodeIp - The ip of the ONOS node where the log is located
2131 * searchTerms - A string to grep for or a list of strings to grep
2132 for in the ONOS log. Will print out the number of
2133 occurances for each term.
2134 Optional Arguments:
2135 * outputMode - 's' or 'd'. If 'd' will print the last 5 lines
2136 containing each search term as well as the total
2137 number of occurances of each term. Defaults to 's',
2138 which prints the simple output of just the number
2139 of occurances for each term.
Pratik Parab3b2ab5a2017-02-14 13:15:14 -08002140 * startStr - the start string to be given to stream editor command
2141 as the start point for extraction of data
2142 * endStr - the end string to be given to stream editor command as
2143 the end point for extraction of data
Jon Hallb4242222016-01-25 17:07:04 -08002144 """
2145 try:
2146 main.log.info( " Log Report for {} ".format( nodeIp ).center( 70, '=' ) )
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002147 if isinstance( searchTerms, str ):
2148 searchTerms = [ searchTerms ]
Jon Hallb4242222016-01-25 17:07:04 -08002149 numTerms = len( searchTerms )
2150 outputMode = outputMode.lower()
cameron@onlab.us70dd8c62015-05-14 11:19:39 -07002151
Jon Hallb4242222016-01-25 17:07:04 -08002152 totalHits = 0
2153 logLines = []
2154 for termIndex in range( numTerms ):
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002155 term = searchTerms[ termIndex ]
2156 logLines.append( [ term ] )
Pratik Parab3b2ab5a2017-02-14 13:15:14 -08002157 if startStr and endStr:
2158 cmd = "onos-ssh {} \"sed -n '/{}/,/{}/p' /opt/onos/log/karaf.log | grep {}\"".format( nodeIp,
2159 startStr,
2160 endStr,
2161 term )
2162 else:
2163 cmd = "onos-ssh {} cat /opt/onos/log/karaf.log | grep {}".format( nodeIp,
2164 term )
Jon Hallb4242222016-01-25 17:07:04 -08002165 self.handle.sendline( cmd )
2166 self.handle.expect( ":~" )
2167 before = self.handle.before.splitlines()
2168 count = 0
2169 for line in before:
2170 if term in line and "grep" not in line:
2171 count += 1
2172 if before.index( line ) > ( len( before ) - 7 ):
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002173 logLines[ termIndex ].append( line )
Jon Hallb4242222016-01-25 17:07:04 -08002174 main.log.info( "{}: {}".format( term, count ) )
2175 totalHits += count
2176 if termIndex == numTerms - 1:
2177 print "\n"
2178 if outputMode != "s":
2179 outputString = ""
2180 for term in logLines:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002181 outputString = term[ 0 ] + ": \n"
Jon Hallb4242222016-01-25 17:07:04 -08002182 for line in range( 1, len( term ) ):
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002183 outputString += ( "\t" + term[ line ] + "\n" )
2184 if outputString != ( term[ 0 ] + ": \n" ):
Jon Hallb4242222016-01-25 17:07:04 -08002185 main.log.info( outputString )
2186 main.log.info( "=" * 70 )
2187 return totalHits
2188 except pexpect.EOF:
2189 main.log.error( self.name + ": EOF exception found" )
2190 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002191 main.cleanAndExit()
Jon Hallb4242222016-01-25 17:07:04 -08002192 except pexpect.TIMEOUT:
2193 main.log.error( self.name + ": TIMEOUT exception found" )
2194 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002195 main.cleanAndExit()
Jon Hallb4242222016-01-25 17:07:04 -08002196 except Exception:
2197 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07002198 main.cleanAndExit()
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002199
2200 def copyMininetFile( self, fileName, localPath, userName, ip,
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00002201 mnPath='~/mininet/custom/', timeout = 60 ):
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002202 """
2203 Description:
2204 Copy mininet topology file from dependency folder in the test folder
2205 and paste it to the mininet machine's mininet/custom folder
2206 Required:
2207 fileName - Name of the topology file to copy
2208 localPath - File path of the mininet topology file
2209 userName - User name of the mininet machine to send the file to
2210 ip - Ip address of the mininet machine
2211 Optional:
2212 mnPath - of the mininet directory to send the file to
2213 Return:
2214 Return main.TRUE if successfully copied the file otherwise
2215 return main.FALSE
2216 """
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00002217
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002218 try:
2219 cmd = "scp " + localPath + fileName + " " + userName + "@" + \
2220 str( ip ) + ":" + mnPath + fileName
2221
2222 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07002223 self.handle.expect( self.prompt )
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002224
2225 main.log.info( self.name + ": Execute: " + cmd )
2226
2227 self.handle.sendline( cmd )
2228
2229 i = self.handle.expect( [ 'No such file',
2230 "100%",
2231 pexpect.TIMEOUT ] )
2232
2233 if i == 0:
2234 main.log.error( self.name + ": File " + fileName +
2235 " does not exist!" )
2236 return main.FALSE
2237
2238 if i == 1:
2239 main.log.info( self.name + ": File " + fileName +
2240 " has been copied!" )
2241 self.handle.sendline( "" )
Devin Limc20e79a2017-06-07 10:29:57 -07002242 self.handle.expect( self.prompt )
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002243 return main.TRUE
2244
2245 except pexpect.EOF:
2246 main.log.error( self.name + ": EOF exception found" )
2247 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002248 main.cleanAndExit()
kelvin-onlab7a719bb2015-07-08 11:09:51 -07002249 except pexpect.TIMEOUT:
2250 main.log.error( self.name + ": TIMEOUT exception found" )
2251 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002252 main.cleanAndExit()
cameron@onlab.us78b89652015-07-08 15:21:03 -07002253
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002254 def jvmSet( self, memory=8 ):
Jon Hall4ba53f02015-07-29 13:07:41 -07002255
cameron@onlab.us78b89652015-07-08 15:21:03 -07002256 import os
2257
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002258 homeDir = os.path.expanduser( '~' )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002259 filename = "/onos/tools/package/bin/onos-service"
2260
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002261 serviceConfig = open( homeDir + filename, 'w+' )
2262 serviceConfig.write( "#!/bin/bash\n " )
2263 serviceConfig.write( "#------------------------------------- \n " )
2264 serviceConfig.write( "# Starts ONOS Apache Karaf container\n " )
2265 serviceConfig.write( "#------------------------------------- \n " )
2266 serviceConfig.write( "#export JAVA_HOME=${JAVA_HOME:-/usr/lib/jvm/java-7-openjdk-amd64/}\n " )
2267 serviceConfig.write( """export JAVA_OPTS="${JAVA_OPTS:--Xms""" + str( memory ) + "G -Xmx" + str( memory ) + """G}" \n """ )
2268 serviceConfig.write( "[ -d $ONOS_HOME ] && cd $ONOS_HOME || ONOS_HOME=$(dirname $0)/..\n" )
2269 serviceConfig.write( """${ONOS_HOME}/apache-karaf-$KARAF_VERSION/bin/karaf "$@" \n """ )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002270 serviceConfig.close()
2271
Jon Hall6c44c0b2016-04-20 15:21:00 -07002272 def createDBFile( self, testData ):
Jon Hall4ba53f02015-07-29 13:07:41 -07002273
cameron@onlab.us78b89652015-07-08 15:21:03 -07002274 filename = main.TEST + "DB"
2275 DBString = ""
Jon Hall4ba53f02015-07-29 13:07:41 -07002276
cameron@onlab.us78b89652015-07-08 15:21:03 -07002277 for item in testData:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002278 if isinstance( item, string ):
cameron@onlab.us78b89652015-07-08 15:21:03 -07002279 item = "'" + item + "'"
Jon Hall6c44c0b2016-04-20 15:21:00 -07002280 if testData.index( item ) < len( testData - 1 ):
cameron@onlab.us78b89652015-07-08 15:21:03 -07002281 item += ","
Jon Hall6c44c0b2016-04-20 15:21:00 -07002282 DBString += str( item )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002283
Jon Hall6c44c0b2016-04-20 15:21:00 -07002284 DBFile = open( filename, "a" )
2285 DBFile.write( DBString )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002286 DBFile.close()
2287
Jon Hall6c44c0b2016-04-20 15:21:00 -07002288 def verifySummary( self, ONOSIp, *deviceCount ):
cameron@onlab.us78b89652015-07-08 15:21:03 -07002289
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002290 self.handle.sendline( "onos " + ONOSIp + " summary" )
Jon Hall6c44c0b2016-04-20 15:21:00 -07002291 self.handle.expect( ":~" )
cameron@onlab.us78b89652015-07-08 15:21:03 -07002292
2293 summaryStr = self.handle.before
2294 print "\nSummary\n==============\n" + summaryStr + "\n\n"
2295
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002296 # passed = "SCC(s)=1" in summaryStr
2297 # if deviceCount:
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00002298 # passed = "devices=" + str(deviceCount) + "," not in summaryStr
cameron@onlab.us78b89652015-07-08 15:21:03 -07002299
GlennRC772363b2015-08-25 13:05:57 -07002300 passed = False
cameron@onlab.us78b89652015-07-08 15:21:03 -07002301 if "SCC(s)=1," in summaryStr:
2302 passed = True
Jon Hall6c44c0b2016-04-20 15:21:00 -07002303 print "Summary is verifed"
Jon Hall4ba53f02015-07-29 13:07:41 -07002304 else:
Jon Hall6c44c0b2016-04-20 15:21:00 -07002305 print "Summary failed"
cameron@onlab.us78b89652015-07-08 15:21:03 -07002306
2307 if deviceCount:
2308 print" ============================="
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002309 checkStr = "devices=" + str( deviceCount[ 0 ] ) + ","
cameron@onlab.us78b89652015-07-08 15:21:03 -07002310 print "Checkstr: " + checkStr
2311 if checkStr not in summaryStr:
2312 passed = False
Jon Hall6c44c0b2016-04-20 15:21:00 -07002313 print "Device count failed"
Jon Hall4ba53f02015-07-29 13:07:41 -07002314 else:
2315 print "device count verified"
cameron@onlab.us78b89652015-07-08 15:21:03 -07002316
2317 return passed
Jon Hall6c44c0b2016-04-20 15:21:00 -07002318
Jon Hall8f6d4622016-05-23 15:27:18 -07002319 def getIpAddr( self, iface=None ):
Jon Hall6c44c0b2016-04-20 15:21:00 -07002320 """
2321 Update self.ip_address with numerical ip address. If multiple IP's are
2322 located on the device, will attempt to use self.nicAddr to choose the
2323 right one. Defaults to 127.0.0.1 if no other address is found or cannot
2324 determine the correct address.
2325
2326 ONLY WORKS WITH IPV4 ADDRESSES
2327 """
2328 try:
Jon Hall8f6d4622016-05-23 15:27:18 -07002329 LOCALHOST = "127.0.0.1"
Jon Hall6c44c0b2016-04-20 15:21:00 -07002330 ipPat = "\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"
2331 pattern = re.compile( ipPat )
2332 match = re.search( pattern, self.ip_address )
2333 if self.nicAddr:
2334 nicPat = self.nicAddr.replace( ".", "\." ).replace( "\*", r"\d{1,3}" )
2335 nicPat = re.compile( nicPat )
2336 else:
2337 nicPat = None
2338 # IF self.ip_address is an ip address and matches
2339 # self.nicAddr: return self.ip_address
2340 if match:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002341 curIp = match.group( 0 )
Jon Hall6c44c0b2016-04-20 15:21:00 -07002342 if nicPat:
2343 nicMatch = re.search( nicPat, curIp )
2344 if nicMatch:
2345 return self.ip_address
Jon Hall8f6d4622016-05-23 15:27:18 -07002346 # ELSE: IF iface, return ip of interface
2347 cmd = "ifconfig"
2348 ifPat = re.compile( "inet addr:({})".format( ipPat ) )
2349 if iface:
2350 cmd += " " + str( iface )
2351 raw = subprocess.check_output( cmd.split() )
Jon Hall6c44c0b2016-04-20 15:21:00 -07002352 ifPat = re.compile( "inet addr:({})".format( ipPat ) )
2353 ips = re.findall( ifPat, raw )
Jon Hall8f6d4622016-05-23 15:27:18 -07002354 if iface:
2355 if ips:
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002356 ip = ips[ 0 ]
Jon Hall8f6d4622016-05-23 15:27:18 -07002357 self.ip_address = ip
2358 return ip
2359 else:
2360 main.log.error( "Error finding ip, ifconfig output:".format( raw ) )
2361 # ELSE: attempt to get address matching nicPat.
Jon Hall6c44c0b2016-04-20 15:21:00 -07002362 if nicPat:
2363 for ip in ips:
2364 curMatch = re.search( nicPat, ip )
2365 if curMatch:
2366 self.ip_address = ip
2367 return ip
Jon Hall8f6d4622016-05-23 15:27:18 -07002368 else: # If only one non-localhost ip, return that
2369 tmpList = [ ip for ip in ips if ip is not LOCALHOST ]
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002370 if len( tmpList ) == 1:
2371 curIp = tmpList[ 0 ]
Jon Hall6c44c0b2016-04-20 15:21:00 -07002372 self.ip_address = curIp
2373 return curIp
Jon Hall8f6d4622016-05-23 15:27:18 -07002374 # Either no non-localhost IPs, or more than 1
Jon Hallebccd352016-05-20 15:17:17 -07002375 main.log.warn( "getIpAddr failed to find a public IP address" )
Jon Hall8f6d4622016-05-23 15:27:18 -07002376 return LOCALHOST
Jon Halle1790952016-05-23 15:51:46 -07002377 except subprocess.CalledProcessError:
Jon Hall8f6d4622016-05-23 15:27:18 -07002378 main.log.exception( "Error executing ifconfig" )
2379 except IndexError:
2380 main.log.exception( "Error getting IP Address" )
Jon Hall6c44c0b2016-04-20 15:21:00 -07002381 except Exception:
2382 main.log.exception( "Uncaught exception" )
suibin zhang116647a2016-05-06 16:30:09 -07002383
Devin Lim461f0872017-06-05 16:49:33 -07002384 def startBasicONOS( self, nodeList, opSleep=60, onosStartupSleep=30, onosUser="sdn" ):
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00002385 '''
suibin zhang116647a2016-05-06 16:30:09 -07002386 Start onos cluster with defined nodes, but only with drivers app
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00002387 '''
suibin zhang116647a2016-05-06 16:30:09 -07002388 import time
2389
2390 self.createCellFile( self.ip_address,
2391 "temp",
2392 self.ip_address,
2393 "drivers",
Devin Lim461f0872017-06-05 16:49:33 -07002394 nodeList, onosUser )
suibin zhang116647a2016-05-06 16:30:09 -07002395
2396 main.log.info( self.name + ": Apply cell to environment" )
2397 cellResult = self.setCell( "temp" )
2398 verifyResult = self.verifyCell()
2399
2400 main.log.info( self.name + ": Creating ONOS package" )
You Wangd1bcaca2016-10-24 15:23:26 -07002401 packageResult = self.buckBuild( timeout=opSleep )
suibin zhang116647a2016-05-06 16:30:09 -07002402
You Wangc669d212017-01-25 11:09:48 -08002403 main.log.info( self.name + ": Uninstalling ONOS" )
2404 for nd in nodeList:
2405 self.onosUninstall( nodeIp=nd )
2406
suibin zhang116647a2016-05-06 16:30:09 -07002407 main.log.info( self.name + ": Installing ONOS package" )
2408 for nd in nodeList:
You Wangc669d212017-01-25 11:09:48 -08002409 self.onosInstall( node=nd )
2410
2411 main.log.info( self.name + ": Set up ONOS secure SSH" )
2412 for nd in nodeList:
2413 self.onosSecureSSH( node=nd )
suibin zhang116647a2016-05-06 16:30:09 -07002414
2415 main.log.info( self.name + ": Starting ONOS service" )
2416 time.sleep( onosStartupSleep )
2417
2418 onosStatus = True
2419 for nd in nodeList:
Jeremy Ronquillo4d5f1d02017-10-13 20:23:57 +00002420 onosStatus = onosStatus & self.isup( node = nd )
Jeremy Ronquillo82705492017-10-18 14:19:55 -07002421 # print "onosStatus is: " + str( onosStatus )
suibin zhang116647a2016-05-06 16:30:09 -07002422
2423 return main.TRUE if onosStatus else main.FALSE
2424
Devin Lim02075272017-07-10 15:33:21 -07002425 def onosNetCfg( self, controllerIp, path, fileName ):
Jeremy Songster5665f1b2016-06-20 14:38:22 -07002426 """
2427 Push a specified json file to ONOS through the onos-netcfg service
2428
2429 Required:
Devin Lim02075272017-07-10 15:33:21 -07002430 controllerIp - the Ip of the ONOS node in the cluster
Jeremy Songster5665f1b2016-06-20 14:38:22 -07002431 path - the location of the file to be sent
2432 fileName - name of the json file to be sent
2433
2434 Returns main.TRUE on successfully sending json file, and main.FALSE if
2435 there is an error.
2436 """
2437 try:
Devin Lim02075272017-07-10 15:33:21 -07002438 cmd = "onos-netcfg {0} {1}{2}".format( controllerIp, path, fileName )
2439 main.log.info( "Sending: " + cmd )
2440 main.ONOSbench.handle.sendline( cmd )
Jeremy Ronquillo3008aa32017-07-07 15:38:57 -07002441 main.ONOSbench.handle.expect( self.prompt )
Devin Lim02075272017-07-10 15:33:21 -07002442 handle = self.handle.before
Jeremy Ronquillo3008aa32017-07-07 15:38:57 -07002443 if "Error" in handle or "No such file or directory" in handle or "curl: " in handle:
2444 main.log.error( self.name + ": " + handle + self.handle.after )
Devin Lim02075272017-07-10 15:33:21 -07002445 return main.FALSE
Devin Lim752dd7b2017-06-27 14:40:03 -07002446 return main.TRUE
Jeremy Songster5665f1b2016-06-20 14:38:22 -07002447 except pexpect.EOF:
2448 main.log.error( self.name + ": EOF exception found" )
2449 main.log.error( self.name + ": " + self.handle.before )
Devin Lim44075962017-08-11 10:56:37 -07002450 main.cleanAndExit()
Jeremy Songster5665f1b2016-06-20 14:38:22 -07002451 except Exception:
2452 main.log.exception( self.name + ": Uncaught exception!" )
Devin Lim44075962017-08-11 10:56:37 -07002453 main.cleanAndExit()
Devin Lim3ebd5e72017-11-14 10:38:00 -08002454
2455 def formCluster( self, onosIPs ):
2456 """
2457 From ONOS cluster for IP addresses in onosIPs list
2458 """
2459 try:
2460 onosIPs = " ".join( onosIPs )
2461 command = "onos-form-cluster {}".format( onosIPs )
2462 main.log.info( "Sending: " + command )
2463 self.handle.sendline( "" )
2464 self.handle.expect( self.prompt )
2465 self.handle.sendline( command )
2466 self.handle.expect( self.prompt )
2467 handle = self.handle.before
2468 main.log.debug( handle )
2469 assert handle is not None, "Error in sendline"
2470 assert "Command not found:" not in handle, handle
2471 assert "Error" not in handle, handle
2472 assert "Exception:" not in handle, handle
2473 assert "curl:" not in handle, handle
2474 return main.TRUE
2475 except AssertionError:
2476 main.log.exception( "{} Error in onos-form-cluster output:".format( self.name ) )
2477 return main.FALSE
2478 except TypeError:
2479 main.log.exception( self.name + ": Object not as expected" )
2480 return main.FALSE
2481 except pexpect.EOF:
2482 main.log.error( self.name + ": EOF exception found" )
2483 main.log.error( self.name + ": " + self.handle.before )
2484 main.cleanAndExit()
2485 except Exception:
2486 main.log.exception( self.name + ": Uncaught exception!" )
2487 main.cleanAndExit()
Jon Hall7ce46ea2018-02-05 12:20:59 -08002488
2489 def backupData( self, location ):
2490 """
2491 Backs up ONOS data and logs to a given location. Returns main.FALSE
2492 if there is an error executing the command, and main.TRUE otherwise.
2493 required arguments:
2494 loaction - The file path to save the backup to
2495 """
2496 try:
2497 cmd = "/opt/onos/bin/onos-backup " + str( location )
2498 self.handle.sendline( cmd )
2499 self.handle.expect( self.prompt )
2500 handle = self.handle.before
2501 main.log.debug( handle )
2502 assert handle is not None, "Error in sendline"
2503 assert "Command not found:" not in handle, handle
2504 assert "Error" not in handle, handle
2505 assert "Exception:" not in handle, handle
2506 return main.TRUE
2507 except AssertionError:
2508 main.log.exception( "{} Error in onos-backup output:".format( self.name ) )
2509 return main.FALSE
2510 except TypeError:
2511 main.log.exception( self.name + ": Object not as expected" )
2512 return main.FALSE
2513 except pexpect.EOF:
2514 main.log.error( self.name + ": EOF exception found" )
2515 main.log.error( self.name + ": " + self.handle.before )
2516 main.cleanAndExit()
2517 except Exception:
2518 main.log.exception( self.name + ": Uncaught exception!" )
2519 main.cleanAndExit()
2520
2521 def restoreData( self, location ):
2522 """
2523 Restores ONOS data and logs from a given location. Returns main.FALSE
2524 if there is an error executing the command, and main.TRUE otherwise.
2525 required arguments:
2526 loaction - The file path of a backup file
2527 """
2528 try:
2529 cmd = "/opt/onos/bin/onos-restore " + str( location )
2530 self.handle.sendline( cmd )
2531 self.handle.expect( self.prompt )
2532 handle = self.handle.before
2533 main.log.debug( handle )
2534 assert handle is not None, "Error in sendline"
2535 assert "Command not found:" not in handle, handle
2536 assert "Error" not in handle, handle
2537 assert "Exception:" not in handle, handle
2538 return main.TRUE
2539 except AssertionError:
2540 main.log.exception( "{} Error in onos-restore output:".format( self.name ) )
2541 return main.FALSE
2542 except TypeError:
2543 main.log.exception( self.name + ": Object not as expected" )
2544 return main.FALSE
2545 except pexpect.EOF:
2546 main.log.error( self.name + ": EOF exception found" )
2547 main.log.error( self.name + ": " + self.handle.before )
2548 main.cleanAndExit()
2549 except Exception:
2550 main.log.exception( self.name + ": Uncaught exception!" )
2551 main.cleanAndExit()
You Wang5df1c6d2018-04-06 18:02:02 -07002552
2553 def onosDiagnostics( self, onosIPs, dstDir, suffix ):
2554 """
2555 Run onos-diagnostics with given ONOS instance IPs and save output to dstDir
2556 with suffix specified E.g. onos-diags-suffix.tar.gz
2557 required argDuments:
2558 onosIPs - list of ONOS IPs for collecting diags
2559 dstDir - diags file will be saved under the directory specified
2560 suffix - diags file will be named with the suffix specified
2561 returns:
2562 main.FALSE if there's an error executing the command, and main.TRUE otherwise
2563 """
2564 try:
2565 cmd = "onos-diagnostics"
2566 assert isinstance( onosIPs, list )
2567 for ip in onosIPs:
2568 cmd += " " + str( ip )
2569 self.handle.sendline( cmd )
2570 self.handle.expect( self.prompt )
2571 handle = self.handle.before
2572 main.log.debug( handle )
2573 assert handle is not None, "Error in sendline"
2574 assert "Command not found:" not in handle, handle
2575 assert "Exception:" not in handle, handle
2576 # Rename and move diags file to dstDir from /tmp
2577 if dstDir[ -1: ] != "/":
2578 dstDir += "/"
2579 self.handle.sendline( "mv /tmp/onos-diags.tar.gz " + str( dstDir ) + "onos-diags" + str( suffix ) + ".tar.gz" )
2580 self.handle.expect( self.prompt )
2581 handle = self.handle.before
2582 main.log.debug( handle )
2583 assert handle is not None, "Error in sendline"
2584 assert "No such file or directory" not in handle, handle
2585 return main.TRUE
2586 except AssertionError:
2587 main.log.exception( "{} Error in onos-diagnostics output:".format( self.name ) )
2588 return main.FALSE
2589 except TypeError:
2590 main.log.exception( self.name + ": Object not as expected" )
2591 return main.FALSE
2592 except pexpect.EOF:
2593 main.log.error( self.name + ": EOF exception found" )
2594 main.log.error( self.name + ": " + self.handle.before )
2595 main.cleanAndExit()
2596 except Exception:
2597 main.log.exception( self.name + ": Uncaught exception!" )
2598 main.cleanAndExit()