blob: 575de1c6c8e6ab83280f64a4c1a8522af9a616fe [file] [log] [blame]
Jon Hall05b2b432014-10-08 19:53:25 -04001#!/usr/bin/env python
andrewonlabe8e56fd2014-10-09 17:12:44 -04002
Jon Hall05b2b432014-10-08 19:53:25 -04003'''
andrewonlabe8e56fd2014-10-09 17:12:44 -04004This driver interacts with ONOS bench, the OSGi platform
5that configures the ONOS nodes. (aka ONOS-next)
6
7Please follow the coding style demonstrated by existing
8functions and document properly.
9
10If you are a contributor to the driver, please
11list your email here for future contact:
12
13jhall@onlab.us
14andrew@onlab.us
15
16OCT 9 2014
17
Jon Hall05b2b432014-10-08 19:53:25 -040018'''
andrewonlabe8e56fd2014-10-09 17:12:44 -040019
andrewonlab7735d852014-10-09 13:02:47 -040020import sys
Jon Hall05b2b432014-10-08 19:53:25 -040021import time
22import pexpect
23import re
24import traceback
andrewonlab7735d852014-10-09 13:02:47 -040025import os.path
andrewonlab6e20c342014-10-10 18:08:48 -040026import pydoc
Jon Hall05b2b432014-10-08 19:53:25 -040027sys.path.append("../")
28from drivers.common.clidriver import CLI
29
30class OnosDriver(CLI):
31
32 def __init__(self):
andrewonlab6e20c342014-10-10 18:08:48 -040033 '''
34 Initialize client
35 '''
Jon Hall05b2b432014-10-08 19:53:25 -040036 super(CLI, self).__init__()
37
38 def connect(self,**connectargs):
39 '''
40 Creates ssh handle for ONOS "bench".
41 '''
42 try:
43 for key in connectargs:
44 vars(self)[key] = connectargs[key]
45 self.home = "~/ONOS"
46 for key in self.options:
47 if key == "home":
48 self.home = self.options['home']
49 break
50
51
52 self.name = self.options['name']
Jon Hallea7818b2014-10-09 14:30:59 -040053 self.handle = super(OnosDriver,self).connect(
54 user_name = self.user_name,
55 ip_address = self.ip_address,
56 port = self.port,
57 pwd = self.pwd,
58 home = self.home)
Jon Hallea7818b2014-10-09 14:30:59 -040059
60 self.handle.sendline("cd "+ self.home)
61 self.handle.expect("\$")
Jon Hall05b2b432014-10-08 19:53:25 -040062 if self.handle:
63 return self.handle
64 else :
65 main.log.info("NO ONOS HANDLE")
66 return main.FALSE
67 except pexpect.EOF:
68 main.log.error(self.name + ": EOF exception found")
69 main.log.error(self.name + ": " + self.handle.before)
70 main.cleanup()
71 main.exit()
72 except:
73 main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
74 main.log.error( traceback.print_exc() )
75 main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
76 main.cleanup()
77 main.exit()
78
79 def disconnect(self):
80 '''
81 Called when Test is complete to disconnect the ONOS handle.
82 '''
83 response = ''
84 try:
Jon Hallf8d10982014-10-22 12:23:38 -040085 self.handle.sendline("\n")
86 self.handle.expect("\$")
Jon Hall05b2b432014-10-08 19:53:25 -040087 self.handle.sendline("exit")
88 self.handle.expect("closed")
89 except pexpect.EOF:
90 main.log.error(self.name + ": EOF exception found")
91 main.log.error(self.name + ": " + self.handle.before)
92 except:
93 main.log.error(self.name + ": Connection failed to the host")
94 response = main.FALSE
95 return response
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -040096
97 def onos_package(self):
98 '''
99 Produce a self-contained tar.gz file that can be deployed
100 and executed on any platform with Java 7 JRE.
101 '''
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400102
103 try:
104 self.handle.sendline("onos-package")
Jon Hallea7818b2014-10-09 14:30:59 -0400105 self.handle.expect("onos-package")
andrewonlab0748d2a2014-10-09 13:24:17 -0400106 self.handle.expect("tar.gz",timeout=10)
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400107 handle = str(self.handle.before)
108 main.log.info("onos-package command returned: "+
109 handle)
andrewonlab0748d2a2014-10-09 13:24:17 -0400110 #As long as the sendline does not time out,
111 #return true. However, be careful to interpret
112 #the results of the onos-package command return
113 return main.TRUE
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400114
andrewonlab7735d852014-10-09 13:02:47 -0400115 except pexpect.EOF:
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400116 main.log.error(self.name + ": EOF exception found")
117 main.log.error(self.name + ": " + self.handle.before)
118 except:
119 main.log.error("Failed to package ONOS")
120 main.cleanup()
121 main.exit()
122
andrewonlab8790abb2014-11-06 13:51:54 -0500123 def onos_build(self):
124 '''
125 Use the pre defined script to build onos via mvn
126 '''
127
128 try:
129 self.handle.sendline("onos-build")
130 self.handle.expect("onos-build")
131 i = self.handle.expect([
132 "BUILD SUCCESS",
133 "ERROR",
134 "BUILD FAILED"], timeout=120)
135 handle = str(self.handle.before)
136
137 main.log.info("onos-build command returned: "+
138 handle)
139
140 if i == 0:
141 return main.TRUE
142 else:
143 return handle
144
145 except pexpect.EOF:
146 main.log.error(self.name + ": EOF exception found")
147 main.log.error(self.name + ": " + self.handle.before)
148 except:
149 main.log.error("Failed to build ONOS")
150 main.cleanup()
151 main.exit()
152
Jon Hallde9d9aa2014-10-08 20:36:02 -0400153 def clean_install(self):
154 '''
155 Runs mvn clean install in the root of the ONOS directory.
156 This will clean all ONOS artifacts then compile each module
andrew@onlab.us9e2cd0f2014-10-08 20:32:32 -0400157
Jon Hallde9d9aa2014-10-08 20:36:02 -0400158 Returns: main.TRUE on success
159 On Failure, exits the test
160 '''
161 try:
Jon Hallea7818b2014-10-09 14:30:59 -0400162 main.log.info("Running 'mvn clean install' on " + str(self.name) +
163 ". This may take some time.")
164 self.handle.sendline("cd "+ self.home)
165 self.handle.expect("\$")
166
167 self.handle.sendline("\n")
168 self.handle.expect("\$")
Jon Hallde9d9aa2014-10-08 20:36:02 -0400169 self.handle.sendline("mvn clean install")
Jon Hallea7818b2014-10-09 14:30:59 -0400170 self.handle.expect("mvn clean install")
Jon Hallde9d9aa2014-10-08 20:36:02 -0400171 while 1:
172 i=self.handle.expect([
173 'There\sis\sinsufficient\smemory\sfor\sthe\sJava\s\
174 Runtime\sEnvironment\sto\scontinue',
175 'BUILD\sFAILURE',
176 'BUILD\sSUCCESS',
177 'ONOS\$',
178 pexpect.TIMEOUT],timeout=600)
179 if i == 0:
180 main.log.error(self.name + ":There is insufficient memory \
181 for the Java Runtime Environment to continue.")
182 #return main.FALSE
183 main.cleanup()
184 main.exit()
185 if i == 1:
186 main.log.error(self.name + ": Build failure!")
187 #return main.FALSE
188 main.cleanup()
189 main.exit()
190 elif i == 2:
191 main.log.info(self.name + ": Build success!")
192 elif i == 3:
193 main.log.info(self.name + ": Build complete")
Jon Hallf8ef52c2014-10-09 19:37:33 -0400194 #Print the build time
195 for line in self.handle.before.splitlines():
196 if "Total time:" in line:
197 main.log.info(line)
Jon Hallea7818b2014-10-09 14:30:59 -0400198 self.handle.sendline("\n")
Jon Hallde9d9aa2014-10-08 20:36:02 -0400199 self.handle.expect("\$", timeout=60)
200 return main.TRUE
201 elif i == 4:
202 main.log.error(self.name + ": mvn clean install TIMEOUT!")
203 #return main.FALSE
204 main.cleanup()
205 main.exit()
206 else:
207 main.log.error(self.name + ": unexpected response from \
208 mvn clean install")
209 #return main.FALSE
210 main.cleanup()
211 main.exit()
212 except pexpect.EOF:
213 main.log.error(self.name + ": EOF exception found")
214 main.log.error(self.name + ": " + self.handle.before)
215 main.cleanup()
216 main.exit()
217 except:
218 main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
219 main.log.error( traceback.print_exc() )
220 main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
221 main.cleanup()
222 main.exit()
Jon Hallacabffd2014-10-09 12:36:53 -0400223
224 def git_pull(self, comp1=""):
225 '''
226 Assumes that "git pull" works without login
227
228 This function will perform a git pull on the ONOS instance.
229 If used as git_pull("NODE") it will do git pull + NODE. This is
230 for the purpose of pulling from other nodes if necessary.
231
232 Otherwise, this function will perform a git pull in the
233 ONOS repository. If it has any problems, it will return main.ERROR
Shreya Shahee15f6c2014-10-28 18:12:30 -0400234 If it successfully does a git_pull, it will return a 1 (main.TRUE)
235 If it has no updates, it will return 3.
Jon Hallacabffd2014-10-09 12:36:53 -0400236
237 '''
238 try:
239 # main.log.info(self.name + ": Stopping ONOS")
240 #self.stop()
241 self.handle.sendline("cd " + self.home)
242 self.handle.expect("ONOS\$")
243 if comp1=="":
244 self.handle.sendline("git pull")
245 else:
246 self.handle.sendline("git pull " + comp1)
247
248 uptodate = 0
249 i=self.handle.expect(['fatal',
250 'Username\sfor\s(.*):\s',
251 '\sfile(s*) changed,\s',
252 'Already up-to-date',
253 'Aborting',
254 'You\sare\snot\scurrently\son\sa\sbranch',
255 'You\sasked\sme\sto\spull\swithout\stelling\sme\swhich\sbranch\syou',
256 'Pull\sis\snot\spossible\sbecause\syou\shave\sunmerged\sfiles',
257 pexpect.TIMEOUT],
258 timeout=300)
259 #debug
Jon Hall81e29af2014-11-04 20:41:23 -0500260 #main.log.report(self.name +": DEBUG: \n"+"git pull response: " + str(self.handle.before) + str(self.handle.after))
Jon Hallacabffd2014-10-09 12:36:53 -0400261 if i==0:
262 main.log.error(self.name + ": Git pull had some issue...")
263 return main.ERROR
264 elif i==1:
265 main.log.error(self.name + ": Git Pull Asking for username. ")
266 return main.ERROR
267 elif i==2:
268 main.log.info(self.name + ": Git Pull - pulling repository now")
269 self.handle.expect("ONOS\$", 120)
Shreya Shahee15f6c2014-10-28 18:12:30 -0400270 return main.TRUE # So that only when git pull is done, we do mvn clean compile
Jon Hallacabffd2014-10-09 12:36:53 -0400271 elif i==3:
272 main.log.info(self.name + ": Git Pull - Already up to date")
Shreya Shahee15f6c2014-10-28 18:12:30 -0400273 return i
Jon Hallacabffd2014-10-09 12:36:53 -0400274 elif i==4:
275 main.log.info(self.name + ": Git Pull - Aborting... Are there conflicting git files?")
276 return main.ERROR
277 elif i==5:
278 main.log.info(self.name + ": Git Pull - You are not currently on a branch so git pull failed!")
279 return main.ERROR
280 elif i==6:
281 main.log.info(self.name + ": Git Pull - You have not configured an upstream branch to pull from. Git pull failed!")
282 return main.ERROR
283 elif i==7:
284 main.log.info(self.name + ": Git Pull - Pull is not possible because you have unmerged files.")
285 return main.ERROR
286 elif i==8:
287 main.log.error(self.name + ": Git Pull - TIMEOUT")
288 main.log.error(self.name + " Response was: " + str(self.handle.before))
289 return main.ERROR
290 else:
291 main.log.error(self.name + ": Git Pull - Unexpected response, check for pull errors")
292 return main.ERROR
293 except pexpect.EOF:
294 main.log.error(self.name + ": EOF exception found")
295 main.log.error(self.name + ": " + self.handle.before)
296 main.cleanup()
297 main.exit()
298 except:
299 main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
300 main.log.error( traceback.print_exc() )
301 main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
302 main.cleanup()
303 main.exit()
304
305 def git_checkout(self, branch="master"):
306 '''
307 Assumes that "git pull" works without login
308
309 This function will perform a git git checkout on the ONOS instance.
310 If used as git_checkout("branch") it will do git checkout of the "branch".
311
312 Otherwise, this function will perform a git checkout of the master
313 branch of the ONOS repository. If it has any problems, it will return
314 main.ERROR.
315 If the branch was already the specified branch, or the git checkout was
316 successful then the function will return main.TRUE.
317
318 '''
319 try:
Jon Hallacabffd2014-10-09 12:36:53 -0400320 self.handle.sendline("cd " + self.home)
321 self.handle.expect("ONOS\$")
Jon Hall81e29af2014-11-04 20:41:23 -0500322 main.log.info(self.name + ": Checking out git branch: " + branch + "...")
323 cmd = "git checkout "+branch
324 self.handle.sendline(cmd)
325 self.handle.expect(cmd)
326 i=self.handle.expect(['fatal',
327 'Username\sfor\s(.*):\s',
328 'Already\son\s\'',
329 'Switched\sto\sbranch\s\'' + str(branch),
330 pexpect.TIMEOUT,
331 'error: Your local changes to the following files would be overwritten by checkout:',
332 'error: you need to resolve your current index first'],timeout=60)
Jon Hallacabffd2014-10-09 12:36:53 -0400333
334 if i==0:
335 main.log.error(self.name + ": Git checkout had some issue...")
Jon Hall81e29af2014-11-04 20:41:23 -0500336 main.log.error(self.name + ": " + self.handle.before)
Jon Hallacabffd2014-10-09 12:36:53 -0400337 return main.ERROR
338 elif i==1:
Jon Hall81e29af2014-11-04 20:41:23 -0500339 main.log.error(self.name + ": Git checkout asking for username."\
340 +" Please configure your local git repository to be able "\
341 +"to access your remote repository passwordlessly")
Jon Hallacabffd2014-10-09 12:36:53 -0400342 return main.ERROR
343 elif i==2:
344 main.log.info(self.name + ": Git Checkout %s : Already on this branch" %branch)
345 self.handle.expect("ONOS\$")
Jon Hall81e29af2014-11-04 20:41:23 -0500346 #main.log.info("DEBUG: after checkout cmd = "+ self.handle.before)
Jon Hallacabffd2014-10-09 12:36:53 -0400347 return main.TRUE
348 elif i==3:
349 main.log.info(self.name + ": Git checkout %s - Switched to this branch" %branch)
350 self.handle.expect("ONOS\$")
Jon Hall81e29af2014-11-04 20:41:23 -0500351 #main.log.info("DEBUG: after checkout cmd = "+ self.handle.before)
Jon Hallacabffd2014-10-09 12:36:53 -0400352 return main.TRUE
353 elif i==4:
354 main.log.error(self.name + ": Git Checkout- TIMEOUT")
355 main.log.error(self.name + " Response was: " + str(self.handle.before))
356 return main.ERROR
Jon Hall81e29af2014-11-04 20:41:23 -0500357 elif i==5:
358 self.handle.expect("Aborting")
359 main.log.error(self.name + ": Git checkout error: \n" + \
360 "Your local changes to the following files would be overwritten by checkout:" + \
361 str(self.handle.before))
362 self.handle.expect("ONOS\$")
363 return main.ERROR
364 elif i==6:
365 main.log.error(self.name + ": Git checkout error: \n" + \
366 "You need to resolve your current index first:" + \
367 str(self.handle.before))
368 self.handle.expect("ONOS\$")
369 return main.ERROR
Jon Hallacabffd2014-10-09 12:36:53 -0400370 else:
371 main.log.error(self.name + ": Git Checkout - Unexpected response, check for pull errors")
Jon Hall81e29af2014-11-04 20:41:23 -0500372 main.log.error(self.name + ": " + self.handle.before)
Jon Hallacabffd2014-10-09 12:36:53 -0400373 return main.ERROR
374
375 except pexpect.EOF:
376 main.log.error(self.name + ": EOF exception found")
377 main.log.error(self.name + ": " + self.handle.before)
378 main.cleanup()
379 main.exit()
380 except:
381 main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
382 main.log.error( traceback.print_exc() )
383 main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
384 main.cleanup()
385 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -0400386
Jon Hallfd191202014-11-07 18:36:09 -0500387 def get_version(self, report=False):
Jon Hall45ec0922014-10-10 19:33:49 -0400388 '''
389 Writes the COMMIT number to the report to be parsed by Jenkins data collecter.
390 '''
391 try:
392 self.handle.sendline("export TERM=xterm-256color")
393 self.handle.expect("xterm-256color")
394 self.handle.expect("\$")
Jon Hall42db6dc2014-10-24 19:03:48 -0400395 self.handle.sendline("\n")
396 self.handle.expect("\$")
397 self.handle.sendline("cd " + self.home + "; git log -1 --pretty=fuller --decorate=short | grep -A 6 \"commit\" --color=never")
398 self.handle.expect("--color=never")
Jon Hall45ec0922014-10-10 19:33:49 -0400399 self.handle.expect("\$")
400 response=(self.name +": \n"+ str(self.handle.before + self.handle.after))
Jon Hall42db6dc2014-10-24 19:03:48 -0400401 self.handle.sendline("cd " + self.home)
402 self.handle.expect("\$")
Jon Hall45ec0922014-10-10 19:33:49 -0400403 lines=response.splitlines()
404 for line in lines:
Jon Hallfd191202014-11-07 18:36:09 -0500405 print line
406 if report:
407 for line in lines[2:-1]:
408 main.log.report(line)
409 return lines[2]
Jon Hall45ec0922014-10-10 19:33:49 -0400410 except pexpect.EOF:
411 main.log.error(self.name + ": EOF exception found")
412 main.log.error(self.name + ": " + self.handle.before)
413 main.cleanup()
414 main.exit()
415 except:
416 main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
417 main.log.error( traceback.print_exc() )
418 main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
419 main.cleanup()
420 main.exit()
421
andrewonlabba44bcf2014-10-16 16:54:41 -0400422 def create_cell_file(self, bench_ip, file_name, mn_ip_addrs,
andrewonlab3f0a4af2014-10-17 12:25:14 -0400423 extra_feature_string, *onos_ip_addrs):
andrewonlab94282092014-10-10 13:00:11 -0400424 '''
425 Creates a cell file based on arguments
426 Required:
427 * Bench IP address (bench_ip)
428 - Needed to copy the cell file over
429 * File name of the cell file (file_name)
430 * Mininet IP address (mn_ip_addrs)
431 - Note that only 1 ip address is
432 supported currently
433 * ONOS IP addresses (onos_ip_addrs)
434 - Must be passed in as last arguments
435
436 NOTE: Assumes cells are located at:
437 ~/<self.home>/tools/test/cells/
438 '''
439
440 #Variable initialization
441 cell_directory = self.home + "/tools/test/cells/"
442 #We want to create the cell file in the dependencies directory
443 #of TestON first, then copy over to ONOS bench
444 temp_directory = "/tmp/"
445 #Create the cell file in the directory for writing (w+)
446 cell_file = open(temp_directory+file_name , 'w+')
andrewonlabd4940492014-10-24 12:21:27 -0400447
448 comment = ""
449 comment_string = "#"+ comment
andrewonlab7e4d2d32014-10-15 13:23:21 -0400450 #Feature string is hardcoded environment variables
451 #That you may wish to use by default on startup.
452 #Note that you may not want certain features listed
453 #on here.
andrewonlabba44bcf2014-10-16 16:54:41 -0400454 core_feature_string = "export ONOS_FEATURES=webconsole,onos-api,"+\
455 "onos-cli,onos-openflow,onos-app-mobility,onos-app-tvue,"+\
456 "onos-app-proxyarp,"+extra_feature_string
andrewonlab94282092014-10-10 13:00:11 -0400457 mn_string = "export OCN="
458 onos_string = "export OC"
459 temp_count = 1
460
461 #Create ONOS_NIC ip address prefix
462 temp_onos_ip = onos_ip_addrs[0]
463 temp_list = []
464 temp_list = temp_onos_ip.split(".")
andrewonlab7e4d2d32014-10-15 13:23:21 -0400465 #Omit last element of list to format for NIC
andrewonlab94282092014-10-10 13:00:11 -0400466 temp_list = temp_list[:-1]
467 #Structure the nic string ip
andrewonlabd4940492014-10-24 12:21:27 -0400468 nic_addr = ".".join(temp_list) + ".*"
andrewonlab94282092014-10-10 13:00:11 -0400469 onos_nic_string = "export ONOS_NIC="+nic_addr
470
471 try:
472 #Start writing to file
andrewonlabd4940492014-10-24 12:21:27 -0400473 cell_file.write(onos_nic_string + "\n")
andrewonlab94282092014-10-10 13:00:11 -0400474
475 for arg in onos_ip_addrs:
476 #For each argument in onos_ip_addrs, write to file
477 #Output should look like the following:
andrewonlabd4940492014-10-24 12:21:27 -0400478 # export OC1="10.128.20.11"
479 # export OC2="10.128.20.12"
andrewonlab94282092014-10-10 13:00:11 -0400480 cell_file.write(onos_string + str(temp_count) +
andrewonlabd4940492014-10-24 12:21:27 -0400481 "=" + "\"" + arg + "\"" + "\n" )
andrewonlab94282092014-10-10 13:00:11 -0400482 temp_count = temp_count + 1
483
andrewonlabd4940492014-10-24 12:21:27 -0400484 cell_file.write(mn_string +"\""+ mn_ip_addrs +"\""+ "\n")
485 cell_file.write(core_feature_string + "\n")
andrewonlab94282092014-10-10 13:00:11 -0400486 cell_file.close()
487
488 #We use os.system to send the command to TestON cluster
489 #to account for the case in which TestON is not located
490 #on the same cluster as the ONOS bench
491 #Note that even if TestON is located on the same cluster
492 #as ONOS bench, you must setup passwordless ssh
andrewonlab7e4d2d32014-10-15 13:23:21 -0400493 #between TestON and ONOS bench in order to automate the test.
andrewonlab94282092014-10-10 13:00:11 -0400494 os.system("scp "+temp_directory+file_name+
495 " admin@"+bench_ip+":"+cell_directory)
496
andrewonlab2a6c9342014-10-16 13:40:15 -0400497 return main.TRUE
498
andrewonlab94282092014-10-10 13:00:11 -0400499 except pexpect.EOF:
500 main.log.error(self.name + ": EOF exception found")
501 main.log.error(self.name + ": " + self.handle.before)
502 main.cleanup()
503 main.exit()
504 except:
505 main.log.info(self.name + ":::::::::")
506 main.log.error( traceback.print_exc() )
507 main.log.info(":::::::")
508 main.cleanup()
509 main.exit()
510
andrewonlab95ca1462014-10-09 14:04:24 -0400511 def set_cell(self, cellname):
512 '''
513 Calls 'cell <name>' to set the environment variables on ONOSbench
514 '''
515 try:
516 if not cellname:
517 main.log.error("Must define cellname")
518 main.cleanup()
519 main.exit()
520 else:
521 self.handle.sendline("cell "+str(cellname))
522 #Expect the cellname in the ONOS_CELL variable.
523 #Note that this variable name is subject to change
524 # and that this driver will have to change accordingly
525 self.handle.expect("ONOS_CELL="+str(cellname))
526 handle_before = self.handle.before
527 handle_after = self.handle.after
andrewonlabc03bf6c2014-10-09 14:56:18 -0400528 #Get the rest of the handle
529 self.handle.sendline("")
530 self.handle.expect("\$")
531 handle_more = self.handle.before
andrewonlab95ca1462014-10-09 14:04:24 -0400532
533 main.log.info("Cell call returned: "+handle_before+
andrewonlabc03bf6c2014-10-09 14:56:18 -0400534 handle_after + handle_more)
andrewonlab95ca1462014-10-09 14:04:24 -0400535
536 return main.TRUE
537
538 except pexpect.EOF:
539 main.log.error(self.name + ": EOF exception found")
540 main.log.error(self.name + ": " + self.handle.before)
541 main.cleanup()
542 main.exit()
543 except:
544 main.log.info(self.name+" ::::::")
545 main.log.error( traceback.print_exc())
546 main.log.info(self.name+" ::::::")
547 main.cleanup()
548 main.exit()
549
andrewonlabc03bf6c2014-10-09 14:56:18 -0400550 def verify_cell(self):
551 '''
552 Calls 'onos-verify-cell' to check for cell installation
553 '''
andrewonlab8d0d7d72014-10-09 16:33:15 -0400554 #TODO: Add meaningful expect value
555
andrewonlabc03bf6c2014-10-09 14:56:18 -0400556 try:
557 #Clean handle by sending empty and expecting $
558 self.handle.sendline("")
559 self.handle.expect("\$")
560 self.handle.sendline("onos-verify-cell")
561 self.handle.expect("\$")
562 handle_before = self.handle.before
563 handle_after = self.handle.after
564 #Get the rest of the handle
565 self.handle.sendline("")
566 self.handle.expect("\$")
567 handle_more = self.handle.before
568
569 main.log.info("Verify cell returned: "+handle_before+
570 handle_after + handle_more)
571
572 return main.TRUE
Jon Hall7993bfc2014-10-09 16:30:14 -0400573 except pexpect.EOF:
574 main.log.error(self.name + ": EOF exception found")
575 main.log.error(self.name + ": " + self.handle.before)
576 main.cleanup()
577 main.exit()
578 except:
579 main.log.info(self.name+" ::::::")
580 main.log.error( traceback.print_exc())
581 main.log.info(self.name+" ::::::")
582 main.cleanup()
583 main.exit()
584
andrewonlab05e362f2014-10-10 00:40:57 -0400585 def onos_cli(self, ONOS_ip, cmdstr):
586 '''
587 Uses 'onos' command to send various ONOS CLI arguments.
588 Required:
589 * ONOS_ip: specify the ip of the cell machine
andrewonlab94282092014-10-10 13:00:11 -0400590 * cmdstr: specify the command string to send
andrewonlab6e20c342014-10-10 18:08:48 -0400591
592 This function is intended to expose the entire karaf
593 CLI commands for ONOS. Try to use this function first
594 before attempting to write a ONOS CLI specific driver
595 function.
596 You can see a list of available 'cmdstr' arguments
597 by starting onos, and typing in 'onos' to enter the
598 onos> CLI. Then, type 'help' to see the list of
599 available commands.
andrewonlab05e362f2014-10-10 00:40:57 -0400600 '''
601 try:
602 if not ONOS_ip:
603 main.log.error("You must specify the IP address")
604 return main.FALSE
605 if not cmdstr:
606 main.log.error("You must specify the command string")
607 return main.FALSE
608
609 cmdstr = str(cmdstr)
610 self.handle.sendline("")
611 self.handle.expect("\$")
612
613 self.handle.sendline("onos -w " + ONOS_ip + " " + cmdstr)
614 self.handle.expect("\$")
615
Shreya Shaha73aaad2014-10-27 18:03:09 -0400616 handle_before = self.handle.before
617 print "handle_before = ", self.handle.before
andrewonlab05e362f2014-10-10 00:40:57 -0400618 handle_after = str(self.handle.after)
619
Shreya Shaha73aaad2014-10-27 18:03:09 -0400620 #self.handle.sendline("")
621 #self.handle.expect("\$")
622 #handle_more = str(self.handle.before)
andrewonlab05e362f2014-10-10 00:40:57 -0400623
624 main.log.info("Command sent successfully")
625
andrewonlab94282092014-10-10 13:00:11 -0400626 #Obtain return handle that consists of result from
627 #the onos command. The string may need to be
628 #configured further.
Shreya Shaha73aaad2014-10-27 18:03:09 -0400629 #return_string = handle_before + handle_after
630 return_string = handle_before
631 print "return_string = ", return_string
andrewonlab05e362f2014-10-10 00:40:57 -0400632 return return_string
633
634 except pexpect.EOF:
635 main.log.error(self.name + ": EOF exception found")
636 main.log.error(self.name + ": " + self.handle.before)
637 main.cleanup()
638 main.exit()
639 except:
640 main.log.info(self.name+" ::::::")
641 main.log.error( traceback.print_exc())
642 main.log.info(self.name+" ::::::")
643 main.cleanup()
644 main.exit()
Jon Hall7993bfc2014-10-09 16:30:14 -0400645
646 def onos_install(self, options="-f", node = ""):
647 '''
648 Installs ONOS bits on the designated cell machine.
649 If -f option is provided, it also forces an uninstall.
650 Presently, install also includes onos-push-bits and
651 onos-config within.
652 The node option allows you to selectively only push the jar
653 files to certain onos nodes
654
655 Returns: main.TRUE on success and main.FALSE on failure
656 '''
657 try:
658 self.handle.sendline("onos-install " + options + " " + node)
659 self.handle.expect("onos-install ")
660 #NOTE: this timeout may need to change depending on the network and size of ONOS
661 i=self.handle.expect(["Network\sis\sunreachable",
662 "onos\sstart/running,\sprocess",
663 pexpect.TIMEOUT],timeout=60)
664
Jon Hall7993bfc2014-10-09 16:30:14 -0400665 if i == 0:
666 main.log.warn("Network is unreachable")
667 return main.FALSE
668 elif i == 1:
Jon Hall42db6dc2014-10-24 19:03:48 -0400669 main.log.info("ONOS was installed on " + node + " and started")
Jon Hall7993bfc2014-10-09 16:30:14 -0400670 return main.TRUE
671 elif i == 2:
Jon Hall42db6dc2014-10-24 19:03:48 -0400672 main.log.info("Installation of ONOS on " + node + " timed out")
Jon Hall7993bfc2014-10-09 16:30:14 -0400673 return main.FALSE
andrewonlabc03bf6c2014-10-09 14:56:18 -0400674
675 except pexpect.EOF:
676 main.log.error(self.name + ": EOF exception found")
677 main.log.error(self.name + ": " + self.handle.before)
678 main.cleanup()
679 main.exit()
680 except:
681 main.log.info(self.name+" ::::::")
682 main.log.error( traceback.print_exc())
683 main.log.info(self.name+" ::::::")
684 main.cleanup()
685 main.exit()
andrewonlab95ca1462014-10-09 14:04:24 -0400686
andrewonlab8d0d7d72014-10-09 16:33:15 -0400687 def onos_start(self, node_ip):
688 '''
689 Calls onos command: 'onos-service [<node-ip>] start'
andrewonlabe8e56fd2014-10-09 17:12:44 -0400690 This command is a remote management of the ONOS upstart daemon
andrewonlab8d0d7d72014-10-09 16:33:15 -0400691 '''
692
693 try:
694 self.handle.sendline("")
695 self.handle.expect("\$")
696 self.handle.sendline("onos-service "+str(node_ip)+
697 " start")
698 i = self.handle.expect([
699 "Job\sis\salready\srunning",
700 "start/running",
701 "Unknown\sinstance",
Shreya Shahd01153d2014-10-23 15:08:56 -0400702 pexpect.TIMEOUT],timeout=120)
andrewonlab8d0d7d72014-10-09 16:33:15 -0400703
704 if i == 0:
705 main.log.info("Service is already running")
706 return main.TRUE
707 elif i == 1:
708 main.log.info("ONOS service started")
709 return main.TRUE
710 else:
711 main.log.error("ONOS service failed to start")
712 main.cleanup()
713 main.exit()
andrewonlab8d0d7d72014-10-09 16:33:15 -0400714 except pexpect.EOF:
715 main.log.error(self.name + ": EOF exception found")
716 main.log.error(self.name + ": " + self.handle.before)
717 main.cleanup()
718 main.exit()
719 except:
720 main.log.info(self.name+" ::::::")
721 main.log.error( traceback.print_exc())
722 main.log.info(self.name+" ::::::")
723 main.cleanup()
724 main.exit()
725
andrewonlab2b30bd32014-10-09 16:48:55 -0400726 def onos_stop(self, node_ip):
727 '''
728 Calls onos command: 'onos-service [<node-ip>] stop'
andrewonlabe8e56fd2014-10-09 17:12:44 -0400729 This command is a remote management of the ONOS upstart daemon
andrewonlab2b30bd32014-10-09 16:48:55 -0400730 '''
731 try:
732 self.handle.sendline("")
733 self.handle.expect("\$")
734 self.handle.sendline("onos-service "+str(node_ip)+
735 " stop")
736 i = self.handle.expect([
737 "stop/waiting",
738 "Unknown\sinstance",
739 pexpect.TIMEOUT],timeout=60)
740
741 if i == 0:
742 main.log.info("ONOS service stopped")
743 return main.TRUE
744 elif i == 1:
745 main.log.info("Unknown ONOS instance specified: "+
746 str(node_ip))
747 return main.FALSE
748 else:
749 main.log.error("ONOS service failed to stop")
750 return main.FALSE
751
752 except pexpect.EOF:
753 main.log.error(self.name + ": EOF exception found")
754 main.log.error(self.name + ": " + self.handle.before)
755 main.cleanup()
756 main.exit()
757 except:
758 main.log.info(self.name+" ::::::")
759 main.log.error( traceback.print_exc())
760 main.log.info(self.name+" ::::::")
761 main.cleanup()
762 main.exit()
763
andrewonlabc8d47972014-10-09 16:52:36 -0400764 def onos_uninstall(self):
765 '''
766 Calls the command: 'onos-uninstall'
andrewonlabe8e56fd2014-10-09 17:12:44 -0400767 Uninstalls ONOS from the designated cell machine, stopping
768 if needed
andrewonlabc8d47972014-10-09 16:52:36 -0400769 '''
770 try:
771 self.handle.sendline("")
772 self.handle.expect("\$")
773 self.handle.sendline("onos-uninstall")
774 self.handle.expect("\$")
775
andrewonlab84727452014-10-09 18:15:36 -0400776 main.log.info("ONOS cell machine was uninstalled")
andrewonlabc8d47972014-10-09 16:52:36 -0400777 #onos-uninstall command does not return any text
778 return main.TRUE
779
780 except pexpect.EOF:
781 main.log.error(self.name + ": EOF exception found")
782 main.log.error(self.name + ": " + self.handle.before)
783 main.cleanup()
784 main.exit()
785 except:
786 main.log.info(self.name+" ::::::")
787 main.log.error( traceback.print_exc())
788 main.log.info(self.name+" ::::::")
789 main.cleanup()
790 main.exit()
andrewonlab2b30bd32014-10-09 16:48:55 -0400791
andrewonlabe8e56fd2014-10-09 17:12:44 -0400792 def onos_kill(self, node_ip):
793 '''
794 Calls the command: 'onos-kill [<node-ip>]'
795 "Remotely, and unceremoniously kills the ONOS instance running on
796 the specified cell machine" - Tom V
797 '''
798
799 try:
800 self.handle.sendline("")
801 self.handle.expect("\$")
802 self.handle.sendline("onos-kill " + str(node_ip))
803 i = self.handle.expect([
804 "\$",
805 "No\sroute\sto\shost",
806 "password:",
807 pexpect.TIMEOUT], timeout=20)
808
809 if i == 0:
810 main.log.info("ONOS instance "+str(node_ip)+" was killed")
811 return main.TRUE
812 elif i == 1:
813 main.log.info("No route to host")
814 return main.FALSE
815 elif i == 2:
816 main.log.info("Passwordless login for host: "+str(node_ip)+
817 " not configured")
818 return main.FALSE
819 else:
820 main.log.info("ONOS instasnce was not killed")
821 return main.FALSE
822
823 except pexpect.EOF:
824 main.log.error(self.name + ": EOF exception found")
825 main.log.error(self.name + ": " + self.handle.before)
826 main.cleanup()
827 main.exit()
828 except:
829 main.log.info(self.name+" ::::::")
830 main.log.error( traceback.print_exc())
831 main.log.info(self.name+" ::::::")
832 main.cleanup()
833 main.exit()
834
andrewonlab94282092014-10-10 13:00:11 -0400835 def onos_start_network(self, mntopo):
836 '''
837 Calls the command 'onos-start-network [<mininet-topo>]
838 "remotely starts the specified topology on the cell's
839 mininet machine against all controllers configured in the
840 cell."
841 * Specify mininet topology file name for mntopo
842 * Topo files should be placed at:
843 ~/<your-onos-directory>/tools/test/topos
844
845 NOTE: This function will take you to the mininet prompt
846 '''
847 try:
848 if not mntopo:
849 main.log.error("You must specify a topo file to execute")
850 return main.FALSE
851
852 mntopo = str(mntopo)
853 self.handle.sendline("")
854 self.handle.expect("\$")
855
856 self.handle.sendline("onos-start-network " + mntopo)
857 self.handle.expect("mininet>")
858 main.log.info("Network started, entered mininet prompt")
859
860 #TODO: Think about whether return is necessary or not
861
862 except pexpect.EOF:
863 main.log.error(self.name + ": EOF exception found")
864 main.log.error(self.name + ": " + self.handle.before)
865 main.cleanup()
866 main.exit()
867 except:
868 main.log.info(self.name+" ::::::")
869 main.log.error( traceback.print_exc())
870 main.log.info(self.name+" ::::::")
871 main.cleanup()
872 main.exit()
873
874
Jon Hall7993bfc2014-10-09 16:30:14 -0400875 def isup(self, node = ""):
876 '''
Jon Hall77f53ce2014-10-13 18:02:06 -0400877 Run's onos-wait-for-start which only returns once ONOS is at run
878 level 100(ready for use)
andrewonlab8d0d7d72014-10-09 16:33:15 -0400879
Jon Hall7993bfc2014-10-09 16:30:14 -0400880 Returns: main.TRUE if ONOS is running and main.FALSE on timeout
881 '''
882 try:
883 self.handle.sendline("onos-wait-for-start " + node )
884 self.handle.expect("onos-wait-for-start")
885 #NOTE: this timeout is arbitrary"
shahshreya4d79aab2014-11-07 15:20:41 -0800886 i = self.handle.expect(["\$", pexpect.TIMEOUT], timeout = 300)
Jon Hall7993bfc2014-10-09 16:30:14 -0400887 if i == 0:
888 main.log.info(self.name + ": " + node + " is up")
889 return main.TRUE
890 elif i == 1:
891 #NOTE: since this function won't return until ONOS is ready,
892 # we will kill it on timeout
893 self.handle.sendline("\003") #Control-C
894 self.handle.expect("\$")
895 return main.FALSE
896 except pexpect.EOF:
897 main.log.error(self.name + ": EOF exception found")
898 main.log.error(self.name + ": " + self.handle.before)
899 main.cleanup()
900 main.exit()
901 except:
902 main.log.info(self.name+" ::::::")
903 main.log.error( traceback.print_exc())
904 main.log.info(self.name+" ::::::")
905 main.cleanup()
906 main.exit()
andrewonlab05e362f2014-10-10 00:40:57 -0400907
908
Shreya Shaha73aaad2014-10-27 18:03:09 -0400909 def get_topology(self,topology_output):
Jon Hall77f53ce2014-10-13 18:02:06 -0400910 '''
911 parses the onos:topology output
912 Returns: a topology dict populated by the key values found in
913 the cli command.
914 '''
915
916 try:
917 #call the cli to get the topology summary
Shreya Shaha73aaad2014-10-27 18:03:09 -0400918 #cmdstr = "onos:topology"
919 #cli_result = self.onos_cli(ip, cmdstr)
920 #print "cli_result = ", cli_result
Jon Hall77f53ce2014-10-13 18:02:06 -0400921
922 #Parse the output
923 topology = {}
924 #for line in cli_result.split("\n"):
Shreya Shaha73aaad2014-10-27 18:03:09 -0400925 for line in topology_output.splitlines():
Jon Hall77f53ce2014-10-13 18:02:06 -0400926 if not line.startswith("time="):
927 continue
928 #else
929 print line
930 for var in line.split(","):
Shreya Shaha73aaad2014-10-27 18:03:09 -0400931 #print "'"+var+"'"
932 #print "'"+var.strip()+"'"
Jon Hall77f53ce2014-10-13 18:02:06 -0400933 key, value = var.strip().split("=")
934 topology[key] = value
Shreya Shaha73aaad2014-10-27 18:03:09 -0400935 print "topology = ", topology
Jon Hall77f53ce2014-10-13 18:02:06 -0400936 devices = topology.get('devices', False)
Shreya Shaha73aaad2014-10-27 18:03:09 -0400937 print "devices = ", devices
Jon Hall77f53ce2014-10-13 18:02:06 -0400938 links = topology.get('links', False)
Shreya Shaha73aaad2014-10-27 18:03:09 -0400939 print "links = ", links
Jon Hall77f53ce2014-10-13 18:02:06 -0400940 clusters = topology.get('clusters', False)
Shreya Shaha73aaad2014-10-27 18:03:09 -0400941 print "clusters = ", clusters
Jon Hall77f53ce2014-10-13 18:02:06 -0400942 paths = topology.get('paths', False)
Shreya Shaha73aaad2014-10-27 18:03:09 -0400943 print "paths = ", paths
Jon Hall77f53ce2014-10-13 18:02:06 -0400944
945 return topology
946 except pexpect.EOF:
947 main.log.error(self.name + ": EOF exception found")
948 main.log.error(self.name + ": " + self.handle.before)
949 main.cleanup()
950 main.exit()
951 except:
952 main.log.info(self.name+" ::::::")
953 main.log.error( traceback.print_exc())
954 main.log.info(self.name+" ::::::")
955 main.cleanup()
956 main.exit()
Shreya Shaha73aaad2014-10-27 18:03:09 -0400957
958
Jon Hall77f53ce2014-10-13 18:02:06 -0400959
Shreya Shaha73aaad2014-10-27 18:03:09 -0400960 def check_status(self, topology_result, numoswitch, numolink, log_level="info"):
Jon Hall77f53ce2014-10-13 18:02:06 -0400961 '''
962 Checks the number of swithes & links that ONOS sees against the
963 supplied values. By default this will report to main.log, but the
964 log level can be specifid.
965
966 Params: ip = ip used for the onos cli
967 numoswitch = expected number of switches
968 numlink = expected number of links
969 log_level = level to log to. Currently accepts 'info', 'warn' and 'report'
970
971
972 log_level can
973
974 Returns: main.TRUE if the number of switchs and links are correct,
975 main.FALSE if the numer of switches and links is incorrect,
976 and main.ERROR otherwise
977 '''
978
979 try:
Shreya Shaha73aaad2014-10-27 18:03:09 -0400980 topology = self.get_topology(topology_result)
Jon Hall77f53ce2014-10-13 18:02:06 -0400981 if topology == {}:
982 return main.ERROR
983 output = ""
984 #Is the number of switches is what we expected
985 devices = topology.get('devices',False)
986 links = topology.get('links',False)
987 if devices == False or links == False:
988 return main.ERROR
989 switch_check = ( int(devices) == int(numoswitch) )
990 #Is the number of links is what we expected
991 link_check = ( int(links) == int(numolink) )
992 if (switch_check and link_check):
993 #We expected the correct numbers
994 output = output + "The number of links and switches match "\
995 + "what was expected"
996 result = main.TRUE
997 else:
998 output = output + \
999 "The number of links and switches does not match what was expected"
1000 result = main.FALSE
1001 output = output + "\n ONOS sees %i devices (%i expected) and %i links (%i expected)"\
1002 % ( int(devices), int(numoswitch), int(links), int(numolink) )
1003 if log_level == "report":
1004 main.log.report(output)
1005 elif log_level == "warn":
1006 main.log.warn(output)
1007 else:
1008 main.log.info(output)
1009 return result
1010 except pexpect.EOF:
1011 main.log.error(self.name + ": EOF exception found")
1012 main.log.error(self.name + ": " + self.handle.before)
1013 main.cleanup()
1014 main.exit()
1015 except:
1016 main.log.info(self.name+" ::::::")
1017 main.log.error( traceback.print_exc())
1018 main.log.info(self.name+" ::::::")
1019 main.cleanup()
1020 main.exit()
andrewonlabba44bcf2014-10-16 16:54:41 -04001021
andrewonlab970399c2014-11-07 13:09:32 -05001022 def tshark_pcap(self, interface, dir_file):
1023 '''
1024 Capture all packet activity and store in specified
1025 directory/file
1026
1027 Required:
1028 * interface: interface to capture
1029 * dir: directory/filename to store pcap
1030 '''
1031 self.handle.sendline("")
1032 self.handle.expect("\$")
1033
1034 self.handle.sendline("tshark -i "+str(interface)+
andrewonlab5d7a8f32014-11-10 13:07:56 -05001035 " -t e -w "+str(dir_file)+ " &")
1036 self.handle.sendline("\r")
andrewonlab970399c2014-11-07 13:09:32 -05001037 self.handle.expect("Capturing on")
andrewonlab5d7a8f32014-11-10 13:07:56 -05001038 self.handle.sendline("\r")
1039 self.handle.expect("\$")
andrewonlab970399c2014-11-07 13:09:32 -05001040
1041 main.log.info("Tshark started capturing files on "+
1042 str(interface)+ " and saving to directory: "+
andrewonlab5d7a8f32014-11-10 13:07:56 -05001043 str(dir_file))
Shreya Shaha73aaad2014-10-27 18:03:09 -04001044
shahshreya4d79aab2014-11-07 15:20:41 -08001045
1046 def run_onos_topo_cfg(self):
1047 '''
1048 On ONOS bench, run this command: ./~/ONOS/tools/test/bin/onos-topo-cfg
1049 which starts the rest and copies the json file to the onos instance
1050 '''
1051 self.handle.sendline("")
1052 self.handle.expect("\$")
1053 self.handle.sendline("cd ~/ONOS/tools/test/bin")
1054 self.handle.expect("/bin$")
1055 self.handle.sendline("./onos-topo-cfg")
1056 self.handle.expect("{}admin@onosTestBench")
1057 self.handle.sendline("cd ~")
1058 self.handle.expect("\$")
1059
1060
andrewonlabba44bcf2014-10-16 16:54:41 -04001061 def tshark_grep(self, grep, directory, interface='eth0'):
1062 '''
1063 Required:
1064 * grep string
1065 * directory to store results
1066 Optional:
1067 * interface - default: eth0
1068 Description:
1069 Uses tshark command to grep specific group of packets
1070 and stores the results to specified directory.
1071 The timestamp is hardcoded to be in epoch
1072 '''
1073 self.handle.sendline("")
1074 self.handle.expect("\$")
andrewonlabefd7f3d2014-10-21 16:02:31 -04001075 self.handle.sendline("")
andrewonlabba44bcf2014-10-16 16:54:41 -04001076 self.handle.sendline("tshark -i "+str(interface)+
andrewonlabd4940492014-10-24 12:21:27 -04001077 " -t e | grep --line-buffered \""+str(grep)+"\" >"+directory+" &")
andrewonlabba44bcf2014-10-16 16:54:41 -04001078 self.handle.sendline("\r")
1079 self.handle.expect("Capturing on")
1080 self.handle.sendline("\r")
1081 self.handle.expect("\$")
1082
1083 def tshark_stop(self):
1084 '''
1085 Removes wireshark files from /tmp and kills all tshark processes
1086 '''
andrewonlab5ba0d9e2014-10-24 13:32:23 -04001087 #Remove all pcap from previous captures
1088 self.execute(cmd="sudo rm /tmp/wireshark*")
andrewonlabba44bcf2014-10-16 16:54:41 -04001089 self.handle.sendline("")
1090 self.handle.sendline("sudo kill -9 `ps -ef | grep \"tshark -i\" |"+
1091 " grep -v grep | awk '{print $2}'`")
1092 self.handle.sendline("")
1093 main.log.info("Tshark stopped")
1094
andrewonlab0c38a4a2014-10-28 18:35:35 -04001095 def ptpd(self, args):
1096 '''
1097 Initiate ptp with user-specified args.
1098 Required:
1099 * args: specify string of args after command
1100 'sudo ptpd'
1101 '''
1102 try:
1103 self.handle.sendline("sudo ptpd "+str(args))
andrewonlab978dff62014-10-29 16:53:35 -04001104 i = self.handle.expect([
andrewonlab0c38a4a2014-10-28 18:35:35 -04001105 "Multiple",
1106 "Error",
1107 "\$"])
1108 self.handle.expect("\$")
andrewonlabba44bcf2014-10-16 16:54:41 -04001109
andrewonlab0c38a4a2014-10-28 18:35:35 -04001110 if i == 0:
1111 handle = self.handle.before
1112 main.log.info("ptpd returned an error: "+
1113 str(handle))
1114 return handle
1115 elif i == 1:
1116 handle = self.handle.before
1117 main.log.error("ptpd returned an error: "+
1118 str(handle))
1119 return handle
1120 else:
1121 return main.TRUE
1122
1123 except pexpect.EOF:
1124 main.log.error(self.name + ": EOF exception found")
1125 main.log.error(self.name + ": " + self.handle.before)
1126 main.cleanup()
1127 main.exit()
1128 except:
1129 main.log.info(self.name+" ::::::")
1130 main.log.error( traceback.print_exc())
1131 main.log.info(self.name+" ::::::")
1132 main.cleanup()
1133 main.exit()
andrewonlabba44bcf2014-10-16 16:54:41 -04001134
andrewonlab5d7a8f32014-11-10 13:07:56 -05001135 def cp_logs_to_dir(self, log_to_copy,
1136 dest_dir, copy_file_name=""):
1137 '''
1138 Copies logs to a desired directory.
1139 Current implementation of ONOS deletes its karaf
1140 logs on every iteration. For debugging purposes,
1141 you may want to use this function to capture
1142 certain karaf logs. (or any other logs if needed)
1143 Localtime will be attached to the filename
1144
1145 Required:
1146 * log_to_copy: specify directory and log name to
1147 copy.
1148 ex) /opt/onos/log/karaf.log.1
1149 For copying multiple files, leave copy_file_name
1150 empty and only specify dest_dir -
1151 ex) /opt/onos/log/karaf*
1152 * dest_dir: specify directory to copy to.
1153 ex) /tmp/
1154 Optional:
1155 * copy_file_name: If you want to rename the log
1156 file, specify copy_file_name. This will not work
1157 with multiple file copying
1158 '''
1159 try:
1160 localtime = time.strftime('%x %X')
1161 localtime = localtime.replace("/","")
1162 localtime = localtime.replace(" ","_")
1163 localtime = localtime.replace(":","")
1164 if dest_dir[-1:] != "/":
1165 dest_dir += "/"
1166
1167 if copy_file_name:
1168 self.handle.sendline("cp "+str(log_to_copy)+
1169 " "+str(dest_dir)+str(copy_file_name)+
1170 localtime)
1171 self.handle.expect("cp")
1172 self.handle.expect("\$")
1173 else:
1174 self.handle.sendline("cp "+str(log_to_copy)+
1175 " "+str(dest_dir))
1176 self.handle.expect("cp")
1177 self.handle.expect("\$")
1178
1179 return self.handle.before
1180
1181 except pexpect.EOF:
1182 main.log.error("Copying files failed")
1183 main.log.error(self.name + ": EOF exception found")
1184 main.log.error(self.name + ": " + self.handle.before)
1185 except:
1186 main.log.error("Copying files failed")
1187 main.log.info(self.name+" ::::::")
1188 main.log.error( traceback.print_exc())
1189 main.log.info(self.name+" ::::::")
1190
1191
andrewonlabba44bcf2014-10-16 16:54:41 -04001192