blob: 45713871fa722d36c665c1f82a7e4955a1c69149 [file] [log] [blame]
andrewonlab95ce8322014-10-13 14:12:04 -04001#!/usr/bin/env python
2
3'''
4This driver enters the onos> prompt to issue commands.
5
6Please follow the coding style demonstrated by existing
7functions and document properly.
8
9If you are a contributor to the driver, please
10list your email here for future contact:
11
12jhall@onlab.us
13andrew@onlab.us
Jon Halle8217482014-10-17 13:49:14 -040014shreya@onlab.us
andrewonlab95ce8322014-10-13 14:12:04 -040015
16OCT 13 2014
17
18'''
19
20import sys
21import time
22import pexpect
23import re
24import traceback
25import os.path
26import pydoc
Jon Halla001c392014-10-17 18:50:59 -040027import re
andrewonlab95ce8322014-10-13 14:12:04 -040028sys.path.append("../")
29from drivers.common.clidriver import CLI
30
31class OnosCliDriver(CLI):
32
33 def __init__(self):
34 '''
35 Initialize client
36 '''
37 super(CLI, self).__init__()
38
39 def connect(self,**connectargs):
40 '''
41 Creates ssh handle for ONOS cli.
42 '''
43 try:
44 for key in connectargs:
45 vars(self)[key] = connectargs[key]
46 self.home = "~/ONOS"
47 for key in self.options:
48 if key == "home":
49 self.home = self.options['home']
50 break
51
52
53 self.name = self.options['name']
54 self.handle = super(OnosCliDriver,self).connect(
55 user_name = self.user_name,
56 ip_address = self.ip_address,
57 port = self.port,
58 pwd = self.pwd,
59 home = self.home)
60
61 self.handle.sendline("cd "+ self.home)
62 self.handle.expect("\$")
63 if self.handle:
64 return self.handle
65 else :
66 main.log.info("NO ONOS HANDLE")
67 return main.FALSE
68 except pexpect.EOF:
69 main.log.error(self.name + ": EOF exception found")
70 main.log.error(self.name + ": " + self.handle.before)
71 main.cleanup()
72 main.exit()
73 except:
andrewonlab9627f432014-11-14 12:45:10 -050074 main.log.info(self.name + ":::::::::::::::::::::::")
andrewonlab95ce8322014-10-13 14:12:04 -040075 main.log.error( traceback.print_exc() )
andrewonlab9627f432014-11-14 12:45:10 -050076 main.log.info(":::::::::::::::::::::::")
andrewonlab95ce8322014-10-13 14:12:04 -040077 main.cleanup()
78 main.exit()
79
80 def disconnect(self):
81 '''
82 Called when Test is complete to disconnect the ONOS handle.
83 '''
84 response = ''
85 try:
andrewonlab2a6c9342014-10-16 13:40:15 -040086 self.handle.sendline("")
Jon Hall7e5b9172014-10-22 12:32:47 -040087 i = self.handle.expect(["onos>","\$"])
88 if i == 0:
89 self.handle.sendline("system:shutdown")
90 self.handle.expect("Confirm")
91 self.handle.sendline("yes")
92 self.handle.expect("\$")
93 self.handle.sendline("\n")
andrewonlabc2d05aa2014-10-13 16:51:10 -040094 self.handle.expect("\$")
Jon Hall7e5b9172014-10-22 12:32:47 -040095 self.handle.sendline("exit")
96 self.handle.expect("closed")
andrewonlabc2d05aa2014-10-13 16:51:10 -040097
andrewonlab95ce8322014-10-13 14:12:04 -040098 except pexpect.EOF:
99 main.log.error(self.name + ": EOF exception found")
100 main.log.error(self.name + ": " + self.handle.before)
101 except:
102 main.log.error(self.name + ": Connection failed to the host")
103 response = main.FALSE
104 return response
105
andrewonlab38d2b4a2014-11-13 16:28:47 -0500106 def logout(self):
107 '''
108 Sends 'logout' command to ONOS cli
109 '''
110 try:
andrewonlab9627f432014-11-14 12:45:10 -0500111 self.handle.sendline("")
112 i = self.handle.expect([
113 "onos>",
114 "\$"], timeout=10)
115 if i == 0:
116 self.handle.sendline("logout")
117 self.handle.expect("\$")
118 elif i == 1:
119 return main.TRUE
120
andrewonlab38d2b4a2014-11-13 16:28:47 -0500121 except pexpect.EOF:
122 main.log.error(self.name + ": eof exception found")
andrewonlab9627f432014-11-14 12:45:10 -0500123 main.log.error(self.name + ": " +
124 self.handle.before)
andrewonlab38d2b4a2014-11-13 16:28:47 -0500125 main.cleanup()
126 main.exit()
127 except:
128 main.log.info(self.name+" ::::::")
129 main.log.error( traceback.print_exc())
130 main.log.info(self.name+" ::::::")
131 main.cleanup()
132 main.exit()
133
andrewonlab95ce8322014-10-13 14:12:04 -0400134 def set_cell(self, cellname):
135 '''
136 Calls 'cell <name>' to set the environment variables on ONOSbench
137
138 Before issuing any cli commands, set the environment variable first.
139 '''
140 try:
141 if not cellname:
142 main.log.error("Must define cellname")
143 main.cleanup()
144 main.exit()
145 else:
146 self.handle.sendline("cell "+str(cellname))
147 #Expect the cellname in the ONOS_CELL variable.
148 #Note that this variable name is subject to change
149 # and that this driver will have to change accordingly
150 self.handle.expect("ONOS_CELL="+str(cellname))
151 handle_before = self.handle.before
152 handle_after = self.handle.after
153 #Get the rest of the handle
154 self.handle.sendline("")
155 self.handle.expect("\$")
156 handle_more = self.handle.before
157
158 main.log.info("Cell call returned: "+handle_before+
159 handle_after + handle_more)
160
161 return main.TRUE
162
163 except pexpect.EOF:
andrewonlab38d2b4a2014-11-13 16:28:47 -0500164 main.log.error(self.name + ": eof exception found")
andrewonlab95ce8322014-10-13 14:12:04 -0400165 main.log.error(self.name + ": " + self.handle.before)
166 main.cleanup()
167 main.exit()
168 except:
169 main.log.info(self.name+" ::::::")
170 main.log.error( traceback.print_exc())
171 main.log.info(self.name+" ::::::")
172 main.cleanup()
173 main.exit()
174
andrewonlabc2d05aa2014-10-13 16:51:10 -0400175 def start_onos_cli(self, ONOS_ip):
andrewonlab95ce8322014-10-13 14:12:04 -0400176 try:
177 self.handle.sendline("")
andrewonlab48829f62014-11-17 13:49:01 -0500178 x = self.handle.expect([
179 "\$", "onos>"], timeout=10)
180
181 if x == 1:
182 main.log.info("ONOS cli is already running")
183 return main.TRUE
andrewonlab95ce8322014-10-13 14:12:04 -0400184
185 #Wait for onos start (-w) and enter onos cli
andrewonlabc2d05aa2014-10-13 16:51:10 -0400186 self.handle.sendline("onos -w "+str(ONOS_ip))
andrewonlab2a7ea9b2014-10-24 12:21:05 -0400187 i = self.handle.expect([
188 "onos>",
189 pexpect.TIMEOUT],timeout=60)
190
191 if i == 0:
192 main.log.info(str(ONOS_ip)+" CLI Started successfully")
193 return main.TRUE
194 else:
andrewonlab3a7c3c72014-10-24 17:21:03 -0400195 #If failed, send ctrl+c to process and try again
andrewonlabf47993a2014-10-24 17:56:01 -0400196 main.log.info("Starting CLI failed. Retrying...")
andrewonlab3a7c3c72014-10-24 17:21:03 -0400197 self.handle.sendline("\x03")
198 self.handle.sendline("onos -w "+str(ONOS_ip))
199 i = self.handle.expect(["onos>",pexpect.TIMEOUT],
200 timeout=30)
201 if i == 0:
202 return main.TRUE
203 else:
204 main.log.error("Connection to CLI "+\
andrewonlab2a7ea9b2014-10-24 12:21:05 -0400205 str(ONOS_ip)+" timeout")
andrewonlab3a7c3c72014-10-24 17:21:03 -0400206 return main.FALSE
andrewonlab95ce8322014-10-13 14:12:04 -0400207
208 except pexpect.EOF:
209 main.log.error(self.name + ": EOF exception found")
210 main.log.error(self.name + ": " + self.handle.before)
211 main.cleanup()
212 main.exit()
213 except:
214 main.log.info(self.name+" ::::::")
215 main.log.error( traceback.print_exc())
216 main.log.info(self.name+" ::::::")
217 main.cleanup()
218 main.exit()
219
andrewonlaba18f6bf2014-10-13 19:31:54 -0400220 def sendline(self, cmd_str):
221 '''
222 Send a completely user specified string to
223 the onos> prompt. Use this function if you have
224 a very specific command to send.
225
226 Warning: There are no sanity checking to commands
227 sent using this method.
228 '''
229 try:
230 self.handle.sendline("")
231 self.handle.expect("onos>")
232
233 self.handle.sendline(cmd_str)
234 self.handle.expect("onos>")
235
236 handle = self.handle.before
237
238 self.handle.sendline("")
239 self.handle.expect("onos>")
240
241 handle += self.handle.before
242 handle += self.handle.after
243
244 main.log.info("Command sent.")
Jon Hall42db6dc2014-10-24 19:03:48 -0400245 ansi_escape = re.compile(r'\x1b[^m]*m')
246 handle = ansi_escape.sub('', handle)
andrewonlaba18f6bf2014-10-13 19:31:54 -0400247
248 return handle
249 except pexpect.EOF:
250 main.log.error(self.name + ": EOF exception found")
251 main.log.error(self.name + ": " + self.handle.before)
252 main.cleanup()
253 main.exit()
254 except:
255 main.log.info(self.name+" ::::::")
256 main.log.error( traceback.print_exc())
257 main.log.info(self.name+" ::::::")
258 main.cleanup()
259 main.exit()
260
andrewonlab95ce8322014-10-13 14:12:04 -0400261 #IMPORTANT NOTE:
262 #For all cli commands, naming convention should match
263 #the cli command replacing ':' with '_'.
264 #Ex) onos:topology > onos_topology
265 # onos:links > onos_links
266 # feature:list > feature_list
andrewonlabc2d05aa2014-10-13 16:51:10 -0400267
268 def add_node(self, node_id, ONOS_ip, tcp_port=""):
269 '''
270 Adds a new cluster node by ID and address information.
271 Required:
272 * node_id
273 * ONOS_ip
274 Optional:
275 * tcp_port
276 '''
277 try:
278 self.handle.sendline("")
279 self.handle.expect("onos>")
280
281 self.handle.sendline("add-node "+
282 str(node_id)+" "+
283 str(ONOS_ip)+" "+
284 str(tcp_port))
285
286 i = self.handle.expect([
287 "Error",
288 "onos>" ])
289
290 #Clear handle to get previous output
291 self.handle.sendline("")
292 self.handle.expect("onos>")
293
294 handle = self.handle.before
295
296 if i == 0:
297 main.log.error("Error in adding node")
298 main.log.error(handle)
299 return main.FALSE
300 else:
301 main.log.info("Node "+str(ONOS_ip)+" added")
302 return main.TRUE
303
304 except pexpect.EOF:
305 main.log.error(self.name + ": EOF exception found")
306 main.log.error(self.name + ": " + self.handle.before)
307 main.cleanup()
308 main.exit()
309 except:
310 main.log.info(self.name+" ::::::")
311 main.log.error( traceback.print_exc())
312 main.log.info(self.name+" ::::::")
313 main.cleanup()
314 main.exit()
315
andrewonlab86dc3082014-10-13 18:18:38 -0400316 def remove_node(self, node_id):
317 '''
318 Removes a cluster by ID
319 Issues command: 'remove-node [<node-id>]'
320 Required:
321 * node_id
322 '''
323 try:
324 self.handle.sendline("")
325 self.handle.expect("onos>")
326
327 self.handle.sendline("remove-node "+str(node_id))
328 self.handle.expect("onos>")
329
330 return main.TRUE
331
332 except pexpect.EOF:
333 main.log.error(self.name + ": EOF exception found")
334 main.log.error(self.name + ": " + self.handle.before)
335 main.cleanup()
336 main.exit()
337 except:
338 main.log.info(self.name+" ::::::")
339 main.log.error( traceback.print_exc())
340 main.log.info(self.name+" ::::::")
341 main.cleanup()
342 main.exit()
andrewonlabc2d05aa2014-10-13 16:51:10 -0400343
andrewonlab7c211572014-10-15 16:45:20 -0400344 def nodes(self):
345 '''
346 List the nodes currently visible
347 Issues command: 'nodes'
348 Returns: entire handle of list of nodes
349 '''
350 try:
351 self.handle.sendline("")
352 self.handle.expect("onos>")
353
354 self.handle.sendline("nodes")
355 self.handle.expect("onos>")
356
357 self.handle.sendline("")
358 self.handle.expect("onos>")
359
360 handle = self.handle.before
361
362 return handle
363
364 except pexpect.EOF:
365 main.log.error(self.name + ": EOF exception found")
366 main.log.error(self.name + ": " + self.handle.before)
367 main.cleanup()
368 main.exit()
369 except:
370 main.log.info(self.name+" ::::::")
371 main.log.error( traceback.print_exc())
372 main.log.info(self.name+" ::::::")
373 main.cleanup()
374 main.exit()
375
andrewonlab38d6ae22014-10-15 14:23:45 -0400376 def topology(self):
andrewonlabc2d05aa2014-10-13 16:51:10 -0400377 '''
378 Shows the current state of the topology
379 by issusing command: 'onos> onos:topology'
380 '''
andrewonlab95ce8322014-10-13 14:12:04 -0400381 try:
382 self.handle.sendline("")
383 self.handle.expect("onos>")
andrewonlab38d6ae22014-10-15 14:23:45 -0400384 #either onos:topology or 'topology' will work in CLI
andrewonlab95ce8322014-10-13 14:12:04 -0400385 self.handle.sendline("onos:topology")
386 self.handle.expect("onos>")
387
388 handle = self.handle.before
389
390 main.log.info("onos:topology returned: " +
391 str(handle))
392
393 return handle
394
395 except pexpect.EOF:
396 main.log.error(self.name + ": EOF exception found")
397 main.log.error(self.name + ": " + self.handle.before)
398 main.cleanup()
399 main.exit()
400 except:
401 main.log.info(self.name+" ::::::")
402 main.log.error( traceback.print_exc())
403 main.log.info(self.name+" ::::::")
404 main.cleanup()
405 main.exit()
andrewonlabc2d05aa2014-10-13 16:51:10 -0400406
407 def feature_install(self, feature_str):
408 '''
409 Installs a specified feature
410 by issuing command: 'onos> feature:install <feature_str>'
411 '''
412 try:
413 self.handle.sendline("")
414 self.handle.expect("onos>")
415
416 self.handle.sendline("feature:install "+str(feature_str))
417 self.handle.expect("onos>")
418
419 return main.TRUE
420
421 except pexpect.EOF:
422 main.log.error(self.name + ": EOF exception found")
423 main.log.error(self.name + ": " + self.handle.before)
andrewonlabbf225b02014-11-12 12:14:05 -0500424 main.log.report("Failed to install feature")
425 main.log.report("Exiting test")
andrewonlabc2d05aa2014-10-13 16:51:10 -0400426 main.cleanup()
427 main.exit()
428 except:
429 main.log.info(self.name+" ::::::")
430 main.log.error( traceback.print_exc())
andrewonlabbf225b02014-11-12 12:14:05 -0500431 main.log.report("Failed to install feature")
432 main.log.report("Exiting test")
andrewonlabc2d05aa2014-10-13 16:51:10 -0400433 main.log.info(self.name+" ::::::")
434 main.cleanup()
435 main.exit()
436
437 def feature_uninstall(self, feature_str):
438 '''
439 Uninstalls a specified feature
440 by issuing command: 'onos> feature:uninstall <feature_str>'
441 '''
442 try:
443 self.handle.sendline("")
444 self.handle.expect("onos>")
445
446 self.handle.sendline("feature:uninstall "+str(feature_str))
447 self.handle.expect("onos>")
448
449 return main.TRUE
450
451 except pexpect.EOF:
452 main.log.error(self.name + ": EOF exception found")
453 main.log.error(self.name + ": " + self.handle.before)
454 main.cleanup()
455 main.exit()
456 except:
457 main.log.info(self.name+" ::::::")
458 main.log.error( traceback.print_exc())
459 main.log.info(self.name+" ::::::")
460 main.cleanup()
461 main.exit()
andrewonlab95ce8322014-10-13 14:12:04 -0400462
Jon Halle8217482014-10-17 13:49:14 -0400463 def devices(self, json_format=True, grep_str=""):
andrewonlab86dc3082014-10-13 18:18:38 -0400464 '''
Jon Hall7b02d952014-10-17 20:14:54 -0400465 Lists all infrastructure devices or switches
andrewonlab86dc3082014-10-13 18:18:38 -0400466 Optional argument:
467 * grep_str - pass in a string to grep
468 '''
469 try:
470 self.handle.sendline("")
471 self.handle.expect("onos>")
Jon Halle8217482014-10-17 13:49:14 -0400472
473 if json_format:
474 if not grep_str:
475 self.handle.sendline("devices -j")
476 self.handle.expect("devices -j")
477 self.handle.expect("onos>")
478 else:
479 self.handle.sendline("devices -j | grep '"+
andrewonlab86dc3082014-10-13 18:18:38 -0400480 str(grep_str)+"'")
Jon Halle8217482014-10-17 13:49:14 -0400481 self.handle.expect("devices -j | grep '"+str(grep_str)+"'")
482 self.handle.expect("onos>")
Jon Halla001c392014-10-17 18:50:59 -0400483 handle = self.handle.before
Jon Halld815ce42014-10-17 19:52:30 -0400484 '''
485 handle variable here contains some ANSI escape color code sequences at the end which are invisible in the print command output
486 To make that escape sequence visible, use repr() function. The repr(handle) output when printed shows the ANSI escape sequences.
Jon Hall5227ce82014-10-17 20:09:51 -0400487 In json.loads(somestring), this somestring variable is actually repr(somestring) and json.loads would fail with the escape sequence.
Jon Hall983a1702014-10-28 18:44:22 -0400488 So we take off that escape sequence using
Jon Halld815ce42014-10-17 19:52:30 -0400489 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
Jon Hall983a1702014-10-28 18:44:22 -0400490 handle1 = ansi_escape.sub('', handle)
Jon Halld815ce42014-10-17 19:52:30 -0400491 '''
492 #print "repr(handle) =", repr(handle)
Jon Halla001c392014-10-17 18:50:59 -0400493 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
494 handle1 = ansi_escape.sub('', handle)
Jon Halld815ce42014-10-17 19:52:30 -0400495 #print "repr(handle1) = ", repr(handle1)
Jon Halla001c392014-10-17 18:50:59 -0400496 return handle1
Jon Halle8217482014-10-17 13:49:14 -0400497 else:
498 if not grep_str:
499 self.handle.sendline("devices")
andrewonlab9a50dfe2014-10-17 17:22:31 -0400500 self.handle.expect("onos>")
Jon Halle8217482014-10-17 13:49:14 -0400501 else:
502 self.handle.sendline("devices | grep '"+
503 str(grep_str)+"'")
Jon Halle8217482014-10-17 13:49:14 -0400504 self.handle.expect("onos>")
Jon Hallcd707292014-10-17 19:06:17 -0400505 handle = self.handle.before
Jon Hall983a1702014-10-28 18:44:22 -0400506 #print "handle =",handle
Jon Hallcd707292014-10-17 19:06:17 -0400507 return handle
andrewonlab7c211572014-10-15 16:45:20 -0400508 except pexpect.EOF:
509 main.log.error(self.name + ": EOF exception found")
510 main.log.error(self.name + ": " + self.handle.before)
511 main.cleanup()
512 main.exit()
513 except:
514 main.log.info(self.name+" ::::::")
515 main.log.error( traceback.print_exc())
516 main.log.info(self.name+" ::::::")
517 main.cleanup()
518 main.exit()
519
Jon Halle8217482014-10-17 13:49:14 -0400520 def links(self, json_format=True, grep_str=""):
521 '''
522 Lists all core links
523 Optional argument:
524 * grep_str - pass in a string to grep
525 '''
526 try:
527 self.handle.sendline("")
528 self.handle.expect("onos>")
529
530 if json_format:
531 if not grep_str:
532 self.handle.sendline("links -j")
533 self.handle.expect("links -j")
534 self.handle.expect("onos>")
535 else:
536 self.handle.sendline("links -j | grep '"+
537 str(grep_str)+"'")
538 self.handle.expect("links -j | grep '"+str(grep_str)+"'")
539 self.handle.expect("onos>")
Jon Hallcd707292014-10-17 19:06:17 -0400540 handle = self.handle.before
Jon Halld815ce42014-10-17 19:52:30 -0400541 '''
542 handle variable here contains some ANSI escape color code sequences at the end which are invisible in the print command output
543 To make that escape sequence visible, use repr() function. The repr(handle) output when printed shows the ANSI escape sequences.
Jon Hall5227ce82014-10-17 20:09:51 -0400544 In json.loads(somestring), this somestring variable is actually repr(somestring) and json.loads would fail with the escape sequence.
Jon Halld815ce42014-10-17 19:52:30 -0400545 So we take off that escape sequence using
546 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
547 handle1 = ansi_escape.sub('', handle)
548 '''
549 #print "repr(handle) =", repr(handle)
Jon Halla001c392014-10-17 18:50:59 -0400550 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
551 handle1 = ansi_escape.sub('', handle)
Jon Halld815ce42014-10-17 19:52:30 -0400552 #print "repr(handle1) = ", repr(handle1)
Jon Halla001c392014-10-17 18:50:59 -0400553 return handle1
Jon Halle8217482014-10-17 13:49:14 -0400554 else:
555 if not grep_str:
556 self.handle.sendline("links")
andrewonlab9a50dfe2014-10-17 17:22:31 -0400557 self.handle.expect("onos>")
Jon Halle8217482014-10-17 13:49:14 -0400558 else:
559 self.handle.sendline("links | grep '"+
560 str(grep_str)+"'")
andrewonlab9a50dfe2014-10-17 17:22:31 -0400561 self.handle.expect("onos>")
Jon Halla001c392014-10-17 18:50:59 -0400562 handle = self.handle.before
Jon Hall983a1702014-10-28 18:44:22 -0400563 #print "handle =",handle
Jon Halla001c392014-10-17 18:50:59 -0400564 return handle
Jon Halle8217482014-10-17 13:49:14 -0400565 except pexpect.EOF:
566 main.log.error(self.name + ": EOF exception found")
567 main.log.error(self.name + ": " + self.handle.before)
568 main.cleanup()
569 main.exit()
570 except:
571 main.log.info(self.name+" ::::::")
572 main.log.error( traceback.print_exc())
573 main.log.info(self.name+" ::::::")
574 main.cleanup()
575 main.exit()
576
577
578 def ports(self, json_format=True, grep_str=""):
579 '''
580 Lists all ports
581 Optional argument:
582 * grep_str - pass in a string to grep
583 '''
584 try:
585 self.handle.sendline("")
586 self.handle.expect("onos>")
587
588 if json_format:
589 if not grep_str:
590 self.handle.sendline("ports -j")
591 self.handle.expect("ports -j")
592 self.handle.expect("onos>")
593 else:
594 self.handle.sendline("ports -j | grep '"+
595 str(grep_str)+"'")
596 self.handle.expect("ports -j | grep '"+str(grep_str)+"'")
597 self.handle.expect("onos>")
Jon Hallcd707292014-10-17 19:06:17 -0400598 handle = self.handle.before
Jon Halld815ce42014-10-17 19:52:30 -0400599 '''
600 handle variable here contains some ANSI escape color code sequences at the end which are invisible in the print command output
601 To make that escape sequence visible, use repr() function. The repr(handle) output when printed shows the ANSI escape sequences.
Jon Hall5227ce82014-10-17 20:09:51 -0400602 In json.loads(somestring), this somestring variable is actually repr(somestring) and json.loads would fail with the escape sequence.
Shreya Shah0c525cc2014-10-17 20:20:24 -0400603 So we take off that escape sequence using the following commads:
Jon Halld815ce42014-10-17 19:52:30 -0400604 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
605 handle1 = ansi_escape.sub('', handle)
606 '''
607 #print "repr(handle) =", repr(handle)
Jon Halla001c392014-10-17 18:50:59 -0400608 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
609 handle1 = ansi_escape.sub('', handle)
Jon Halld815ce42014-10-17 19:52:30 -0400610 #print "repr(handle1) = ", repr(handle1)
Jon Halla001c392014-10-17 18:50:59 -0400611 return handle1
612
Jon Halle8217482014-10-17 13:49:14 -0400613 else:
614 if not grep_str:
615 self.handle.sendline("ports")
andrewonlab9a50dfe2014-10-17 17:22:31 -0400616 self.handle.expect("onos>")
617 self.handle.sendline("")
Jon Halle8217482014-10-17 13:49:14 -0400618 self.handle.expect("onos>")
619 else:
620 self.handle.sendline("ports | grep '"+
621 str(grep_str)+"'")
Jon Halle8217482014-10-17 13:49:14 -0400622 self.handle.expect("onos>")
andrewonlab9a50dfe2014-10-17 17:22:31 -0400623 self.handle.sendline("")
Jon Halle8217482014-10-17 13:49:14 -0400624 self.handle.expect("onos>")
Jon Halla001c392014-10-17 18:50:59 -0400625 handle = self.handle.before
Jon Hall983a1702014-10-28 18:44:22 -0400626 #print "handle =",handle
Jon Hallcd707292014-10-17 19:06:17 -0400627 return handle
Jon Halle8217482014-10-17 13:49:14 -0400628 except pexpect.EOF:
629 main.log.error(self.name + ": EOF exception found")
630 main.log.error(self.name + ": " + self.handle.before)
631 main.cleanup()
632 main.exit()
633 except:
634 main.log.info(self.name+" ::::::")
635 main.log.error( traceback.print_exc())
636 main.log.info(self.name+" ::::::")
637 main.cleanup()
638 main.exit()
639
640
Jon Hall983a1702014-10-28 18:44:22 -0400641 def roles(self, json_format=True, grep_str=""):
andrewonlab7c211572014-10-15 16:45:20 -0400642 '''
Jon Hall983a1702014-10-28 18:44:22 -0400643 Lists all devices and the controllers with roles assigned to them
644 Optional argument:
645 * grep_str - pass in a string to grep
andrewonlab7c211572014-10-15 16:45:20 -0400646 '''
647 try:
648 self.handle.sendline("")
649 self.handle.expect("onos>")
andrewonlab7c211572014-10-15 16:45:20 -0400650
Jon Hall983a1702014-10-28 18:44:22 -0400651 if json_format:
652 if not grep_str:
653 self.handle.sendline("roles -j")
654 self.handle.expect("roles -j")
655 self.handle.expect("onos>")
656 else:
657 self.handle.sendline("roles -j | grep '"+
658 str(grep_str)+"'")
659 self.handle.expect("roles -j | grep '"+str(grep_str)+"'")
660 self.handle.expect("onos>")
661 handle = self.handle.before
662 '''
663 handle variable here contains some ANSI escape color code sequences at the end which are invisible in the print command output
664 To make that escape sequence visible, use repr() function. The repr(handle) output when printed shows the ANSI escape sequences.
665 In json.loads(somestring), this somestring variable is actually repr(somestring) and json.loads would fail with the escape sequence.
666 So we take off that escape sequence using the following commads:
667 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
668 handle1 = ansi_escape.sub('', handle)
669 '''
670 #print "repr(handle) =", repr(handle)
671 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
672 handle1 = ansi_escape.sub('', handle)
673 #print "repr(handle1) = ", repr(handle1)
674 return handle1
andrewonlab7c211572014-10-15 16:45:20 -0400675
andrewonlab7c211572014-10-15 16:45:20 -0400676 else:
Jon Hall983a1702014-10-28 18:44:22 -0400677 if not grep_str:
678 self.handle.sendline("roles")
679 self.handle.expect("onos>")
680 self.handle.sendline("")
681 self.handle.expect("onos>")
682 else:
683 self.handle.sendline("roles | grep '"+
684 str(grep_str)+"'")
685 self.handle.expect("onos>")
686 self.handle.sendline("")
687 self.handle.expect("onos>")
688 handle = self.handle.before
689 #print "handle =",handle
690 return handle
691 except pexpect.EOF:
692 main.log.error(self.name + ": EOF exception found")
693 main.log.error(self.name + ": " + self.handle.before)
694 main.cleanup()
695 main.exit()
696 except:
697 main.log.info(self.name+" ::::::")
698 main.log.error( traceback.print_exc())
699 main.log.info(self.name+" ::::::")
700 main.cleanup()
701 main.exit()
702
703 def get_role(self, device_id):
704 '''
705 Given the a string containing the json representation of the "roles" cli command and a
706 partial or whole device id, returns a json object containing the
707 roles output for the first device whose id contains "device_id"
708
709 Returns:
710 Dict of the role assignments for the given device or
711 None if not match
712 '''
713 try:
714 import json
715 if device_id == None:
716 return None
717 else:
718 raw_roles = self.roles()
719 roles_json = json.loads(raw_roles)
720 #search json for the device with id then return the device
721 for device in roles_json:
Jon Hall720653a2014-10-28 19:02:37 -0400722 #print device
Jon Hall983a1702014-10-28 18:44:22 -0400723 if str(device_id) in device['id']:
724 return device
725 return None
andrewonlab7c211572014-10-15 16:45:20 -0400726
andrewonlab86dc3082014-10-13 18:18:38 -0400727 except pexpect.EOF:
728 main.log.error(self.name + ": EOF exception found")
729 main.log.error(self.name + ": " + self.handle.before)
730 main.cleanup()
731 main.exit()
732 except:
733 main.log.info(self.name+" ::::::")
734 main.log.error( traceback.print_exc())
735 main.log.info(self.name+" ::::::")
736 main.cleanup()
737 main.exit()
andrewonlab2a6c9342014-10-16 13:40:15 -0400738
andrewonlab3e15ead2014-10-15 14:21:34 -0400739 def paths(self, src_id, dst_id):
740 '''
741 Returns string of paths, and the cost.
742 Issues command: onos:paths <src> <dst>
743 '''
744 try:
745 self.handle.sendline("")
746 self.handle.expect("onos>")
747
748 self.handle.sendline("onos:paths "+
749 str(src_id) + " " + str(dst_id))
750 i = self.handle.expect([
751 "Error",
752 "onos>"])
753
754 self.handle.sendline("")
755 self.handle.expect("onos>")
756
757 handle = self.handle.before
758
759 if i == 0:
760 main.log.error("Error in getting paths")
andrewonlab7c211572014-10-15 16:45:20 -0400761 return (handle, "Error")
andrewonlab3e15ead2014-10-15 14:21:34 -0400762 else:
763 path = handle.split(";")[0]
764 cost = handle.split(";")[1]
765 return (path, cost)
766
767 except pexpect.EOF:
768 main.log.error(self.name + ": EOF exception found")
769 main.log.error(self.name + ": " + self.handle.before)
770 main.cleanup()
771 main.exit()
772 except:
773 main.log.info(self.name+" ::::::")
774 main.log.error( traceback.print_exc())
775 main.log.info(self.name+" ::::::")
776 main.cleanup()
777 main.exit()
andrewonlab3f0a4af2014-10-17 12:25:14 -0400778
Jon Hall42db6dc2014-10-24 19:03:48 -0400779 def hosts(self, json_format=True, grep_str=""):
780 '''
781 Lists all discovered hosts
782 Optional argument:
783 * grep_str - pass in a string to grep
784 '''
785 try:
786 self.handle.sendline("")
787 self.handle.expect("onos>")
788
789 if json_format:
790 if not grep_str:
791 self.handle.sendline("hosts -j")
792 self.handle.expect("hosts -j")
793 self.handle.expect("onos>")
794 else:
795 self.handle.sendline("hosts -j | grep '"+
796 str(grep_str)+"'")
797 self.handle.expect("hosts -j | grep '"+str(grep_str)+"'")
798 self.handle.expect("onos>")
799 handle = self.handle.before
800 '''
801 handle variable here contains some ANSI escape color code sequences at the end which are invisible in the print command output
802 To make that escape sequence visible, use repr() function. The repr(handle) output when printed shows the ANSI escape sequences.
803 In json.loads(somestring), this somestring variable is actually repr(somestring) and json.loads would fail with the escape sequence.
804 So we take off that escape sequence using
805 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
806 handle1 = ansi_escape.sub('', handle)
807 '''
808 #print "repr(handle) =", repr(handle)
809 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
810 handle1 = ansi_escape.sub('', handle)
811 #print "repr(handle1) = ", repr(handle1)
812 return handle1
813 else:
814 if not grep_str:
815 self.handle.sendline("hosts")
816 self.handle.expect("onos>")
817 else:
818 self.handle.sendline("hosts | grep '"+
819 str(grep_str)+"'")
820 self.handle.expect("onos>")
821 handle = self.handle.before
Jon Hall983a1702014-10-28 18:44:22 -0400822 #print "handle =",handle
Jon Hall42db6dc2014-10-24 19:03:48 -0400823 return handle
824 except pexpect.EOF:
825 main.log.error(self.name + ": EOF exception found")
826 main.log.error(self.name + ": " + self.handle.before)
827 main.cleanup()
828 main.exit()
829 except:
830 main.log.info(self.name+" ::::::")
831 main.log.error( traceback.print_exc())
832 main.log.info(self.name+" ::::::")
833 main.cleanup()
834 main.exit()
835
836 def get_host(self, mac):
837 '''
838 Return the first host from the hosts api whose 'id' contains 'mac'
839 Note: mac must be a colon seperated mac address, but could be a partial mac address
840 Return None if there is no match
841 '''
842 import json
843 try:
844 if mac == None:
845 return None
846 else:
847 mac = mac
848 raw_hosts = self.hosts()
849 hosts_json = json.loads(raw_hosts)
850 #search json for the host with mac then return the device
851 for host in hosts_json:
Jon Hall983a1702014-10-28 18:44:22 -0400852 #print "%s in %s?" % (mac, host['id'])
Jon Hall42db6dc2014-10-24 19:03:48 -0400853 if mac in host['id']:
854 return host
855 return None
856 except pexpect.EOF:
857 main.log.error(self.name + ": EOF exception found")
858 main.log.error(self.name + ": " + self.handle.before)
859 main.cleanup()
860 main.exit()
861 except:
862 main.log.info(self.name+" ::::::")
863 main.log.error( traceback.print_exc())
864 main.log.info(self.name+" ::::::")
865 main.cleanup()
866 main.exit()
867
andrewonlab3f0a4af2014-10-17 12:25:14 -0400868
869 def get_hosts_id(self, host_list):
870 '''
871 Obtain list of hosts
872 Issues command: 'onos> hosts'
873
874 Required:
875 * host_list: List of hosts obtained by Mininet
876 IMPORTANT:
877 This function assumes that you started your
878 topology with the option '--mac'.
879 Furthermore, it assumes that value of VLAN is '-1'
880 Description:
881 Converts mininet hosts (h1, h2, h3...) into
882 ONOS format (00:00:00:00:00:01/-1 , ...)
883 '''
884
885 try:
andrewonlab3f0a4af2014-10-17 12:25:14 -0400886 onos_host_list = []
887
888 for host in host_list:
889 host = host.replace("h", "")
890 host_hex = hex(int(host)).zfill(12)
891 host_hex = str(host_hex).replace('x','0')
892 i = iter(str(host_hex))
893 host_hex = ":".join(a+b for a,b in zip(i,i))
894 host_hex = host_hex + "/-1"
895 onos_host_list.append(host_hex)
896
897 return onos_host_list
898
899 except pexpect.EOF:
900 main.log.error(self.name + ": EOF exception found")
901 main.log.error(self.name + ": " + self.handle.before)
902 main.cleanup()
903 main.exit()
904 except:
905 main.log.info(self.name+" ::::::")
906 main.log.error( traceback.print_exc())
907 main.log.info(self.name+" ::::::")
908 main.cleanup()
909 main.exit()
andrewonlab3e15ead2014-10-15 14:21:34 -0400910
andrewonlabe6745342014-10-17 14:29:13 -0400911 def add_host_intent(self, host_id_one, host_id_two):
912 '''
913 Required:
914 * host_id_one: ONOS host id for host1
915 * host_id_two: ONOS host id for host2
916 Description:
917 Adds a host-to-host intent (bidrectional) by
918 specifying the two hosts.
919 '''
920 try:
921 self.handle.sendline("")
922 self.handle.expect("onos>")
923
924 self.handle.sendline("add-host-intent "+
925 str(host_id_one) + " " + str(host_id_two))
926 self.handle.expect("onos>")
927
andrewonlabe6745342014-10-17 14:29:13 -0400928 handle = self.handle.before
Shreya Shah4f25fdf2014-10-29 19:55:35 -0400929 print "handle =", handle
andrewonlabe6745342014-10-17 14:29:13 -0400930
931 main.log.info("Intent installed between "+
932 str(host_id_one) + " and " + str(host_id_two))
933
934 return handle
935
936 except pexpect.EOF:
937 main.log.error(self.name + ": EOF exception found")
938 main.log.error(self.name + ": " + self.handle.before)
939 main.cleanup()
940 main.exit()
941 except:
942 main.log.info(self.name+" ::::::")
943 main.log.error( traceback.print_exc())
944 main.log.info(self.name+" ::::::")
945 main.cleanup()
946 main.exit()
947
andrewonlab7b31d232014-10-24 13:31:47 -0400948 def add_optical_intent(self, ingress_device, egress_device):
949 '''
950 Required:
951 * ingress_device: device id of ingress device
952 * egress_device: device id of egress device
953 Optional:
954 TODO: Still needs to be implemented via dev side
955 '''
956 try:
957 self.handle.sendline("add-optical-intent "+
958 str(ingress_device) + " " + str(egress_device))
959 self.handle.expect("add-optical-intent")
960 i = self.handle.expect([
961 "Error",
962 "onos>"])
963
964 handle = self.handle.before
965
966 #If error, return error message
967 if i == 0:
968 return handle
969 else:
970 return main.TRUE
971
972 except pexpect.EOF:
973 main.log.error(self.name + ": EOF exception found")
974 main.log.error(self.name + ": " + self.handle.before)
975 main.cleanup()
976 main.exit()
977 except:
978 main.log.info(self.name+" ::::::")
979 main.log.error( traceback.print_exc())
980 main.log.info(self.name+" ::::::")
981 main.cleanup()
982 main.exit()
983
andrewonlab4dbb4d82014-10-17 18:22:31 -0400984 def add_point_intent(self, ingress_device, port_ingress,
andrewonlab289e4b72014-10-21 21:24:18 -0400985 egress_device, port_egress, ethType="", ethSrc="",
andrewonlabfa4ff502014-11-11 16:41:30 -0500986 ethDst="", bandwidth="", lambda_alloc=False,
987 ipProto="", ipSrc="", ipDst="", tcpSrc="", tcpDst=""):
andrewonlab4dbb4d82014-10-17 18:22:31 -0400988 '''
989 Required:
990 * ingress_device: device id of ingress device
991 * egress_device: device id of egress device
andrewonlab289e4b72014-10-21 21:24:18 -0400992 Optional:
993 * ethType: specify ethType
994 * ethSrc: specify ethSrc (i.e. src mac addr)
995 * ethDst: specify ethDst (i.e. dst mac addr)
andrewonlab0dbb6ec2014-11-06 13:46:55 -0500996 * bandwidth: specify bandwidth capacity of link
andrewonlab40ccd8b2014-11-06 16:23:34 -0500997 * lambda_alloc: if True, intent will allocate lambda
998 for the specified intent
andrewonlabf77e0cb2014-11-11 17:17:59 -0500999 * ipProto: specify ip protocol
1000 * ipSrc: specify ip source address
1001 * ipDst: specify ip destination address
1002 * tcpSrc: specify tcp source port
1003 * tcpDst: specify tcp destination port
andrewonlab4dbb4d82014-10-17 18:22:31 -04001004 Description:
1005 Adds a point-to-point intent (uni-directional) by
andrewonlab289e4b72014-10-21 21:24:18 -04001006 specifying device id's and optional fields
1007
andrewonlab4dbb4d82014-10-17 18:22:31 -04001008 NOTE: This function may change depending on the
1009 options developers provide for point-to-point
1010 intent via cli
1011 '''
1012 try:
andrewonlab289e4b72014-10-21 21:24:18 -04001013 cmd = ""
1014
1015 #If there are no optional arguments
andrewonlab0dbb6ec2014-11-06 13:46:55 -05001016 if not ethType and not ethSrc and not ethDst\
andrewonlabfa4ff502014-11-11 16:41:30 -05001017 and not bandwidth and not lambda_alloc \
1018 and not ipProto and not ipSrc and not ipDst \
1019 and not tcpSrc and not tcpDst:
andrewonlab289e4b72014-10-21 21:24:18 -04001020 cmd = "add-point-intent "+\
1021 str(ingress_device) + "/" + str(port_ingress) + " " +\
1022 str(egress_device) + "/" + str(port_egress)
1023
1024 else:
andrewonlab9a130be2014-10-22 12:44:56 -04001025 cmd = "add-point-intent "
1026
andrewonlab0c0a6772014-10-22 12:31:18 -04001027 if ethType:
andrewonlab289e4b72014-10-21 21:24:18 -04001028 cmd += " --ethType " + str(ethType)
1029 if ethSrc:
1030 cmd += " --ethSrc " + str(ethSrc)
1031 if ethDst:
1032 cmd += " --ethDst " + str(ethDst)
andrewonlab0dbb6ec2014-11-06 13:46:55 -05001033 if bandwidth:
1034 cmd += " --bandwidth " + str(bandwidth)
1035 if lambda_alloc:
andrewonlabfa4ff502014-11-11 16:41:30 -05001036 cmd += " --lambda "
1037 if ipProto:
1038 cmd += " --ipProto " + str(ipProto)
1039 if ipSrc:
1040 cmd += " --ipSrc " + str(ipSrc)
1041 if ipDst:
1042 cmd += " --ipDst " + str(ipDst)
1043 if tcpSrc:
1044 cmd += " --tcpSrc " + str(tcpSrc)
1045 if tcpDst:
1046 cmd += " --tcpDst " + str(tcpDst)
andrewonlab289e4b72014-10-21 21:24:18 -04001047
andrewonlab0dbb6ec2014-11-06 13:46:55 -05001048 cmd += " "+str(ingress_device) +\
1049 "/" + str(port_ingress) + " " +\
1050 str(egress_device) + "/" + str(port_egress)
andrewonlab4dbb4d82014-10-17 18:22:31 -04001051
andrewonlab289e4b72014-10-21 21:24:18 -04001052 self.handle.sendline(cmd)
andrewonlab4dbb4d82014-10-17 18:22:31 -04001053 i = self.handle.expect([
1054 "Error",
1055 "onos>"])
andrewonlab289e4b72014-10-21 21:24:18 -04001056
Shreya Shah0f01c812014-10-26 20:15:28 -04001057 self.handle.sendline("intents")
andrewonlab4dbb4d82014-10-17 18:22:31 -04001058 self.handle.expect("onos>")
Shreya Shah0f01c812014-10-26 20:15:28 -04001059 Intenthandle = self.handle.before
andrewonlab4dbb4d82014-10-17 18:22:31 -04001060
1061 if i == 0:
1062 main.log.error("Error in adding point-to-point intent")
1063 return handle
1064 else:
1065 return main.TRUE
andrewonlab289e4b72014-10-21 21:24:18 -04001066
andrewonlab4dbb4d82014-10-17 18:22:31 -04001067 except pexpect.EOF:
1068 main.log.error(self.name + ": EOF exception found")
1069 main.log.error(self.name + ": " + self.handle.before)
1070 main.cleanup()
1071 main.exit()
1072 except:
1073 main.log.info(self.name+" ::::::")
1074 main.log.error( traceback.print_exc())
1075 main.log.info(self.name+" ::::::")
1076 main.cleanup()
1077 main.exit()
1078
andrewonlab9a50dfe2014-10-17 17:22:31 -04001079 def remove_intent(self, intent_id):
1080 '''
1081 Remove intent for specified intent id
1082 '''
1083 try:
1084 self.handle.sendline("")
1085 self.handle.expect("onos>")
1086
1087 self.handle.sendline("remove-intent "+str(intent_id))
1088 i = self.handle.expect([
1089 "Error",
1090 "onos>"])
1091
1092 handle = self.handle.before
1093
1094 if i == 0:
1095 main.log.error("Error in removing intent")
1096 return handle
1097 else:
1098 return handle
1099
1100 except pexpect.EOF:
1101 main.log.error(self.name + ": EOF exception found")
1102 main.log.error(self.name + ": " + self.handle.before)
1103 main.cleanup()
1104 main.exit()
1105 except:
1106 main.log.info(self.name+" ::::::")
1107 main.log.error( traceback.print_exc())
1108 main.log.info(self.name+" ::::::")
1109 main.cleanup()
1110 main.exit()
1111
pingping-lin8b306ac2014-11-17 18:13:51 -08001112 def routes(self, json_format=False):
1113 '''
1114 Optional:
1115 * json_format: enable output formatting in json
1116 Description:
1117 Obtain all routes in the system
1118 '''
1119 try:
1120 if json_format:
1121 self.handle.sendline("routes -j")
1122 self.handle.expect("routes -j")
1123 self.handle.expect("onos>")
1124 handle_tmp = self.handle.before
1125
1126 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
1127 handle = ansi_escape.sub('', handle_tmp)
1128
1129 else:
1130 self.handle.sendline("")
1131 self.handle.expect("onos>")
1132
1133 self.handle.sendline("routes")
1134 self.handle.expect("onos>")
1135 handle = self.handle.before
1136
1137 return handle
1138
1139 except pexpect.EOF:
1140 main.log.error(self.name + ": EOF exception found")
1141 main.log.error(self.name + ": " + self.handle.before)
1142 main.cleanup()
1143 main.exit()
1144 except:
1145 main.log.info(self.name + " ::::::")
1146 main.log.error(traceback.print_exc())
1147 main.log.info(self.name + " ::::::")
1148 main.cleanup()
1149 main.exit()
1150
andrewonlab377693f2014-10-21 16:00:30 -04001151 def intents(self, json_format = False):
andrewonlabe6745342014-10-17 14:29:13 -04001152 '''
andrewonlab377693f2014-10-21 16:00:30 -04001153 Optional:
1154 * json_format: enable output formatting in json
andrewonlabe6745342014-10-17 14:29:13 -04001155 Description:
1156 Obtain intents currently installed
1157 '''
1158 try:
andrewonlab377693f2014-10-21 16:00:30 -04001159 if json_format:
1160 self.handle.sendline("intents -j")
1161 self.handle.expect("intents -j")
1162 self.handle.expect("onos>")
andrewonlab377693f2014-10-21 16:00:30 -04001163 handle = self.handle.before
andrewonlab0dbb6ec2014-11-06 13:46:55 -05001164
1165 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
1166 handle = ansi_escape.sub('', handle)
andrewonlab377693f2014-10-21 16:00:30 -04001167 else:
1168 self.handle.sendline("")
1169 self.handle.expect("onos>")
andrewonlabe6745342014-10-17 14:29:13 -04001170
andrewonlab377693f2014-10-21 16:00:30 -04001171 self.handle.sendline("intents")
1172 self.handle.expect("onos>")
andrewonlab377693f2014-10-21 16:00:30 -04001173 handle = self.handle.before
andrewonlabe6745342014-10-17 14:29:13 -04001174
1175 return handle
1176
1177 except pexpect.EOF:
1178 main.log.error(self.name + ": EOF exception found")
1179 main.log.error(self.name + ": " + self.handle.before)
1180 main.cleanup()
1181 main.exit()
1182 except:
1183 main.log.info(self.name+" ::::::")
1184 main.log.error( traceback.print_exc())
1185 main.log.info(self.name+" ::::::")
1186 main.cleanup()
1187 main.exit()
1188
Shreya Shah0f01c812014-10-26 20:15:28 -04001189 def flows(self, json_format = False):
1190 '''
1191 Optional:
1192 * json_format: enable output formatting in json
1193 Description:
1194 Obtain flows currently installed
1195 '''
1196 try:
1197 if json_format:
1198 self.handle.sendline("flows -j")
1199 self.handle.expect("flows -j")
1200 self.handle.expect("onos>")
1201 handle = self.handle.before
1202
1203 else:
1204 self.handle.sendline("")
1205 self.handle.expect("onos>")
1206 self.handle.sendline("flows")
1207 self.handle.expect("onos>")
1208 handle = self.handle.before
1209
1210 return handle
1211
1212 except pexpect.EOF:
1213 main.log.error(self.name + ": EOF exception found")
1214 main.log.error(self.name + ": " + self.handle.before)
1215 main.cleanup()
1216 main.exit()
1217 except:
1218 main.log.info(self.name+" ::::::")
1219 main.log.error( traceback.print_exc())
1220 main.log.info(self.name+" ::::::")
1221 main.cleanup()
1222 main.exit()
1223
andrewonlab0dbb6ec2014-11-06 13:46:55 -05001224 def intents_events_metrics(self, json_format=True):
1225 '''
1226 Description:Returns topology metrics
1227 Optional:
1228 * json_format: enable json formatting of output
1229 '''
1230 try:
1231 if json_format:
1232 self.handle.sendline("intents-events-metrics -j")
1233 self.handle.expect("intents-events-metrics -j")
1234 self.handle.expect("onos>")
1235
1236 handle = self.handle.before
1237
1238 #Some color thing that we want to escape
1239 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
1240 handle = ansi_escape.sub('', handle)
1241
1242 else:
1243 self.handle.sendline("intents-events-metrics")
1244 self.handle.expect("intents-events-metrics")
1245 self.handle.expect("onos>")
1246
1247 handle = self.handle.before
Shreya Shah0f01c812014-10-26 20:15:28 -04001248
andrewonlab0dbb6ec2014-11-06 13:46:55 -05001249 return handle
1250
1251 except pexpect.EOF:
1252 main.log.error(self.name + ": EOF exception found")
1253 main.log.error(self.name + ": " + self.handle.before)
1254 main.cleanup()
1255 main.exit()
1256 except:
1257 main.log.info(self.name+" ::::::")
1258 main.log.error( traceback.print_exc())
1259 main.log.info(self.name+" ::::::")
1260 main.cleanup()
1261 main.exit()
Shreya Shah0f01c812014-10-26 20:15:28 -04001262
andrewonlab867212a2014-10-22 20:13:38 -04001263 def topology_events_metrics(self, json_format=True):
1264 '''
1265 Description:Returns topology metrics
1266 Optional:
1267 * json_format: enable json formatting of output
1268 '''
1269 try:
1270 if json_format:
1271 self.handle.sendline("topology-events-metrics -j")
1272 self.handle.expect("topology-events-metrics -j")
1273 self.handle.expect("onos>")
1274
1275 handle = self.handle.before
1276
1277 #Some color thing that we want to escape
1278 ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m')
1279 handle = ansi_escape.sub('', handle)
1280
1281 else:
1282 self.handle.sendline("topology-events-metrics")
1283 self.handle.expect("topology-events-metrics")
1284 self.handle.expect("onos>")
1285
1286 handle = self.handle.before
1287
1288 return handle
1289
1290 except pexpect.EOF:
1291 main.log.error(self.name + ": EOF exception found")
1292 main.log.error(self.name + ": " + self.handle.before)
1293 main.cleanup()
1294 main.exit()
1295 except:
1296 main.log.info(self.name+" ::::::")
1297 main.log.error( traceback.print_exc())
1298 main.log.info(self.name+" ::::::")
1299 main.cleanup()
1300 main.exit()
1301
andrewonlab3e15ead2014-10-15 14:21:34 -04001302 #Wrapper functions ****************
andrewonlab7e4d2d32014-10-15 13:23:21 -04001303 #Wrapper functions use existing driver
1304 #functions and extends their use case.
1305 #For example, we may use the output of
1306 #a normal driver function, and parse it
1307 #using a wrapper function
andrewonlabc2d05aa2014-10-13 16:51:10 -04001308
andrewonlab9a50dfe2014-10-17 17:22:31 -04001309 def get_all_intents_id(self):
1310 '''
1311 Description:
1312 Obtain all intent id's in a list
1313 '''
1314 try:
1315 #Obtain output of intents function
1316 intents_str = self.intents()
1317 all_intent_list = []
1318 intent_id_list = []
1319
1320 #Parse the intents output for ID's
1321 intents_list = [s.strip() for s in intents_str.splitlines()]
1322 for intents in intents_list:
1323 if "onos>" in intents:
1324 continue
1325 elif "intents" in intents:
1326 continue
1327 else:
1328 line_list = intents.split(" ")
1329 all_intent_list.append(line_list[0])
1330
1331 all_intent_list = all_intent_list[1:-2]
1332
1333 for intents in all_intent_list:
1334 if not intents:
1335 continue
1336 else:
1337 intent_id_list.append(intents)
1338
1339 return intent_id_list
1340
1341 except pexpect.EOF:
1342 main.log.error(self.name + ": EOF exception found")
1343 main.log.error(self.name + ": " + self.handle.before)
1344 main.cleanup()
1345 main.exit()
1346 except:
1347 main.log.info(self.name+" ::::::")
1348 main.log.error( traceback.print_exc())
1349 main.log.info(self.name+" ::::::")
1350 main.cleanup()
1351 main.exit()
1352
andrewonlab7e4d2d32014-10-15 13:23:21 -04001353 def get_all_devices_id(self):
1354 '''
1355 Use 'devices' function to obtain list of all devices
1356 and parse the result to obtain a list of all device
1357 id's. Returns this list. Returns empty list if no
1358 devices exist
1359 List is ordered sequentially
andrewonlab3e15ead2014-10-15 14:21:34 -04001360
1361 This function may be useful if you are not sure of the
1362 device id, and wish to execute other commands using
1363 the ids. By obtaining the list of device ids on the fly,
1364 you can iterate through the list to get mastership, etc.
andrewonlab7e4d2d32014-10-15 13:23:21 -04001365 '''
1366 try:
1367 #Call devices and store result string
andrewonlab9a50dfe2014-10-17 17:22:31 -04001368 devices_str = self.devices(json_format=False)
andrewonlab7e4d2d32014-10-15 13:23:21 -04001369 id_list = []
1370
1371 if not devices_str:
1372 main.log.info("There are no devices to get id from")
1373 return id_list
1374
1375 #Split the string into list by comma
1376 device_list = devices_str.split(",")
1377 #Get temporary list of all arguments with string 'id='
1378 temp_list = [dev for dev in device_list if "id=" in dev]
1379 #Split list further into arguments before and after string
1380 # 'id='. Get the latter portion (the actual device id) and
1381 # append to id_list
1382 for arg in temp_list:
1383 id_list.append(arg.split("id=")[1])
andrewonlab7e4d2d32014-10-15 13:23:21 -04001384 return id_list
1385
1386 except pexpect.EOF:
1387 main.log.error(self.name + ": EOF exception found")
1388 main.log.error(self.name + ": " + self.handle.before)
1389 main.cleanup()
1390 main.exit()
1391 except:
1392 main.log.info(self.name+" ::::::")
1393 main.log.error( traceback.print_exc())
1394 main.log.info(self.name+" ::::::")
1395 main.cleanup()
1396 main.exit()
1397
andrewonlab7c211572014-10-15 16:45:20 -04001398 def get_all_nodes_id(self):
1399 '''
1400 Uses 'nodes' function to obtain list of all nodes
1401 and parse the result of nodes to obtain just the
1402 node id's.
1403 Returns:
1404 list of node id's
1405 '''
1406 try:
1407 nodes_str = self.nodes()
1408 id_list = []
1409
1410 if not nodes_str:
1411 main.log.info("There are no nodes to get id from")
1412 return id_list
1413
1414 #Sample nodes_str output
1415 #id=local, address=127.0.0.1:9876, state=ACTIVE *
1416
1417 #Split the string into list by comma
1418 nodes_list = nodes_str.split(",")
1419 temp_list = [node for node in nodes_list if "id=" in node]
1420 for arg in temp_list:
1421 id_list.append(arg.split("id=")[1])
1422
1423 return id_list
1424
1425 except pexpect.EOF:
1426 main.log.error(self.name + ": EOF exception found")
1427 main.log.error(self.name + ": " + self.handle.before)
1428 main.cleanup()
1429 main.exit()
1430 except:
1431 main.log.info(self.name+" ::::::")
1432 main.log.error( traceback.print_exc())
1433 main.log.info(self.name+" ::::::")
1434 main.cleanup()
1435 main.exit()
andrewonlab7e4d2d32014-10-15 13:23:21 -04001436
Jon Halla91c4dc2014-10-22 12:57:04 -04001437 def get_device(self, dpid=None):
1438 '''
1439 Return the first device from the devices api whose 'id' contains 'dpid'
1440 Return None if there is no match
1441 '''
1442 import json
1443 try:
1444 if dpid == None:
1445 return None
1446 else:
1447 dpid = dpid.replace(':', '')
1448 raw_devices = self.devices()
1449 devices_json = json.loads(raw_devices)
1450 #search json for the device with dpid then return the device
1451 for device in devices_json:
1452 #print "%s in %s?" % (dpid, device['id'])
1453 if dpid in device['id']:
1454 return device
1455 return None
1456 except pexpect.EOF:
1457 main.log.error(self.name + ": EOF exception found")
1458 main.log.error(self.name + ": " + self.handle.before)
1459 main.cleanup()
1460 main.exit()
1461 except:
1462 main.log.info(self.name+" ::::::")
1463 main.log.error( traceback.print_exc())
1464 main.log.info(self.name+" ::::::")
1465 main.cleanup()
1466 main.exit()
1467
Jon Hall42db6dc2014-10-24 19:03:48 -04001468 def check_status(self, ip, numoswitch, numolink, log_level="info"):
1469 '''
1470 Checks the number of swithes & links that ONOS sees against the
1471 supplied values. By default this will report to main.log, but the
1472 log level can be specifid.
1473
1474 Params: ip = ip used for the onos cli
1475 numoswitch = expected number of switches
1476 numlink = expected number of links
1477 log_level = level to log to. Currently accepts 'info', 'warn' and 'report'
1478
1479
1480 log_level can
1481
1482 Returns: main.TRUE if the number of switchs and links are correct,
1483 main.FALSE if the numer of switches and links is incorrect,
1484 and main.ERROR otherwise
1485 '''
1486
1487 try:
1488 topology = self.get_topology(ip)
1489 if topology == {}:
1490 return main.ERROR
1491 output = ""
1492 #Is the number of switches is what we expected
1493 devices = topology.get('devices',False)
1494 links = topology.get('links',False)
1495 if devices == False or links == False:
1496 return main.ERROR
1497 switch_check = ( int(devices) == int(numoswitch) )
1498 #Is the number of links is what we expected
1499 link_check = ( int(links) == int(numolink) )
1500 if (switch_check and link_check):
1501 #We expected the correct numbers
1502 output = output + "The number of links and switches match "\
1503 + "what was expected"
1504 result = main.TRUE
1505 else:
1506 output = output + \
1507 "The number of links and switches does not match what was expected"
1508 result = main.FALSE
1509 output = output + "\n ONOS sees %i devices (%i expected) and %i links (%i expected)"\
1510 % ( int(devices), int(numoswitch), int(links), int(numolink) )
1511 if log_level == "report":
1512 main.log.report(output)
1513 elif log_level == "warn":
1514 main.log.warn(output)
1515 else:
1516 main.log.info(output)
1517 return result
1518 except pexpect.EOF:
1519 main.log.error(self.name + ": EOF exception found")
1520 main.log.error(self.name + ": " + self.handle.before)
1521 main.cleanup()
1522 main.exit()
1523 except:
1524 main.log.info(self.name+" ::::::")
1525 main.log.error( traceback.print_exc())
1526 main.log.info(self.name+" ::::::")
1527 main.cleanup()
1528 main.exit()
Jon Hall1c9e8732014-10-27 19:29:27 -04001529
1530 def device_role(self, device_id, onos_node, role="master"):
1531 '''
1532 Calls the device-role cli command.
1533 device_id must be the id of a device as seen in the onos devices command
1534 onos_node is the ip of one of the onos nodes in the cluster
1535 role must be either master, standby, or none
1536
Jon Hall983a1702014-10-28 18:44:22 -04001537 Returns main.TRUE or main.FALSE based argument varification.
1538 When device-role supports errors this should be extended to
Jon Hall1c9e8732014-10-27 19:29:27 -04001539 support that output
1540 '''
Jon Hall1c9e8732014-10-27 19:29:27 -04001541 try:
Jon Hall983a1702014-10-28 18:44:22 -04001542 #print "beginning device_role... \n\tdevice_id:" + device_id
1543 #print "\tonos_node: " + onos_node
1544 #print "\trole: "+ role
Jon Hall1c9e8732014-10-27 19:29:27 -04001545 if role.lower() == "master" or \
1546 role.lower() == "standby" or \
1547 role.lower() == "none":
1548 self.handle.sendline("")
1549 self.handle.expect("onos>")
Jon Hall983a1702014-10-28 18:44:22 -04001550 self.handle.sendline("device-role " +
1551 str(device_id) + " " +
1552 str(onos_node) + " " +
1553 str(role))
1554 i= self.handle.expect(["Error","onos>"])
1555 if i == 0:
1556 output = str(self.handle.before)
1557 self.handle.expect("onos>")
1558 output = output + str(self.handle.before)
1559 main.log.error(self.name + ": " +
1560 output + '\033[0m')#end color output to escape any colours from the cli
1561 return main.ERROR
1562 self.handle.sendline("")
Jon Hall1c9e8732014-10-27 19:29:27 -04001563 self.handle.expect("onos>")
1564 return main.TRUE
1565 else:
1566 return main.FALSE
1567
1568 except pexpect.EOF:
1569 main.log.error(self.name + ": EOF exception found")
1570 main.log.error(self.name + ": " + self.handle.before)
1571 main.cleanup()
1572 main.exit()
1573 except:
1574 main.log.info(self.name+" ::::::")
1575 main.log.error( traceback.print_exc())
1576 main.log.info(self.name+" ::::::")
1577 main.cleanup()
1578 main.exit()
1579
1580
andrewonlab7e4d2d32014-10-15 13:23:21 -04001581 #***********************************