| #!/usr/bin/env python |
| |
| """ |
| This driver enters the onos> prompt to issue commands. |
| |
| Please follow the coding style demonstrated by existing |
| functions and document properly. |
| |
| If you are a contributor to the driver, please |
| list your email here for future contact: |
| |
| jhall@onlab.us |
| andrew@onlab.us |
| shreya@onlab.us |
| |
| OCT 13 2014 |
| |
| """ |
| import sys |
| import pexpect |
| import re |
| import traceback |
| # import os.path |
| sys.path.append( "../" ) |
| from drivers.common.clidriver import CLI |
| |
| |
| class OnosCliDriver( CLI ): |
| |
| def __init__( self ): |
| """ |
| Initialize client |
| """ |
| super( CLI, self ).__init__() |
| |
| def connect( self, **connectargs ): |
| """ |
| Creates ssh handle for ONOS cli. |
| """ |
| try: |
| for key in connectargs: |
| vars( self )[ key ] = connectargs[ key ] |
| self.home = "~/ONOS" |
| for key in self.options: |
| if key == "home": |
| self.home = self.options[ 'home' ] |
| break |
| |
| self.name = self.options[ 'name' ] |
| self.handle = super( OnosCliDriver, self ).connect( |
| user_name=self.user_name, |
| ip_address=self.ip_address, |
| port=self.port, |
| pwd=self.pwd, |
| home=self.home ) |
| |
| self.handle.sendline( "cd " + self.home ) |
| self.handle.expect( "\$" ) |
| if self.handle: |
| return self.handle |
| else: |
| main.log.info( "NO ONOS HANDLE" ) |
| return main.FALSE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + ":::::::::::::::::::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( ":::::::::::::::::::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def disconnect( self ): |
| """ |
| Called when Test is complete to disconnect the ONOS handle. |
| """ |
| response = '' |
| try: |
| self.handle.sendline( "" ) |
| i = self.handle.expect( [ "onos>", "\$" ] ) |
| if i == 0: |
| self.handle.sendline( "system:shutdown" ) |
| self.handle.expect( "Confirm" ) |
| self.handle.sendline( "yes" ) |
| self.handle.expect( "\$" ) |
| self.handle.sendline( "" ) |
| self.handle.expect( "\$" ) |
| self.handle.sendline( "exit" ) |
| self.handle.expect( "closed" ) |
| |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| except: |
| main.log.error( self.name + ": Connection failed to the host" ) |
| response = main.FALSE |
| return response |
| |
| def logout( self ): |
| """ |
| Sends 'logout' command to ONOS cli |
| """ |
| try: |
| self.handle.sendline( "" ) |
| i = self.handle.expect( [ |
| "onos>", |
| "\$" ], timeout=10 ) |
| if i == 0: |
| self.handle.sendline( "logout" ) |
| self.handle.expect( "\$" ) |
| elif i == 1: |
| return main.TRUE |
| |
| except pexpect.EOF: |
| main.log.error( self.name + ": eof exception found" ) |
| main.log.error( self.name + ": " + |
| self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def set_cell( self, cellname ): |
| """ |
| Calls 'cell <name>' to set the environment variables on ONOSbench |
| |
| Before issuing any cli commands, set the environment variable first. |
| """ |
| try: |
| if not cellname: |
| main.log.error( "Must define cellname" ) |
| main.cleanup() |
| main.exit() |
| else: |
| self.handle.sendline( "cell " + str( cellname ) ) |
| # Expect the cellname in the ONOS_CELL variable. |
| # Note that this variable name is subject to change |
| # and that this driver will have to change accordingly |
| self.handle.expect( "ONOS_CELL=" + str( cellname ) ) |
| handle_before = self.handle.before |
| handle_after = self.handle.after |
| # Get the rest of the handle |
| self.handle.sendline( "" ) |
| self.handle.expect( "\$" ) |
| handle_more = self.handle.before |
| |
| main.log.info( "Cell call returned: " + handle_before + |
| handle_after + handle_more ) |
| |
| return main.TRUE |
| |
| except pexpect.EOF: |
| main.log.error( self.name + ": eof exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def start_onos_cli( self, ONOS_ip, karafTimeout="" ): |
| """ |
| karafTimeout is an optional arugument. karafTimeout value passed by user would be used to set the |
| current karaf shell idle timeout. Note that when ever this property is modified the shell will exit and |
| the subsequent login would reflect new idle timeout. |
| Below is an example to start a session with 60 seconds idle timeout ( input value is in milliseconds ): |
| |
| tValue = "60000" |
| main.ONOScli1.start_onos_cli( ONOS_ip, karafTimeout=tValue ) |
| |
| Note: karafTimeout is left as str so that this could be read and passed to start_onos_cli from PARAMS file as str. |
| """ |
| try: |
| self.handle.sendline( "" ) |
| x = self.handle.expect( [ |
| "\$", "onos>" ], timeout=10 ) |
| |
| if x == 1: |
| main.log.info( "ONOS cli is already running" ) |
| return main.TRUE |
| |
| # Wait for onos start ( -w ) and enter onos cli |
| self.handle.sendline( "onos -w " + str( ONOS_ip ) ) |
| i = self.handle.expect( [ |
| "onos>", |
| pexpect.TIMEOUT ], timeout=60 ) |
| |
| if i == 0: |
| main.log.info( str( ONOS_ip ) + " CLI Started successfully" ) |
| if karafTimeout: |
| self.handle.sendline( |
| "config:property-set -p org.apache.karaf.shell sshIdleTimeout " + |
| karafTimeout ) |
| self.handle.expect( "\$" ) |
| self.handle.sendline( "onos -w " + str( ONOS_ip ) ) |
| self.handle.expect( "onos>" ) |
| return main.TRUE |
| else: |
| # If failed, send ctrl+c to process and try again |
| main.log.info( "Starting CLI failed. Retrying..." ) |
| self.handle.send( "\x03" ) |
| self.handle.sendline( "onos -w " + str( ONOS_ip ) ) |
| i = self.handle.expect( [ "onos>", pexpect.TIMEOUT ], |
| timeout=30 ) |
| if i == 0: |
| main.log.info( str( ONOS_ip ) + " CLI Started " + |
| "successfully after retry attempt" ) |
| if karafTimeout: |
| self.handle.sendline( |
| "config:property-set -p org.apache.karaf.shell sshIdleTimeout " + |
| karafTimeout ) |
| self.handle.expect( "\$" ) |
| self.handle.sendline( "onos -w " + str( ONOS_ip ) ) |
| self.handle.expect( "onos>" ) |
| return main.TRUE |
| else: |
| main.log.error( "Connection to CLI " + |
| str( ONOS_ip ) + " timeout" ) |
| return main.FALSE |
| |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| def sendline(self, cmd_str): |
| ''' |
| ======= |
| def sendline( self, cmd_str ): |
| """ |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| Send a completely user specified string to |
| the onos> prompt. Use this function if you have |
| a very specific command to send. |
| |
| Warning: There are no sanity checking to commands |
| sent using this method. |
| """ |
| try: |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| <<<<<<< HEAD |
| self.handle.sendline("log:log \"Sending CLI command: '" |
| + cmd_str + "'\"") |
| self.handle.expect("onos>") |
| self.handle.sendline( cmd_str ) |
| self.handle.expect( cmd_str ) |
| self.handle.expect("onos>") |
| |
| handle = self.handle.before |
| |
| self.handle.sendline("") |
| self.handle.expect("onos>") |
| |
| #handle += self.handle.before |
| #handle += self.handle.after |
| |
| main.log.info("Command '" + str( cmd_str ) + "' sent to " |
| + self.name + ".") |
| ansi_escape = re.compile(r'\x1b[^m]*m') |
| handle = ansi_escape.sub('', handle) |
| ======= |
| self.handle.sendline( cmd_str ) |
| self.handle.expect( "onos>" ) |
| |
| handle = self.handle.before |
| |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| handle += self.handle.before |
| handle += self.handle.after |
| |
| main.log.info( "Command sent." ) |
| ansi_escape = re.compile( r'\x1b[^m]*m' ) |
| handle = ansi_escape.sub( '', handle ) |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| |
| return handle |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| # IMPORTANT NOTE: |
| # For all cli commands, naming convention should match |
| # the cli command replacing ':' with '_'. |
| # Ex ) onos:topology > onos_topology |
| # onos:links > onos_links |
| # feature:list > feature_list |
| |
| <<<<<<< HEAD |
| def add_node(self, node_id, ONOS_ip, tcp_port=""): |
| ''' |
| ======= |
| def add_node( self, node_id, ONOS_ip, tcp_port="" ): |
| """ |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| Adds a new cluster node by ID and address information. |
| Required: |
| * node_id |
| * ONOS_ip |
| Optional: |
| * tcp_port |
| """ |
| try: |
| <<<<<<< HEAD |
| cmd_str = "add-node " + str(node_id) + " " +\ |
| str(ONOS_ip) + " " + str(tcp_port) |
| handle = self.sendline( cmd_str ) |
| if re.search("Error", handle): |
| main.log.error("Error in adding node") |
| main.log.error(handle) |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "add-node " + |
| str( node_id ) + " " + |
| str( ONOS_ip ) + " " + |
| str( tcp_port ) ) |
| |
| i = self.handle.expect( [ |
| "Error", |
| "onos>" ] ) |
| |
| # Clear handle to get previous output |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| handle = self.handle.before |
| |
| if i == 0: |
| main.log.error( "Error in adding node" ) |
| main.log.error( handle ) |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return main.FALSE |
| else: |
| main.log.info( "Node " + str( ONOS_ip ) + " added" ) |
| return main.TRUE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def remove_node( self, node_id ): |
| """ |
| Removes a cluster by ID |
| Issues command: 'remove-node [<node-id>]' |
| Required: |
| * node_id |
| """ |
| try: |
| <<<<<<< HEAD |
| |
| cmd_str = "remove-node " + str(node_id) |
| self.sendline( cmd_str ) |
| # TODO: add error checking. Does ONOS give any errors? |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "remove-node " + str( node_id ) ) |
| self.handle.expect( "onos>" ) |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| |
| return main.TRUE |
| |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def nodes( self ): |
| """ |
| List the nodes currently visible |
| Issues command: 'nodes' |
| Returns: entire handle of list of nodes |
| """ |
| try: |
| <<<<<<< HEAD |
| cmd_str = "nodes" |
| handle = self.sendline( cmd_str ) |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "nodes" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| handle = self.handle.before |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return handle |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def topology( self ): |
| """ |
| Shows the current state of the topology |
| by issusing command: 'onos> onos:topology' |
| """ |
| try: |
| <<<<<<< HEAD |
| # either onos:topology or 'topology' will work in CLI |
| cmd_str = "onos:topology" |
| handle = self.sendline( cmd_str ) |
| main.log.info( "onos:topology returned: " + str( handle ) ) |
| return handle |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| # either onos:topology or 'topology' will work in CLI |
| self.handle.sendline( "onos:topology" ) |
| self.handle.expect( "onos>" ) |
| |
| handle = self.handle.before |
| |
| main.log.info( "onos:topology returned: " + |
| str( handle ) ) |
| |
| return handle |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| def feature_install(self, feature_str): |
| ''' |
| ======= |
| def feature_install( self, feature_str ): |
| """ |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| Installs a specified feature |
| by issuing command: 'onos> feature:install <feature_str>' |
| """ |
| try: |
| <<<<<<< HEAD |
| cmd_str = "feature:install " + str( feature_str ) |
| self.sendline( cmd_str ) |
| # TODO: Check for possible error responses from karaf |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "feature:install " + str( feature_str ) ) |
| self.handle.expect( "onos>" ) |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return main.TRUE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.log.report( "Failed to install feature" ) |
| main.log.report( "Exiting test" ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.report( "Failed to install feature" ) |
| main.log.report( "Exiting test" ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| def feature_uninstall(self, feature_str): |
| ''' |
| ======= |
| def feature_uninstall( self, feature_str ): |
| """ |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| Uninstalls a specified feature |
| by issuing command: 'onos> feature:uninstall <feature_str>' |
| """ |
| try: |
| <<<<<<< HEAD |
| cmd_str = "feature:uninstall " + str( feature_str ) |
| self.sendline( cmd_str ) |
| # TODO: Check for possible error responses from karaf |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "feature:uninstall " + str( feature_str ) ) |
| self.handle.expect( "onos>" ) |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return main.TRUE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def devices( self, json_format=True ): |
| """ |
| Lists all infrastructure devices or switches |
| Optional argument: |
| * json_format - boolean indicating if you want output in json |
| """ |
| try: |
| <<<<<<< HEAD |
| if json_format: |
| cmd_str = "devices -j" |
| handle = self.sendline( cmd_str ) |
| ''' |
| handle variable here contains some ANSI escape color code |
| sequences at the end which are invisible in the print command |
| output. To make that escape sequence visible, use repr() |
| function. The repr(handle) output when printed shows the |
| ANSI escape sequences. In json.loads(somestring), this |
| somestring variable is actually repr(somestring) and |
| json.loads would fail with the escape sequence. So we take off |
| that escape sequence using: |
| |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle1 = ansi_escape.sub('', handle) |
| ''' |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle1 = ansi_escape.sub('', handle) |
| return handle1 |
| else: |
| cmd_str = "devices" |
| handle = self.sendline( cmd_str ) |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| if json_format: |
| self.handle.sendline( "devices -j" ) |
| self.handle.expect( "devices -j" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| """ |
| handle variable here contains some ANSI escape color code sequences at the end which are invisible in the print command output |
| To make that escape sequence visible, use repr() function. The repr( handle ) output when printed shows the ANSI escape sequences. |
| In json.loads( somestring ), this somestring variable is actually repr( somestring ) and json.loads would fail with the escape sequence. |
| So we take off that escape sequence using |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle1 = ansi_escape.sub( '', handle ) |
| """ |
| # print "repr(handle) =", repr( handle ) |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle1 = ansi_escape.sub( '', handle ) |
| # print "repr(handle1) = ", repr( handle1 ) |
| return handle1 |
| else: |
| self.handle.sendline( "devices" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| # print "handle =",handle |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return handle |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| def balance_masters(self): |
| ''' |
| ======= |
| def balance_masters( self ): |
| """ |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| This balances the devices across all controllers |
| by issuing command: 'onos> onos:balance-masters' |
| If required this could be extended to return devices balanced output. |
| """ |
| try: |
| <<<<<<< HEAD |
| cmd_str = "onos:balance-masters" |
| self.sendline( cmd_str ) |
| # TODO: Check for error responses from ONOS |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "onos:balance-masters" ) |
| self.handle.expect( "onos>" ) |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return main.TRUE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def links( self, json_format=True ): |
| """ |
| Lists all core links |
| Optional argument: |
| * json_format - boolean indicating if you want output in json |
| """ |
| try: |
| <<<<<<< HEAD |
| if json_format: |
| cmd_str = "links -j" |
| handle = self.sendline( cmd_str ) |
| ''' |
| handle variable here contains some ANSI escape color code |
| sequences at the end which are invisible in the print command |
| output. To make that escape sequence visible, use repr() |
| function. The repr(handle) output when printed shows the ANSI |
| escape sequences. In json.loads(somestring), this somestring |
| variable is actually repr(somestring) and json.loads would |
| fail with the escape sequence. So we take off that escape |
| sequence using: |
| |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle1 = ansi_escape.sub('', handle) |
| ''' |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle1 = ansi_escape.sub('', handle) |
| return handle1 |
| else: |
| cmd_str = "links" |
| handle = self.sendline( cmd_str ) |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| if json_format: |
| self.handle.sendline( "links -j" ) |
| self.handle.expect( "links -j" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| """ |
| handle variable here contains some ANSI escape color code sequences at the end which are invisible in the print command output |
| To make that escape sequence visible, use repr() function. The repr( handle ) output when printed shows the ANSI escape sequences. |
| In json.loads( somestring ), this somestring variable is actually repr( somestring ) and json.loads would fail with the escape sequence. |
| So we take off that escape sequence using |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle1 = ansi_escape.sub( '', handle ) |
| """ |
| # print "repr(handle) =", repr( handle ) |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle1 = ansi_escape.sub( '', handle ) |
| # print "repr(handle1) = ", repr( handle1 ) |
| return handle1 |
| else: |
| self.handle.sendline( "links" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| # print "handle =",handle |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return handle |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| def ports(self, json_format=True): |
| ''' |
| ======= |
| def ports( self, json_format=True ): |
| """ |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| Lists all ports |
| Optional argument: |
| * json_format - boolean indicating if you want output in json |
| """ |
| try: |
| <<<<<<< HEAD |
| if json_format: |
| cmd_str = "ports -j" |
| handle = self.sendline( cmd_str ) |
| ''' |
| handle variable here contains some ANSI escape color code |
| sequences at the end which are invisible in the print command |
| output. To make that escape sequence visible, use repr() |
| function. The repr(handle) output when printed shows the ANSI |
| escape sequences. In json.loads(somestring), this somestring |
| variable is actually repr(somestring) and json.loads would |
| fail with the escape sequence. So we take off that escape |
| sequence using the following commads: |
| |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle1 = ansi_escape.sub('', handle) |
| ''' |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle1 = ansi_escape.sub('', handle) |
| return handle1 |
| |
| else: |
| cmd_str = "ports" |
| handle = self.sendline( cmd_str ) |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| if json_format: |
| self.handle.sendline( "ports -j" ) |
| self.handle.expect( "ports -j" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| """ |
| handle variable here contains some ANSI escape color code sequences at the end which are invisible in the print command output |
| To make that escape sequence visible, use repr() function. The repr( handle ) output when printed shows the ANSI escape sequences. |
| In json.loads( somestring ), this somestring variable is actually repr( somestring ) and json.loads would fail with the escape sequence. |
| So we take off that escape sequence using the following commads: |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle1 = ansi_escape.sub( '', handle ) |
| """ |
| # print "repr(handle) =", repr( handle ) |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle1 = ansi_escape.sub( '', handle ) |
| # print "repr(handle1) = ", repr( handle1 ) |
| return handle1 |
| |
| else: |
| self.handle.sendline( "ports" ) |
| self.handle.expect( "onos>" ) |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| # print "handle =",handle |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return handle |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def roles( self, json_format=True ): |
| """ |
| Lists all devices and the controllers with roles assigned to them |
| Optional argument: |
| * json_format - boolean indicating if you want output in json |
| """ |
| try: |
| <<<<<<< HEAD |
| if json_format: |
| cmd_str = "roles -j" |
| handle = self.sendline( cmd_str ) |
| ''' |
| handle variable here contains some ANSI escape color code |
| sequences at the end which are invisible in the print command |
| output. To make that escape sequence visible, use repr() |
| function. The repr(handle) output when printed shows the ANSI |
| escape sequences. In json.loads(somestring), this somestring |
| variable is actually repr(somestring) and json.loads would |
| fail with the escape sequence. |
| |
| So we take off that escape sequence using the following |
| commads: |
| |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle1 = ansi_escape.sub('', handle) |
| ''' |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle1 = ansi_escape.sub('', handle) |
| return handle1 |
| |
| else: |
| cmd_str = "roles" |
| handle = self.sendline( cmd_str ) |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| if json_format: |
| self.handle.sendline( "roles -j" ) |
| self.handle.expect( "roles -j" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| """ |
| handle variable here contains some ANSI escape color code sequences at the |
| end which are invisible in the print command output. To make that escape |
| sequence visible, use repr() function. The repr( handle ) output when printed |
| shows the ANSI escape sequences. In json.loads( somestring ), this somestring |
| variable is actually repr( somestring ) and json.loads would fail with the escape |
| sequence. |
| |
| So we take off that escape sequence using the following commads: |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle1 = ansi_escape.sub( '', handle ) |
| """ |
| # print "repr(handle) =", repr( handle ) |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle1 = ansi_escape.sub( '', handle ) |
| # print "repr(handle1) = ", repr( handle1 ) |
| return handle1 |
| |
| else: |
| self.handle.sendline( "roles" ) |
| self.handle.expect( "onos>" ) |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| # print "handle =",handle |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return handle |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| def get_role(self, device_id): |
| ''' |
| Given the a string containing the json representation of the "roles" |
| cli command and a partial or whole device id, returns a json object |
| containing the roles output for the first device whose id contains |
| "device_id" |
| |
| Returns: |
| A dict of the role assignments for the given device or |
| None if no match |
| ''' |
| ======= |
| def get_role( self, device_id ): |
| """ |
| Given the a string containing the json representation of the "roles" cli command and a |
| partial or whole device id, returns a json object containing the |
| roles output for the first device whose id contains "device_id" |
| |
| Returns: |
| Dict of the role assignments for the given device or |
| None if not match |
| """ |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| try: |
| import json |
| if device_id is None: |
| return None |
| else: |
| raw_roles = self.roles() |
| roles_json = json.loads( raw_roles ) |
| # search json for the device with id then return the device |
| for device in roles_json: |
| # print device |
| if str( device_id ) in device[ 'id' ]: |
| return device |
| return None |
| |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def roles_not_null( self ): |
| """ |
| Iterates through each device and checks if there is a master assigned |
| Returns: main.TRUE if each device has a master |
| main.FALSE any device has no master |
| """ |
| try: |
| import json |
| raw_roles = self.roles() |
| roles_json = json.loads( raw_roles ) |
| # search json for the device with id then return the device |
| for device in roles_json: |
| # print device |
| if device[ 'master' ] == "none": |
| main.log.warn( "Device has no master: " + str( device ) ) |
| return main.FALSE |
| return main.TRUE |
| |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def paths( self, src_id, dst_id ): |
| """ |
| Returns string of paths, and the cost. |
| Issues command: onos:paths <src> <dst> |
| """ |
| try: |
| <<<<<<< HEAD |
| cmd_str = "onos:paths " + str(src_id) + " " + str(dst_id) |
| handle = self.sendline( cmd_str ) |
| if re.search( "Error", handle ): |
| main.log.error("Error in getting paths") |
| return (handle, "Error") |
| else: |
| path = handle.split(";")[0] |
| cost = handle.split(";")[1] |
| return (path, cost) |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "onos:paths " + |
| str( src_id ) + " " + str( dst_id ) ) |
| i = self.handle.expect( [ |
| "Error", |
| "onos>" ] ) |
| |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| handle = self.handle.before |
| |
| if i == 0: |
| main.log.error( "Error in getting paths" ) |
| return ( handle, "Error" ) |
| else: |
| path = handle.split( ";" )[ 0 ] |
| cost = handle.split( ";" )[ 1 ] |
| return ( path, cost ) |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def hosts( self, json_format=True ): |
| """ |
| Lists all discovered hosts |
| Optional argument: |
| * json_format - boolean indicating if you want output in json |
| """ |
| try: |
| <<<<<<< HEAD |
| if json_format: |
| cmd_str = "hosts -j" |
| handle = self.sendline( cmd_str ) |
| ''' |
| handle variable here contains some ANSI escape color code |
| sequences at the end which are invisible in the print command |
| output. To make that escape sequence visible, use repr() |
| function. The repr(handle) output when printed shows the ANSI |
| escape sequences. In json.loads(somestring), this somestring |
| variable is actually repr(somestring) and json.loads would |
| fail with the escape sequence. So we take off that escape |
| sequence using: |
| |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle1 = ansi_escape.sub('', handle) |
| ''' |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle1 = ansi_escape.sub('', handle) |
| return handle1 |
| else: |
| cmd_str = "hosts" |
| handle = self.sendline( cmd_str ) |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| if json_format: |
| self.handle.sendline( "hosts -j" ) |
| self.handle.expect( "hosts -j" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| """ |
| handle variable here contains some ANSI escape color code sequences at the end which are invisible in the print command output |
| To make that escape sequence visible, use repr() function. The repr( handle ) output when printed shows the ANSI escape sequences. |
| In json.loads( somestring ), this somestring variable is actually repr( somestring ) and json.loads would fail with the escape sequence. |
| So we take off that escape sequence using |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle1 = ansi_escape.sub( '', handle ) |
| """ |
| # print "repr(handle) =", repr( handle ) |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle1 = ansi_escape.sub( '', handle ) |
| # print "repr(handle1) = ", repr( handle1 ) |
| return handle1 |
| else: |
| self.handle.sendline( "hosts" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| # print "handle =",handle |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return handle |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def get_host( self, mac ): |
| """ |
| Return the first host from the hosts api whose 'id' contains 'mac' |
| |
| Note: mac must be a colon seperated mac address, but could be a |
| partial mac address |
| |
| Return None if there is no match |
| """ |
| import json |
| try: |
| if mac is None: |
| return None |
| else: |
| mac = mac |
| raw_hosts = self.hosts() |
| hosts_json = json.loads( raw_hosts ) |
| # search json for the host with mac then return the device |
| for host in hosts_json: |
| # print "%s in %s?" % ( mac, host[ 'id' ] ) |
| if mac in host[ 'id' ]: |
| return host |
| return None |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def get_hosts_id( self, host_list ): |
| """ |
| Obtain list of hosts |
| Issues command: 'onos> hosts' |
| |
| Required: |
| * host_list: List of hosts obtained by Mininet |
| IMPORTANT: |
| This function assumes that you started your |
| topology with the option '--mac'. |
| Furthermore, it assumes that value of VLAN is '-1' |
| Description: |
| Converts mininet hosts ( h1, h2, h3... ) into |
| ONOS format ( 00:00:00:00:00:01/-1 , ... ) |
| """ |
| try: |
| onos_host_list = [] |
| |
| for host in host_list: |
| host = host.replace( "h", "" ) |
| host_hex = hex( int( host ) ).zfill( 12 ) |
| host_hex = str( host_hex ).replace( 'x', '0' ) |
| i = iter( str( host_hex ) ) |
| host_hex = ":".join( a + b for a, b in zip( i, i ) ) |
| host_hex = host_hex + "/-1" |
| onos_host_list.append( host_hex ) |
| |
| return onos_host_list |
| |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def add_host_intent( self, host_id_one, host_id_two ): |
| """ |
| Required: |
| * host_id_one: ONOS host id for host1 |
| * host_id_two: ONOS host id for host2 |
| Description: |
| Adds a host-to-host intent ( bidrectional ) by |
| specifying the two hosts. |
| """ |
| try: |
| <<<<<<< HEAD |
| cmd_str = "add-host-intent " + str(host_id_one) +\ |
| " " + str(host_id_two) |
| handle = self.sendline( cmd_str ) |
| main.log.info("Host intent installed between "+ |
| str(host_id_one) + " and " + str(host_id_two)) |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "add-host-intent " + |
| str( host_id_one ) + " " + str( host_id_two ) ) |
| self.handle.expect( "onos>" ) |
| |
| handle = self.handle.before |
| # print "handle =", handle |
| |
| main.log.info( "Host intent installed between " + |
| str( host_id_one ) + " and " + str( host_id_two ) ) |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return handle |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def add_optical_intent( self, ingress_device, egress_device ): |
| """ |
| Required: |
| * ingress_device: device id of ingress device |
| * egress_device: device id of egress device |
| Optional: |
| TODO: Still needs to be implemented via dev side |
| <<<<<<< HEAD |
| ''' |
| try: |
| cmd_str = "add-optical-intent " + str( ingress_device ) +\ |
| " " + str( egress_device ) |
| handle = self.sendline( cmd_str ) |
| #If error, return error message |
| if re.search( "Error", handle ): |
| return handle |
| else: |
| return main.TRUE |
| ======= |
| """ |
| try: |
| self.handle.sendline( "add-optical-intent " + |
| str( ingress_device ) + " " + str( egress_device ) ) |
| self.handle.expect( "add-optical-intent" ) |
| i = self.handle.expect( [ |
| "Error", |
| "onos>" ] ) |
| |
| handle = self.handle.before |
| |
| # If error, return error message |
| if i == 0: |
| return handle |
| else: |
| return main.TRUE |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| def add_point_intent(self, ingress_device, egress_device, |
| port_ingress="", port_egress="", ethType="", ethSrc="", |
| ethDst="", bandwidth="", lambda_alloc=False, |
| ipProto="", ipSrc="", ipDst="", tcpSrc="", tcpDst=""): |
| ''' |
| ======= |
| def add_point_intent( self, ingress_device, egress_device, |
| port_ingress="", port_egress="", ethType="", ethSrc="", |
| ethDst="", bandwidth="", lambda_alloc=False, |
| ipProto="", ipSrc="", ipDst="", tcpSrc="", tcpDst="" ): |
| """ |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| Required: |
| * ingress_device: device id of ingress device |
| * egress_device: device id of egress device |
| Optional: |
| * ethType: specify ethType |
| * ethSrc: specify ethSrc ( i.e. src mac addr ) |
| * ethDst: specify ethDst ( i.e. dst mac addr ) |
| * bandwidth: specify bandwidth capacity of link |
| * lambda_alloc: if True, intent will allocate lambda |
| for the specified intent |
| * ipProto: specify ip protocol |
| * ipSrc: specify ip source address |
| * ipDst: specify ip destination address |
| * tcpSrc: specify tcp source port |
| * tcpDst: specify tcp destination port |
| Description: |
| Adds a point-to-point intent ( uni-directional ) by |
| specifying device id's and optional fields |
| |
| NOTE: This function may change depending on the |
| options developers provide for point-to-point |
| intent via cli |
| """ |
| try: |
| cmd = "" |
| |
| # If there are no optional arguments |
| if not ethType and not ethSrc and not ethDst\ |
| and not bandwidth and not lambda_alloc \ |
| and not ipProto and not ipSrc and not ipDst \ |
| and not tcpSrc and not tcpDst: |
| cmd = "add-point-intent" |
| <<<<<<< HEAD |
| |
| ======= |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| |
| else: |
| cmd = "add-point-intent" |
| |
| if ethType: |
| cmd += " --ethType " + str( ethType ) |
| if ethSrc: |
| <<<<<<< HEAD |
| cmd += " --ethSrc " + str(ethSrc) |
| if ethDst: |
| cmd += " --ethDst " + str(ethDst) |
| ======= |
| cmd += " --ethSrc " + str( ethSrc ) |
| if ethDst: |
| cmd += " --ethDst " + str( ethDst ) |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| if bandwidth: |
| cmd += " --bandwidth " + str( bandwidth ) |
| if lambda_alloc: |
| cmd += " --lambda " |
| if ipProto: |
| cmd += " --ipProto " + str( ipProto ) |
| if ipSrc: |
| cmd += " --ipSrc " + str( ipSrc ) |
| if ipDst: |
| cmd += " --ipDst " + str( ipDst ) |
| if tcpSrc: |
| cmd += " --tcpSrc " + str( tcpSrc ) |
| if tcpDst: |
| cmd += " --tcpDst " + str( tcpDst ) |
| |
| <<<<<<< HEAD |
| #Check whether the user appended the port |
| #or provided it as an input |
| ======= |
| # Check whether the user appended the port |
| # or provided it as an input |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| if "/" in ingress_device: |
| cmd += " " + str( ingress_device ) |
| else: |
| if not port_ingress: |
| main.log.error( "You must specify " + |
| "the ingress port" ) |
| # TODO: perhaps more meaningful return |
| return main.FALSE |
| |
| <<<<<<< HEAD |
| cmd += " "+ \ |
| str(ingress_device) + "/" +\ |
| str(port_ingress) + " " |
| ======= |
| cmd += " " + \ |
| str( ingress_device ) + "/" +\ |
| str( port_ingress ) + " " |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| |
| if "/" in egress_device: |
| cmd += " " + str( egress_device ) |
| else: |
| if not port_egress: |
| main.log.error( "You must specify " + |
| "the egress port" ) |
| return main.FALSE |
| |
| <<<<<<< HEAD |
| cmd += " "+\ |
| str(egress_device) + "/" +\ |
| str(port_egress) |
| |
| handle = self.sendline(cmd) |
| if re.search( "Error", handle ): |
| main.log.error("Error in adding point-to-point intent") |
| ======= |
| cmd += " " +\ |
| str( egress_device ) + "/" +\ |
| str( port_egress ) |
| |
| self.handle.sendline( cmd ) |
| |
| main.log.info( cmd + " sent" ) |
| i = self.handle.expect( [ |
| "Error", |
| "onos>" ] ) |
| |
| if i == 0: |
| main.log.error( "Error in adding point-to-point intent" ) |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return main.FALSE |
| else: |
| return main.TRUE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| |
| def add_multipoint_to_singlepoint_intent(self, ingress_device1, |
| ingress_device2, egress_device, port_ingress="", port_egress="", |
| ethType="", ethSrc="", ethDst="", bandwidth="", lambda_alloc=False, |
| ipProto="", ipSrc="", ipDst="", tcpSrc="", tcpDst="", setEthSrc="", |
| setEthDst=""): |
| ''' |
| ======= |
| def add_multipoint_to_singlepoint_intent( |
| self, ingress_device1, ingress_device2, egress_device, |
| port_ingress="", port_egress="", ethType="", ethSrc="", |
| ethDst="", bandwidth="", lambda_alloc=False, |
| ipProto="", ipSrc="", ipDst="", tcpSrc="", tcpDst="", setEthSrc="", setEthDst="" ): |
| """ |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| Note: |
| This function assumes that there would be 2 ingress devices and |
| one egress device. For more number of ingress devices, this |
| function needs to be modified |
| Required: |
| * ingress_device1: device id of ingress device1 |
| * ingress_device2: device id of ingress device2 |
| * egress_device: device id of egress device |
| Optional: |
| * ethType: specify ethType |
| * ethSrc: specify ethSrc ( i.e. src mac addr ) |
| * ethDst: specify ethDst ( i.e. dst mac addr ) |
| * bandwidth: specify bandwidth capacity of link |
| * lambda_alloc: if True, intent will allocate lambda |
| for the specified intent |
| * ipProto: specify ip protocol |
| * ipSrc: specify ip source address |
| * ipDst: specify ip destination address |
| * tcpSrc: specify tcp source port |
| * tcpDst: specify tcp destination port |
| * setEthSrc: action to Rewrite Source MAC Address |
| * setEthDst: action to Rewrite Destination MAC Address |
| Description: |
| Adds a multipoint-to-singlepoint intent ( uni-directional ) by |
| specifying device id's and optional fields |
| |
| NOTE: This function may change depending on the |
| options developers provide for multipointpoint-to-singlepoint |
| intent via cli |
| """ |
| try: |
| cmd = "" |
| |
| # If there are no optional arguments |
| if not ethType and not ethSrc and not ethDst\ |
| and not bandwidth and not lambda_alloc\ |
| and not ipProto and not ipSrc and not ipDst\ |
| and not tcpSrc and not tcpDst and not setEthSrc\ |
| and not setEthDst: |
| cmd = "add-multi-to-single-intent" |
| |
| else: |
| cmd = "add-multi-to-single-intent" |
| |
| if ethType: |
| cmd += " --ethType " + str( ethType ) |
| if ethSrc: |
| <<<<<<< HEAD |
| cmd += " --ethSrc " + str(ethSrc) |
| if ethDst: |
| cmd += " --ethDst " + str(ethDst) |
| ======= |
| cmd += " --ethSrc " + str( ethSrc ) |
| if ethDst: |
| cmd += " --ethDst " + str( ethDst ) |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| if bandwidth: |
| cmd += " --bandwidth " + str( bandwidth ) |
| if lambda_alloc: |
| cmd += " --lambda " |
| if ipProto: |
| cmd += " --ipProto " + str( ipProto ) |
| if ipSrc: |
| cmd += " --ipSrc " + str( ipSrc ) |
| if ipDst: |
| cmd += " --ipDst " + str( ipDst ) |
| if tcpSrc: |
| cmd += " --tcpSrc " + str( tcpSrc ) |
| if tcpDst: |
| cmd += " --tcpDst " + str( tcpDst ) |
| if setEthSrc: |
| cmd += " --setEthSrc " + str( setEthSrc ) |
| if setEthDst: |
| cmd += " --setEthDst " + str( setEthDst ) |
| |
| <<<<<<< HEAD |
| #Check whether the user appended the port |
| #or provided it as an input |
| if "/" in ingress_device1: |
| cmd += " "+str(ingress_device1) |
| ======= |
| # Check whether the user appended the port |
| # or provided it as an input |
| if "/" in ingress_device1: |
| cmd += " " + str( ingress_device1 ) |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| else: |
| if not port_ingress1: |
| main.log.error( "You must specify " + |
| "the ingress port1" ) |
| # TODO: perhaps more meaningful return |
| return main.FALSE |
| |
| <<<<<<< HEAD |
| cmd += " "+ \ |
| str(ingress_device1) + "/" +\ |
| str(port_ingress1) + " " |
| ======= |
| cmd += " " + \ |
| str( ingress_device1 ) + "/" +\ |
| str( port_ingress1 ) + " " |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| |
| if "/" in ingress_device2: |
| cmd += " " + str( ingress_device2 ) |
| else: |
| if not port_ingress2: |
| main.log.error( "You must specify " + |
| "the ingress port2" ) |
| # TODO: perhaps more meaningful return |
| return main.FALSE |
| |
| cmd += " " + \ |
| str( ingress_device2 ) + "/" +\ |
| str( port_ingress2 ) + " " |
| |
| if "/" in egress_device: |
| cmd += " " + str( egress_device ) |
| else: |
| if not port_egress: |
| main.log.error( "You must specify " + |
| "the egress port" ) |
| return main.FALSE |
| |
| <<<<<<< HEAD |
| cmd += " "+\ |
| str(egress_device) + "/" +\ |
| str(port_egress) |
| print "cmd= ",cmd |
| handle = self.sendline(cmd) |
| if re.search( "Error", handle ): |
| main.log.error("Error in adding point-to-point intent") |
| ======= |
| cmd += " " +\ |
| str( egress_device ) + "/" +\ |
| str( port_egress ) |
| print "cmd= ", cmd |
| self.handle.sendline( cmd ) |
| |
| main.log.info( cmd + " sent" ) |
| i = self.handle.expect( [ |
| "Error", |
| "onos>" ] ) |
| |
| if i == 0: |
| main.log.error( "Error in adding point-to-point intent" ) |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return self.handle |
| else: |
| return main.TRUE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| def remove_intent(self, intent_id): |
| ''' |
| Remove intent for specified intent id |
| |
| Returns: |
| main.False on error and |
| cli output otherwise |
| ''' |
| try: |
| cmd_str = "remove-intent " + str( intent_id ) |
| handle = self.sendline( cmd_str ) |
| if re.search( "Error", handle ): |
| main.log.error("Error in removing intent") |
| return main.FALSE |
| else: |
| # TODO: Should this be main.TRUE |
| return handle |
| ======= |
| def remove_intent( self, intent_id ): |
| """ |
| Remove intent for specified intent id |
| """ |
| try: |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "remove-intent " + str( intent_id ) ) |
| i = self.handle.expect( [ |
| "Error", |
| "onos>" ] ) |
| |
| handle = self.handle.before |
| |
| if i == 0: |
| main.log.error( "Error in removing intent" ) |
| return handle |
| else: |
| return handle |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| def routes(self, json_format=False): |
| ''' |
| NOTE: This method should be used after installing application: |
| onos-app-sdnip |
| ======= |
| # This method should be used after installing application: onos-app-sdnip |
| def routes( self, json_format=False ): |
| """ |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| Optional: |
| * json_format: enable output formatting in json |
| Description: |
| Obtain all routes in the system |
| """ |
| try: |
| if json_format: |
| <<<<<<< HEAD |
| cmd_str = "routes -j" |
| handle_tmp = self.sendline( cmd_str ) |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle = ansi_escape.sub('', handle_tmp) |
| else: |
| cmd_str = "routes" |
| handle = self.sendline( cmd_str ) |
| ======= |
| self.handle.sendline( "routes -j" ) |
| self.handle.expect( "routes -j" ) |
| self.handle.expect( "onos>" ) |
| handle_tmp = self.handle.before |
| |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle = ansi_escape.sub( '', handle_tmp ) |
| |
| else: |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "routes" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return handle |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def intents( self, json_format=True ): |
| """ |
| Optional: |
| * json_format: enable output formatting in json |
| Description: |
| Obtain intents currently installed |
| <<<<<<< HEAD |
| ''' |
| try: |
| if json_format: |
| cmd_str = "intents -j" |
| handle = self.sendline( cmd_str ) |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle = ansi_escape.sub('', handle) |
| else: |
| cmd_str = "intents" |
| handle = self.sendline( cmd_str ) |
| ======= |
| """ |
| try: |
| if json_format: |
| self.handle.sendline( "intents -j" ) |
| self.handle.expect( "intents -j" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle = ansi_escape.sub( '', handle ) |
| else: |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "intents" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return handle |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def flows( self, json_format=True ): |
| """ |
| Optional: |
| * json_format: enable output formatting in json |
| Description: |
| Obtain flows currently installed |
| <<<<<<< HEAD |
| ''' |
| try: |
| if json_format: |
| cmd_str = "flows -j" |
| handle = self.sendline( cmd_str ) |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle = ansi_escape.sub('', handle) |
| else: |
| cmd_str = "flows" |
| handle = self.sendline( cmd_str ) |
| if re.search("Error\sexecuting\scommand:", handle): |
| main.log.error( self.name + ".flows() response: " + |
| str( handle ) ) |
| ======= |
| """ |
| try: |
| if json_format: |
| self.handle.sendline( "flows -j" ) |
| self.handle.expect( "flows -j" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle = ansi_escape.sub( '', handle ) |
| |
| else: |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| self.handle.sendline( "flows" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| if re.search( "Error\sexecuting\scommand:", handle ): |
| main.log.error( |
| self.name + ".flows() response: " + str( handle ) ) |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return handle |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| def push_test_intents(self, dpid_src, dpid_dst, num_intents, |
| num_mult="", app_id="", report=True): |
| ''' |
| ======= |
| def push_test_intents( self, dpid_src, dpid_dst, num_intents, |
| num_mult="", app_id="", report=True ): |
| """ |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| Description: |
| Push a number of intents in a batch format to |
| a specific point-to-point intent definition |
| Required: |
| * dpid_src: specify source dpid |
| * dpid_dst: specify destination dpid |
| * num_intents: specify number of intents to push |
| Optional: |
| * num_mult: number multiplier for multiplying |
| the number of intents specified |
| * app_id: specify the application id init to further |
| modularize the intents |
| * report: default True, returns latency information |
| """ |
| try: |
| <<<<<<< HEAD |
| cmd = "push-test-intents "+\ |
| str(dpid_src)+" "+str(dpid_dst)+" "+\ |
| str(num_intents) |
| if num_mult: |
| cmd += " " + str(num_mult) |
| #If app id is specified, then num_mult |
| #must exist because of the way this command |
| #takes in arguments |
| if app_id: |
| cmd += " " + str(app_id) |
| handle = self.sendline( cmd ) |
| #Some color thing that we want to escape |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle = ansi_escape.sub('', handle) |
| ======= |
| cmd = "push-test-intents " +\ |
| str( dpid_src ) + " " + str( dpid_dst ) + " " +\ |
| str( num_intents ) |
| |
| if num_mult: |
| cmd += " " + str( num_mult ) |
| # If app id is specified, then num_mult |
| # must exist because of the way this command |
| # takes in arguments |
| if app_id: |
| cmd += " " + str( app_id ) |
| |
| self.handle.sendline( cmd ) |
| self.handle.expect( cmd ) |
| self.handle.expect( "onos>" ) |
| |
| handle = self.handle.before |
| |
| # Some color thing that we want to escape |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle = ansi_escape.sub( '', handle ) |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| if report: |
| lat_result = [] |
| main.log.info( handle ) |
| # Split result by newline |
| newline = handle.split( "\r\r\n" ) |
| # Ignore the first object of list, which is empty |
| newline = newline[ 1: ] |
| # Some sloppy parsing method to get the latency |
| for result in newline: |
| <<<<<<< HEAD |
| result = result.split(": ") |
| #Append the first result of second parse |
| lat_result.append(result[1].split(" ")[0]) |
| main.log.info(lat_result) |
| ======= |
| result = result.split( ": " ) |
| # Append the first result of second parse |
| lat_result.append( result[ 1 ].split( " " )[ 0 ] ) |
| |
| main.log.info( lat_result ) |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return lat_result |
| else: |
| return main.TRUE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| def intents_events_metrics(self, json_format=True): |
| ''' |
| ======= |
| def intents_events_metrics( self, json_format=True ): |
| """ |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| Description:Returns topology metrics |
| Optional: |
| * json_format: enable json formatting of output |
| """ |
| try: |
| if json_format: |
| <<<<<<< HEAD |
| cmd_str = "intents-events-metrics -j" |
| handle = self.sendline( cmd_str ) |
| # Some color thing that we want to escape |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle = ansi_escape.sub('', handle) |
| else: |
| cmd_str = "intents-events-metrics" |
| handle = self.sendline( cmd_str ) |
| return handle |
| ======= |
| self.handle.sendline( "intents-events-metrics -j" ) |
| self.handle.expect( "intents-events-metrics -j" ) |
| self.handle.expect( "onos>" ) |
| |
| handle = self.handle.before |
| |
| # Some color thing that we want to escape |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle = ansi_escape.sub( '', handle ) |
| |
| else: |
| self.handle.sendline( "intents-events-metrics" ) |
| self.handle.expect( "intents-events-metrics" ) |
| self.handle.expect( "onos>" ) |
| |
| handle = self.handle.before |
| |
| return handle |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def topology_events_metrics( self, json_format=True ): |
| """ |
| Description:Returns topology metrics |
| Optional: |
| * json_format: enable json formatting of output |
| """ |
| try: |
| if json_format: |
| <<<<<<< HEAD |
| cmd_str = "topology-events-metrics -j" |
| handle = self.sendline( cmd_str ) |
| #Some color thing that we want to escape |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle = ansi_escape.sub('', handle) |
| else: |
| cmd_str = "topology-events-metrics" |
| handle = self.sendline( cmd_str ) |
| return handle |
| ======= |
| self.handle.sendline( "topology-events-metrics -j" ) |
| self.handle.expect( "topology-events-metrics -j" ) |
| self.handle.expect( "onos>" ) |
| |
| handle = self.handle.before |
| |
| # Some color thing that we want to escape |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle = ansi_escape.sub( '', handle ) |
| |
| else: |
| self.handle.sendline( "topology-events-metrics" ) |
| self.handle.expect( "topology-events-metrics" ) |
| self.handle.expect( "onos>" ) |
| |
| handle = self.handle.before |
| |
| return handle |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| # Wrapper functions **************** |
| # Wrapper functions use existing driver |
| # functions and extends their use case. |
| # For example, we may use the output of |
| # a normal driver function, and parse it |
| # using a wrapper function |
| |
| def get_all_intents_id( self ): |
| """ |
| Description: |
| Obtain all intent id's in a list |
| """ |
| try: |
| # Obtain output of intents function |
| intents_str = self.intents() |
| all_intent_list = [] |
| intent_id_list = [] |
| |
| # Parse the intents output for ID's |
| intents_list = [ s.strip() for s in intents_str.splitlines() ] |
| for intents in intents_list: |
| if "onos>" in intents: |
| continue |
| elif "intents" in intents: |
| continue |
| else: |
| line_list = intents.split( " " ) |
| all_intent_list.append( line_list[ 0 ] ) |
| |
| all_intent_list = all_intent_list[ 1:-2 ] |
| |
| for intents in all_intent_list: |
| if not intents: |
| continue |
| else: |
| intent_id_list.append( intents ) |
| |
| return intent_id_list |
| |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def get_all_devices_id( self ): |
| """ |
| Use 'devices' function to obtain list of all devices |
| and parse the result to obtain a list of all device |
| id's. Returns this list. Returns empty list if no |
| devices exist |
| List is ordered sequentially |
| |
| This function may be useful if you are not sure of the |
| device id, and wish to execute other commands using |
| the ids. By obtaining the list of device ids on the fly, |
| you can iterate through the list to get mastership, etc. |
| """ |
| try: |
| # Call devices and store result string |
| devices_str = self.devices( json_format=False ) |
| id_list = [] |
| |
| if not devices_str: |
| main.log.info( "There are no devices to get id from" ) |
| return id_list |
| |
| # Split the string into list by comma |
| device_list = devices_str.split( "," ) |
| # Get temporary list of all arguments with string 'id=' |
| temp_list = [ dev for dev in device_list if "id=" in dev ] |
| # Split list further into arguments before and after string |
| # 'id='. Get the latter portion ( the actual device id ) and |
| # append to id_list |
| for arg in temp_list: |
| id_list.append( arg.split( "id=" )[ 1 ] ) |
| return id_list |
| |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def get_all_nodes_id( self ): |
| """ |
| Uses 'nodes' function to obtain list of all nodes |
| and parse the result of nodes to obtain just the |
| node id's. |
| Returns: |
| list of node id's |
| """ |
| try: |
| nodes_str = self.nodes() |
| id_list = [] |
| |
| if not nodes_str: |
| main.log.info( "There are no nodes to get id from" ) |
| return id_list |
| |
| # Sample nodes_str output |
| # id=local, address=127.0.0.1:9876, state=ACTIVE * |
| |
| # Split the string into list by comma |
| nodes_list = nodes_str.split( "," ) |
| temp_list = [ node for node in nodes_list if "id=" in node ] |
| for arg in temp_list: |
| id_list.append( arg.split( "id=" )[ 1 ] ) |
| |
| return id_list |
| |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def get_device( self, dpid=None ): |
| """ |
| Return the first device from the devices api whose 'id' contains 'dpid' |
| Return None if there is no match |
| """ |
| import json |
| try: |
| if dpid is None: |
| return None |
| else: |
| dpid = dpid.replace( ':', '' ) |
| raw_devices = self.devices() |
| devices_json = json.loads( raw_devices ) |
| # search json for the device with dpid then return the device |
| for device in devices_json: |
| # print "%s in %s?" % ( dpid, device[ 'id' ] ) |
| if dpid in device[ 'id' ]: |
| return device |
| return None |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def check_status( self, ip, numoswitch, numolink, log_level="info" ): |
| """ |
| Checks the number of swithes & links that ONOS sees against the |
| supplied values. By default this will report to main.log, but the |
| log level can be specifid. |
| |
| Params: ip = ip used for the onos cli |
| numoswitch = expected number of switches |
| numlink = expected number of links |
| log_level = level to log to. Currently accepts 'info', 'warn' and 'report' |
| |
| |
| log_level can |
| |
| Returns: main.TRUE if the number of switchs and links are correct, |
| main.FALSE if the numer of switches and links is incorrect, |
| and main.ERROR otherwise |
| """ |
| try: |
| topology = self.get_topology( ip ) |
| if topology == {}: |
| return main.ERROR |
| output = "" |
| # Is the number of switches is what we expected |
| devices = topology.get( 'devices', False ) |
| links = topology.get( 'links', False ) |
| if devices == False or links == False: |
| return main.ERROR |
| switch_check = ( int( devices ) == int( numoswitch ) ) |
| # Is the number of links is what we expected |
| link_check = ( int( links ) == int( numolink ) ) |
| if ( switch_check and link_check ): |
| # We expected the correct numbers |
| output = output + "The number of links and switches match "\ |
| + "what was expected" |
| result = main.TRUE |
| else: |
| output = output + \ |
| "The number of links and switches does not match what was expected" |
| result = main.FALSE |
| output = output + "\n ONOS sees %i devices (%i expected) and %i links (%i expected)"\ |
| % ( int( devices ), int( numoswitch ), int( links ), int( numolink ) ) |
| if log_level == "report": |
| main.log.report( output ) |
| elif log_level == "warn": |
| main.log.warn( output ) |
| else: |
| main.log.info( output ) |
| return result |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def device_role( self, device_id, onos_node, role="master" ): |
| """ |
| Calls the device-role cli command. |
| device_id must be the id of a device as seen in the onos devices command |
| onos_node is the ip of one of the onos nodes in the cluster |
| role must be either master, standby, or none |
| |
| <<<<<<< HEAD |
| Returns: |
| main.TRUE or main.FALSE based on argument verification and |
| main.ERROR if command returns and error |
| ''' |
| try: |
| if role.lower() == "master" or role.lower() == "standby" or\ |
| role.lower() == "none": |
| cmd_str = "device-role " +\ |
| str(device_id) + " " +\ |
| str(onos_node) + " " +\ |
| str(role) |
| handle = self.sendline( cmd_str ) |
| if re.search( "Error", handle ): |
| # end color output to escape any colours |
| # from the cli |
| main.log.error( self.name + ": " +\ |
| handle + '\033[0m' ) |
| return main.ERROR |
| return main.TRUE |
| ======= |
| Returns main.TRUE or main.FALSE based on argument verification. |
| When device-role supports errors this should be extended to |
| support that output |
| """ |
| try: |
| # print "beginning device_role... \n\tdevice_id:" + device_id |
| # print "\tonos_node: " + onos_node |
| # print "\trole: "+ role |
| if role.lower() == "master" or \ |
| role.lower() == "standby" or \ |
| role.lower() == "none": |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| self.handle.sendline( "device-role " + |
| str( device_id ) + " " + |
| str( onos_node ) + " " + |
| str( role ) ) |
| i = self.handle.expect( [ "Error", "onos>" ] ) |
| if i == 0: |
| output = str( self.handle.before ) |
| self.handle.expect( "onos>" ) |
| output = output + str( self.handle.before ) |
| main.log.error( self.name + ": " + |
| output + '\033[0m' ) # end color output to escape any colours from the cli |
| return main.ERROR |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| return main.TRUE |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| else: |
| main.log.error("Invalid 'role' given to device_role(). " + |
| "Value was '" + str( role ) + "'.") |
| return main.FALSE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def clusters( self, json_format=True ): |
| """ |
| Lists all clusters |
| Optional argument: |
| * json_format - boolean indicating if you want output in json |
| """ |
| try: |
| <<<<<<< HEAD |
| if json_format: |
| cmd_str = "clusters -j" |
| handle = self.sendline( cmd_str ) |
| ''' |
| handle variable here contains some ANSI escape color code |
| sequences at the end which are invisible in the print command |
| output. To make that escape sequence visible, use repr() |
| function. The repr(handle) output when printed shows the ANSI |
| escape sequences. In json.loads(somestring), this somestring |
| variable is actually repr(somestring) and json.loads would fail |
| with the escape sequence. So we take off that escape sequence |
| using: |
| |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle1 = ansi_escape.sub('', handle) |
| ''' |
| ansi_escape = re.compile(r'\r\r\n\x1b[^m]*m') |
| handle1 = ansi_escape.sub('', handle) |
| return handle1 |
| else: |
| cmd_str = "clusters" |
| handle = self.sendline( cmd_str ) |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| if json_format: |
| self.handle.sendline( "clusters -j" ) |
| self.handle.expect( "clusters -j" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| """ |
| handle variable here contains some ANSI escape color code |
| sequences at the end which are invisible in the print command |
| output. To make that escape sequence visible, use repr() function. |
| The repr( handle ) output when printed shows the ANSI escape sequences. |
| In json.loads( somestring ), this somestring variable is actually |
| repr( somestring ) and json.loads would fail with the escape sequence. |
| So we take off that escape sequence using |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle1 = ansi_escape.sub( '', handle ) |
| """ |
| # print "repr(handle) =", repr( handle ) |
| ansi_escape = re.compile( r'\r\r\n\x1b[^m]*m' ) |
| handle1 = ansi_escape.sub( '', handle ) |
| # print "repr(handle1) = ", repr( handle1 ) |
| return handle1 |
| else: |
| self.handle.sendline( "clusters" ) |
| self.handle.expect( "onos>" ) |
| handle = self.handle.before |
| # print "handle =",handle |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return handle |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| def election_test_leader(self): |
| ''' |
| CLI command to get the current leader for the Election test application |
| NOTE: Requires installation of the onos-app-election feature |
| Returns: Node IP of the leader if one exists |
| None if none exists |
| Main.FALSE on error |
| ''' |
| try: |
| cmd_str = "election-test-leader" |
| response = self.sendline( cmd_str ) |
| # Leader |
| leaderPattern = "The\scurrent\sleader\sfor\sthe\sElection\s" +\ |
| "app\sis\s(?P<node>.+)\." |
| node_search = re.search(leaderPattern, response) |
| if node_search: |
| node = node_search.group('node') |
| main.log.info( "Election-test-leader on " + str( self.name ) + |
| " found " + node + " as the leader" ) |
| return node |
| # no leader |
| nullPattern = "There\sis\scurrently\sno\sleader\selected\sfor\s" +\ |
| "the\sElection\sapp" |
| null_search = re.search(nullPattern, response) |
| if null_search: |
| main.log.info( "Election-test-leader found no leader on " + |
| self.name ) |
| return None |
| #error |
| errorPattern = "Command\snot\sfound" |
| if re.search(errorPattern, response): |
| main.log.error("Election app is not loaded on " + self.name) |
| # TODO: Should this be main.ERROR? |
| return main.FALSE |
| else: |
| main.log.error("Error in election_test_leader: " + |
| "unexpected response") |
| main.log.error( repr(response) ) |
| ======= |
| def election_test_leader( self ): |
| """ |
| * CLI command to get the current leader for the Election test application. |
| #NOTE: Requires installation of the onos-app-election feature |
| Returns: Node IP of the leader if one exists |
| None if none exists |
| Main.FALSE on error |
| """ |
| try: |
| self.handle.sendline( "election-test-leader" ) |
| self.handle.expect( "election-test-leader" ) |
| self.handle.expect( "onos>" ) |
| response = self.handle.before |
| # Leader |
| node_search = re.search( |
| "The\scurrent\sleader\sfor\sthe\sElection\sapp\sis\s(?P<node>.+)\.", |
| response ) |
| if node_search: |
| node = node_search.group( 'node' ) |
| main.log.info( "Election-test-leader on " + str( |
| self.name ) + " found " + node + " as the leader" ) |
| return node |
| # no leader |
| null_search = re.search( |
| "There\sis\scurrently\sno\sleader\selected\sfor\sthe\sElection\sapp", |
| response ) |
| if null_search: |
| main.log.info( |
| "Election-test-leader found no leader on " + |
| self.name ) |
| return None |
| # error |
| if re.search( "Command\snot\sfound", response ): |
| main.log.error( "Election app is not loaded on " + self.name ) |
| return main.FALSE |
| else: |
| main.log.error( |
| "Error in election_test_leader: unexpected response" ) |
| main.log.error( repr( response ) ) |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| return main.FALSE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| <<<<<<< HEAD |
| def election_test_run(self): |
| ''' |
| CLI command to run for leadership of the Election test application. |
| NOTE: Requires installation of the onos-app-election feature |
| Returns: Main.TRUE on success |
| Main.FALSE on error |
| ''' |
| try: |
| cmd_str = "election-test-run" |
| response = self.sendline( cmd_str ) |
| #success |
| successPattern = "Entering\sleadership\selections\sfor\sthe\s" +\ |
| "Election\sapp." |
| search = re.search( successPattern, response ) |
| if search: |
| main.log.info( self.name + " entering leadership elections " + |
| "for the Election app." ) |
| return main.TRUE |
| #error |
| errorPattern = "Command\snot\sfound" |
| if re.search( errorPattern, response ): |
| main.log.error( "Election app is not loaded on " + self.name ) |
| return main.FALSE |
| else: |
| main.log.error( "Error in election_test_run: " + |
| "unexpected response" ) |
| ======= |
| def election_test_run( self ): |
| """ |
| * CLI command to run for leadership of the Election test application. |
| #NOTE: Requires installation of the onos-app-election feature |
| Returns: Main.TRUE on success |
| Main.FALSE on error |
| """ |
| try: |
| self.handle.sendline( "election-test-run" ) |
| self.handle.expect( "election-test-run" ) |
| self.handle.expect( "onos>" ) |
| response = self.handle.before |
| # success |
| search = re.search( |
| "Entering\sleadership\selections\sfor\sthe\sElection\sapp.", |
| response ) |
| if search: |
| main.log.info( |
| self.name + |
| " entering leadership elections for the Election app." ) |
| return main.TRUE |
| # error |
| if re.search( "Command\snot\sfound", response ): |
| main.log.error( "Election app is not loaded on " + self.name ) |
| return main.FALSE |
| else: |
| main.log.error( |
| "Error in election_test_run: unexpected response" ) |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| main.log.error( repr( response ) ) |
| return main.FALSE |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def election_test_withdraw( self ): |
| """ |
| * CLI command to withdraw the local node from leadership election for |
| * the Election test application. |
| #NOTE: Requires installation of the onos-app-election feature |
| Returns: Main.TRUE on success |
| Main.FALSE on error |
| """ |
| try: |
| <<<<<<< HEAD |
| cmd_str = "election-test-withdraw" |
| response = self.sendline( cmd_str ) |
| #success |
| successPattern = "Withdrawing\sfrom\sleadership\selections\sfor" +\ |
| "\sthe\sElection\sapp." |
| if re.search( successPattern, response ): |
| main.log.info( self.name + " withdrawing from leadership " + |
| "elections for the Election app." ) |
| return main.TRUE |
| #error |
| errorPattern = "Command\snot\sfound" |
| if re.search( errorPattern, response ): |
| main.log.error( "Election app is not loaded on " + self.name ) |
| return main.FALSE |
| else: |
| main.log.error( "Error in election_test_withdraw: " + |
| "unexpected response" ) |
| main.log.error( repr( response ) ) |
| return main.FALSE |
| ======= |
| self.handle.sendline( "election-test-withdraw" ) |
| self.handle.expect( "election-test-withdraw" ) |
| self.handle.expect( "onos>" ) |
| response = self.handle.before |
| # success |
| search = re.search( |
| "Withdrawing\sfrom\sleadership\selections\sfor\sthe\sElection\sapp.", |
| response ) |
| if search: |
| main.log.info( |
| self.name + |
| " withdrawing from leadership elections for the Election app." ) |
| return main.TRUE |
| # error |
| if re.search( "Command\snot\sfound", response ): |
| main.log.error( "Election app is not loaded on " + self.name ) |
| return main.FALSE |
| else: |
| main.log.error( |
| "Error in election_test_withdraw: unexpected response" ) |
| main.log.error( repr( response ) ) |
| return main.FALSE |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| #*********************************** |
| def getDevicePortsEnabledCount( self, dpid ): |
| """ |
| Get the count of all enabled ports on a particular device/switch |
| """ |
| try: |
| dpid = str( dpid ) |
| <<<<<<< HEAD |
| cmd_str = "onos:ports -e " + dpid + " | wc -l" |
| output = self.sendline( cmd_str ) |
| if re.search( "No such device", output ): |
| main.log.error( "Error in getting ports" ) |
| return ( output, "Error" ) |
| else: |
| return output |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "onos:ports -e " + dpid + " | wc -l" ) |
| i = self.handle.expect( [ |
| "No such device", |
| "onos>" ] ) |
| |
| # self.handle.sendline( "" ) |
| # self.handle.expect( "onos>" ) |
| |
| output = self.handle.before |
| |
| if i == 0: |
| main.log.error( "Error in getting ports" ) |
| return ( output, "Error" ) |
| else: |
| result = output |
| return result |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def getDeviceLinksActiveCount( self, dpid ): |
| """ |
| Get the count of all enabled ports on a particular device/switch |
| """ |
| try: |
| <<<<<<< HEAD |
| dpid = str(dpid) |
| cmd_str = "onos:links " + dpid + " | grep ACTIVE | wc -l" |
| output = self.sendline( cmd_str ) |
| if re.search( "No such device", output ): |
| main.log.error( "Error in getting ports ") |
| return ( output, "Error ") |
| else: |
| return output |
| ======= |
| dpid = str( dpid ) |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( |
| "onos:links " + |
| dpid + |
| " | grep ACTIVE | wc -l" ) |
| i = self.handle.expect( [ |
| "No such device", |
| "onos>" ] ) |
| |
| output = self.handle.before |
| |
| if i == 0: |
| main.log.error( "Error in getting ports" ) |
| return ( output, "Error" ) |
| else: |
| result = output |
| return result |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |
| def getAllIntentIds( self ): |
| """ |
| Return a list of all Intent IDs |
| """ |
| try: |
| <<<<<<< HEAD |
| cmd_str = "onos:intents | grep id=" |
| output = self.sendline( cmd_str ) |
| if re.search( "Error", output ): |
| main.log.error( "Error in getting ports" ) |
| return ( output, "Error" ) |
| else: |
| return output |
| ======= |
| self.handle.sendline( "" ) |
| self.handle.expect( "onos>" ) |
| |
| self.handle.sendline( "onos:intents | grep id=" ) |
| i = self.handle.expect( [ |
| "Error", |
| "onos>" ] ) |
| |
| output = self.handle.before |
| |
| if i == 0: |
| main.log.error( "Error in getting ports" ) |
| return ( output, "Error" ) |
| else: |
| result = output |
| return result |
| |
| >>>>>>> 8ec71447cf6f890345b6b3c29368d5bd3c29dd54 |
| except pexpect.EOF: |
| main.log.error( self.name + ": EOF exception found" ) |
| main.log.error( self.name + ": " + self.handle.before ) |
| main.cleanup() |
| main.exit() |
| except: |
| main.log.info( self.name + " ::::::" ) |
| main.log.error( traceback.print_exc() ) |
| main.log.info( self.name + " ::::::" ) |
| main.cleanup() |
| main.exit() |
| |