Gitiles
Code Review Sign In
gerrit.onosproject.org / spring-open-cli / 1725e498e49068c90ef3ef405d2f085f766dd25a / . / cli / cli.py
blob: e6987af1c90abc52db602a9b5e741f43021c45a6 [file] [log] [blame]
#!/usr/bin/python
#
# Copyright (c) 2010,2011,2012,2013 Big Switch Networks, Inc.
#
# Licensed under the Eclipse Public License, Version 1.0 (the
# "License"); you may not use this file except in compliance with the
# License. You may obtain a copy of the License at
#
# http://www.eclipse.org/legal/epl-v10.html
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied. See the License for the specific language governing
# permissions and limitations under the License.
#
# sdnsh - The Controller Shell
# --------------------------------------------------------------------------------
#
# LOOK! TODO --
#
# create tokens for modify actions in StaticFlowEntryPusher and here
#
# extend completion to show help text
#
# need to verify we can talk to the controller
#
# flow-entry naming - unique across all switches?
#
# joins on show commands (port names, ids, etc.)
#
# accept enums in addition to numbers - "ether-type arp" or "ether-type ip"
#
# cli commands not mapping to database model (this is an -undo-)
#
# simple options/singletons in the CLI ("logging level 5" "twitter username blah")
#
# csv, left/right justification in columns, sorts
#
# completion with multi command lines
#
# disallow 'switch' field and name as options flow-entry ('key' fields in general)
#
# delayed commit semantics (depends on 1?)
#
# delete config files?
#
# --------------------------------------------------------------------------------
#
# Notes:
#
# support functions for a command, consider, for example, 'vns-definition'
#
# For a new command, for example 'vns-definition', there will be a variety
# of different support functions to manage different required functionaly.
# do_vns_definition() describes what to do to execute the actual command.
# cp_vns_definition() describes how to perform command completion for the same.
# do_show_vns_definition() would describe how to show the vns-definitions
# (this procedure doesn't exist, but is implemented by 'show vns' via
# do_show_vns), while
# cp_show_vns_definition() would describe how to complete the show command for
# this particular command. Other functions may also be needed, for example
# specialized changes to the 'no' command for the same command.
#
# command completion
#
# currently in many cases, there's a specialized completion handler
# it would make sense to manage 'no' completion by overloading the
# same completion handler.
#
#
# error processing:
#
# Keep in mond that al errors ought to use a similar prefix so that
# all the error conditions acan be identifyed by the automated test
# procedures. these prefixes are regular expressions in bigtest/cli.py
# The prefixed currently recognized as errors are 'Error: Not Found",
# 'Error running command ', 'Syntax error:', and 'Syntax: ' the last
# of which is used to display both usage for some commands, and
# various specific syntax errors
#
# alias management:
#
# Aliases are managed by having a separate table/model for each
# of the aliases, for example the host table has an associated alias
# table called 'host-alias'. These alias models are nothing more
# than an id, which is the alias name and a foreign key for the other
# table, in the 'host-alias' model, the associated foreign key would
# point to the host.
#
# Alias tables or models are not directly configured as alias tables,
# the cli can find these tables by noticing the only fields within
# the model is a foreign key for another table. The cli builds the
# alias_obj_type_xref dictionary during initialization, and later uses
# that association to manage aliases. Knowing which of the tables
# are alias tables also allows the cli to exclude these tables from
# modification in typical config mode.
#
# Alias are created when within the submode for a particular obj_type,
# for example, the host-alias table is available within the host
# config submode, and it appears as the 'host-alias' table there.
# However no further submode for the host-alias is managed; it is
# treated as if it were a field in the submode config object.
# So if 'host-alias xxx' were entered while in host config submode,
# the cli converts the request into a host-alias table entry.
#
# Feature management. The cli is intended to manage the availability
# of specific feature groups. This isn't meant to prevent a user from
# getting at specific sku features (ie: licensing), but instead meant
# to allow a user to disable specific sub-groups of commands to
# prevent unintended enabling of features. For example,
# to prevent a 'static-flow' cli configured controller from enabling
# vns features likely resulting in a misconfigured environment.
#
# changes:
#
# -- new source field for obj_types in models, obj_types which are
# written based on discovered details are typically not editable.
# don't allow a config submode entry. and don't
# advertise such an entry is possible
#
# -- integrated alias support, no special cases through the use
# of a separated alias tables. this allows more integrated
# cli support for tables specifically constructed to manage
# alias names for other fields. Currently code in the cli
# prevents multiple alias for a single foreign key, but this
# behavior can be relaxed (perhaps it ought to be configurable?)
#
# -- perform alias substitution for 'no' commands obj_type's
#
# -- support for primary key/id changes within a row.
# if an update occurs which modifies the primary key of a row,
# the cli now identifies whether any foreign keys point at
# the existing entry, and updates the foreign key to reference
# the updated primary key.
#
# -- support for cascaded delete.
# when a row is deleted, if there are foreign keys associated
# with the row, the cli will remove them. the climodelinfo
# configures which obj_types are included in the cascade deletes.
#
# -- vns interface creation.
# vns interfaces are required to have a vns-interface-rule associated.
# sdnplatform writes both the interface name and the rule, but the cli needed
# to have code added to determine and validate the associated rule.
# The validation attempts to ensure the correct rule is associated with
# the use of the interface name (id).
#
import subprocess
import os, atexit, stat
import sys, traceback # traceback.print_exc()
from optparse import OptionParser
from types import StringType
import collections
import datetime
import json
import re
import time
import urllib2
import httplib # provides error processing for isinstance
import socket
import select
import fcntl
import posixpath
import random
import copy
import utif
import fmtcnv
import run_config
import imp
import locale
from pkg_resources import resource_filename
from modi import Modi
from midw import *
from vnsw import *
from prettyprint import PrettyPrinter
from storeclient import StoreClient
from climodelinfo import CliModelInfo
from vendor import VendorDB
import error
import command
import rest_to_model
import tech_support
import url_cache
import doc
import sdndb
#
# --------------------------------------------------------------------------------
#
class ParamException(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
class TooManyVNSException(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
TIMESTAMP_HELP = \
('Enter an integer timestamp in milliseconds since the epoch or formatted\n' +
'as one of the following options in your local timezone:\n'
'"YYYY-MM-DD HH:MM:SS" YYYY-MM-DDTHH:MM:SS\n' +
'"YYYY-MM-DD HH:MM:SS+TTT" YYYY-MM-DDTHH:MM:SS+TTT\n' +
'YYYY-MM-DD MM-DD\n' +
'HH:MM now')
# This is a bit of a hack. The completion and validation functions for time zones
# are static methods, but they need to access the SDNSh object to get at the
# controller field to be able to do a REST call to load the list of time zone
# strings. So we set up a global for the single SDNSh instance we have. An
# alternative would have been to have a global variable for the list of time
# zone strings that's initialized when the CLI is initialized, but it seems
# nicer to only load it on demand, especially since setting the time zone
# will be a pretty infrequently invoked command.
cli = None
#
# Constants for packet tracing
#
SESSIONID = 'sessionId'
FT_VNS = 'vns'
FT_PORT = 'port'
FT_PORT_DPID = 'dpid'
FT_PORT_PORT = 'port'
FT_OUTPUT = 'output'
FT_DIRECTION = 'direction'
FT_PERIOD = 'period'
FT_TIMEOUT = "FilterTimeout"
FT_PERIOD_DEFAULT = 300
onos=1
#
# --------------------------------------------------------------------------------
#
class NotFound(Exception):
def __init__(self, obj_type, name):
self.obj_type = obj_type
self.name = name
def __str__(self):
return "Not Found: %s %s" % (self.obj_type, self.name)
# LOOK!: The next two functions are copied from the sdncon code.
# Should ideally figure out a way to share the code for utility
# functions like this.
def dotted_decimal_to_int(ip):
"""
Converts a dotted decimal IP address string to a 32 bit integer
"""
bytes = ip.split('.')
ip_int = 0
for b in bytes:
ip_int = (ip_int << 8) + int(b)
return ip_int
def same_subnet(ip1, ip2, netmask):
"""
Checks whether the two ip addresses are on the same subnet as
determined by the netmask argument. All of the arguments are
dotted decimal IP address strings.
"""
ip1_int = dotted_decimal_to_int(ip1)
ip2_int = dotted_decimal_to_int(ip2)
netmask_int = dotted_decimal_to_int(netmask)
return (ip1_int & netmask_int) == (ip2_int & netmask_int)
#
# --------------------------------------------------------------------------------
#
class SDNSh():
debug = False # general cli debugging
debug_backtrace = False # backtrace on failures
description = False # help debug command descriptions
display_rest = False # display rest call details
display_reply_rest = False # display rest call replies details
command_dict = {}
mode_stack = []
reserved_words = ['unknown', 'all']
known_controllers = ["127.0.0.1:8000"]
controller = None
# LOOK! manage this separately until we can cetainly
# talk to eth0 addr instead of 127.0.0.1
controller_for_prompt = "127.0.0.1:8000"
cluster = "default"
run = True
# Are we running in batch mode, i.e. "cat commands | cli"
batch = False
# used for parsing as an arg
local_name_pattern = "config://([A-Za-z0-9_:@\-\.\/]+$)"
# name of boot/startup-config
boot_config_filename = '/opt/sdnplatform/run/boot-config'
saved_configs_dirname = '/opt/sdnplatform/run/saved-configs/'
feature_allow_experimental = '/opt/sdnplatform/feature/experimental'
# contained objects
pp = None
store = None
model_handler = None
# cached metadata
stats_metadata = None
stats_type_metadata = None
stats_restapi_map = {'controller-node': 'controller'}
stats_optional_params = {
'start-time': {'type': 'string',
'syntax_help': TIMESTAMP_HELP},
'end-time': {'type': 'string',
'syntax_help': TIMESTAMP_HELP},
'duration': {'type': 'string',
'syntax_help':
"Enter an integer followed by a time unit\n" +
"[integer]weeks [integer]days [integer]hours\n" +
"[integer]mins [integer]secs [integer]ms"},
'sample-interval': {'type': 'int',
'syntax_help': 'Enter an integer number of milliseconds'},
'sample-count': {'type': 'int',
'syntax_help': 'Enter an integer target sample count'},
'sample-window': {'type': 'string',
'syntax_help': 'Enter an integer number of milliseconds for sampling window'},
'data-format': {'type': 'enum', 'values': ['value', 'rate']},
'display': {'type': 'enum', 'values': ['latest-value', 'graph', 'table']},
#'limit': {'type': 'int'}
}
netvirt_feature_enabled_cached = False
warning_suppress = False #
#
# --------------------------------------------------------------------------------
# warning
# When a config is getting replayed, warnings are suporessed. Other situations
# may also require supression of warnings.
#
def warning(self, message):
if not self.warning_suppress:
print "Warning: %s" % message
#
# --------------------------------------------------------------------------------
# supress_warnings(self)
#
def suppress_warnings(self):
self.warning_suppress = True
#
# --------------------------------------------------------------------------------
# enable_warnings(self)
#
def enable_warnings(self):
self.warning_suppress = False
config_replay = False # only true while replaying config files
#
# --------------------------------------------------------------------------------
# config_replay_start
# Behavior is different during config replay. Warnings are
# suppressed, and other error conditions may be relaxed, for example
# the switch submode interface command requires that the interface exist,
# and the interface names are discovered by sdnplatform, which means that during
# config replay for statup, an unknown-named-interface may need to be accepted
# since that interface may appear once the switch connected to sdnplatform, and
# sdnplatform writes the ports for this switch.
#
def config_replay_start(self):
self.suppress_warnings()
self.config_replay = True
#
# --------------------------------------------------------------------------------
# config_replay_done
#
def config_replay_done(self):
self.enable_warnings()
self.config_replay = False
#
# --------------------------------------------------------------------------------
# config_replay_active
# Returns true when a configuration is getting replayed
#
def config_replay_active(self):
return self.config_replay
#
# --------------------------------------------------------------------------------
# note
# When a config is getting replayed, warnings/notes are suporessed. Other situations
# may also require supression of warnings.
#
def note(self, message):
if not self.warning_suppress:
print "Note: %s" % message
#
# --------------------------------------------------------------------------------
# debug_msg
# Debugging message cover. Only enabled for display once 'debug cli' is performed.
#
def debug_msg(self, message):
if self.debug:
print "debug_msg: %s" % message
#
# --------------------------------------------------------------------------------
# error_msg
# Error message cover, to ensure consistent error messages
#
@staticmethod
def error_msg(message):
return "Error: %s" % message
#
# --------------------------------------------------------------------------------
# syntax_msg
# Syntax error message cover, to ensure consistent error messages
#
@staticmethod
def syntax_msg(message):
return "Syntax: %s" % message
#
# --------------------------------------------------------------------------------
# completion_error_msg
# Error message cover during completion, to ensure consistent error messages
#
def completion_error_msg(self, message):
self.print_completion_help("Error: %s" % message)
#
# --------------------------------------------------------------------------------
# completion_syntax_msg
# Syntax error message cover during completion, to ensure consistent error messages
#
def completion_syntax_msg(self, message):
self.print_completion_help("Syntax: %s" % message)
#
# --------------------------------------------------------------------------------
# init_history_file
#
def init_history_file(self):
history_file = os.path.join(os.environ["HOME"], ".sdnsh_history")
# create the initial history file group-writable,
# so that the tacacs users can write to it
if os.path.exists(history_file):
st = os.stat(history_file)
if not (st[stat.ST_MODE] & stat.S_IWGRP):
buf = open(history_file).read()
os.rename(history_file, history_file + "~")
mask = os.umask(007)
fno = os.open(history_file, os.O_WRONLY | os.O_CREAT, 0660)
os.umask(mask)
os.write(fno, buf)
os.close(fno)
else:
mask = os.umask(007)
fno = os.open(history_file, os.O_WRONLY | os.O_CREAT, 0660)
os.umask(mask)
os.close(fno)
try:
readline.read_history_file(history_file)
except IOError:
pass
atexit.register(readline.write_history_file, history_file)
#
# --------------------------------------------------------------------------------
# init_command_dict
#
def init_command_dict(self):
#
# command_submode_dict saves a little information about
# submode commands. The index is 'mode', and the resulting
# list contains strings, each of which is a submode command
# available in that mode.
self.command_submode_dict = {}
#
# associate command names with features, so that when
# help is provided, command names which have associated
# features are validated to determine whether the feature
# is enabled or not.
self.command_name_feature = {}
#
# command_nested_dict is indexed by mode, and contains
# command configured with a trailing '*', for example
# 'mode' : 'config-*', intended to mean "all nested
# submodes after config-'. This can't be computed until
# all submodes are known, which means all the command
# describption must be configured., for these to make sense.
self.command_nested_dict = {}
#
# config mode commands
#
#self.command_dict['config'] = [ "boot" ]
#
# commands which start at 'login'
#
if onos == 0:
self.command_nested_dict['login'] = [ 'show', 'logout', 'exit',
'history', 'help', 'echo',
'date', 'trace', 'traceroute',
'ping', 'test', 'version',
'connect', 'watch', 'no' ]
else:
self.command_nested_dict['login'] = [ 'show', 'logout', 'exit',
'history', 'help', 'echo',
'date', 'trace',
'ping', 'test', 'version',
'connect', 'watch', 'no' ]
self.command_nested_dict['enable'] = [ 'clear', 'end' ]
#self.command_dict['config-internal'] = ['lint', 'permute']
#
# --------------------------------------------------------------------------------
# make_unit_formatter
#
@staticmethod
def make_unit_formatter(units):
return lambda x, y: '%s %s' % (x, units)
#
# --------------------------------------------------------------------------------
# init_stats_metadata
#
def init_stats_metadata(self):
# Initialize the stats metadata by pulling it from the rest api
json_data = self.rest_simple_request_to_dict('http://%s/rest/v1/stats/metadata/%s/' % \
(self.controller, self.cluster))
metadata = {}
fields = {}
for item in json_data:
# XXX Requesting this stat causes a long delay in reading; bug in sdncon
# once this is fixed we can add back in; also add to field_orderings below
#if json_data[item]['name'] == 'OFActiveFlow':
# continue
if json_data[item]['target_type'] in metadata:
metadata[json_data[item]['target_type']].append(json_data[item])
else:
metadata[json_data[item]['target_type']] = [json_data[item]]
fields[json_data[item]['target_type']] = {}
formatter = self.make_unit_formatter(json_data[item]['units'])
fields[json_data[item]['target_type']][json_data[item]['name']] = \
{'verbose-name': json_data[item]['verbose_name'],
'units': json_data[item]['units'],
'formatter': formatter}
self.stats_metadata = json_data
self.stats_type_metadata = metadata
self.pp.add_format('STATS-CONTROLLER',
'cli.init_stats_metadata()', # origina
{'stats-controller' : {
'field-orderings' : {'default':
['cpu-user', 'cpu-nice', 'cpu-system',
'cpu-idle'
'mem-free', 'mem-used', 'swap-used',
'disk-root', 'disk-log', 'disk-boot',
'sdnplatform-cpu', 'database-cpu',
'apache-cpu', 'cli-cpu', 'statd-cpu']},
'fields' : fields['controller']
}})
self.pp.add_format('STATS-SWITCH',
'cli.init_stats_metadata()', # origina
{ 'stats-switch' : {
'field-orderings' : {'default':
['OFPacketIn', 'OFFlowMod', 'OFActiveFlow']},
'fields' : fields['switch']
}})
for obj_type in fields:
for field in fields[obj_type]:
for data_format in ['rate', 'value']:
units = fields[obj_type][field]['units']
if data_format == 'rate':
units += '/s'
self.pp.add_format('STATS-%s-%s-%s' % (obj_type,field,data_format),
'cli.init_stats_metadata()',
{ 'stats-%s-%s-%s' % (obj_type,field,data_format) : { \
'field-orderings' : {'default': ['value', 'timestamp']},
'fields' : {'timestamp': {'verbose-name': 'Timestamp',
'formatter':
lambda x,y: time.ctime(x/1000)},
'value': {'units': units,
'verbose-name':
'%s (%s)' %
(fields[obj_type][field]['verbose-name'],
units)}}
}})
#
# --------------------------------------------------------------------------------
#
def command_packages_path(self):
command_descriptions = 'desc'
desc_path = resource_filename(__name__, command_descriptions)
if desc_path:
# print "desc_path %s" % desc_path
return desc_path
desc_path = os.path.join(os.path.dirname(__file__), command_descriptions)
if os.path.exists(desc_path):
return desc_path
return None
#
# --------------------------------------------------------------------------------
#
def command_packages_exists(self, version):
desc_path = self.command_packages_path()
if desc_path == None:
return None
version_path = os.path.join(desc_path, version)
if os.path.exists(version_path):
return version_path
return None
#
# --------------------------------------------------------------------------------
#
def add_command_packages(self, version):
"""
Add all command and output format components
"""
desc_path = self.command_packages_path()
if desc_path == None:
print 'No Command Descriptions subdirectory'
return
for path_version in [x for x in os.listdir(desc_path) if x.startswith(version)]:
print path_version
result_tuple = imp.find_module(path_version, [desc_path])
imp.load_module(version, result_tuple[0], result_tuple[1], result_tuple[2])
new_path = result_tuple[1]
cmds_imported = []
for cmds in os.listdir(new_path):
(prefix, suffix) = os.path.splitext(cmds)
if (suffix == '.py' or suffix == '.pyc') and prefix not in cmds_imported and prefix != '__init__':
cmds_imported.append(prefix)
result_tuple = imp.find_module(prefix, [new_path])
module = imp.load_module(prefix, result_tuple[0], result_tuple[1], result_tuple[2])
command.add_commands_from_module(version, module, self.dump_syntax)
self.pp.add_formats_from_module(version, module)
# print cmds_imported
#
# --------------------------------------------------------------------------------
#
def choices_text_builder(self, matches, max_len = None, col_width = None):
"""
@param max_len integer, describes max width of any entry in matches
@param col_width integer, colun width
"""
# Sort the choices alphabetically, but if the token ends
# in a number, sort that number numerically.
try:
entries = sorted(matches, utif.completion_trailing_integer_cmp)
except Exception, e:
traceback.print_exc()
if col_width == None:
# request to look it up
(col_width, line_length) = self.pp.get_terminal_size()
col_width = min(120, col_width)
if max_len == None:
# request to compute the max length
max_len = len(max(matches, key=len))
count = len(matches)
max_len += 1 # space after each choice
if max_len > col_width:
# one per line?
pass
else:
per_line = col_width / max_len
lines = (count + (per_line - 1)) / per_line
if lines == 1:
return ''.join(['%-*s' % (max_len, m) for m in entries])
else:
# fill the columns, which means skipping around the entries
result = []
for l in range(lines):
result.append(['%-*s' % (max_len, entries[i])
for i in range(l, count, lines)])
lines = [''.join(x) for x in result]
return '\n'.join(lines)
#
# --------------------------------------------------------------------------------
#
def matches_hook(self, subs, matches, max_len):
# one shot disabler, used to disable printing of completion
# help for two-column help display (for '?' character).
# completion printing here can only display the possible selections,
# for two-column mode, the reason why each keyword was added
# needs to be displayed, which is no longer available here.
if self.completion_print == False:
self.completion_print = True
return
choices_text = self.choices_text_builder(matches, max_len)
self.print_completion_help(choices_text)
#
# --------------------------------------------------------------------------------
#
def pre_input_hook(self):
"""
"""
pass
#
# --------------------------------------------------------------------------------
#
def desc_version_to_path_elem(self, version):
"""
Version numbers like 1.0 need to be converted to the path
element associated with the number, like version100
"""
try:
version_number = float(version)
version = 'version%s' % int(version_number * 100)
except:
pass
# temporary, use until version100 exists.
if version == 'version100' and not self.command_packages_exists(version):
version = 'version200'
return version
#
# --------------------------------------------------------------------------------
# init
#
def init(self):
global mi
self.completion_print = True
self.vendordb = VendorDB()
self.vendordb.init()
parser = OptionParser()
parser.add_option("-c", "--controller", dest="controller",
help="set default controller to CONTROLLER",
metavar="CONTROLLER", default=self.controller)
parser.add_option("-S", "--syntax", dest='dump_syntax',
help="display syntax of loaded commands",
action='store_true', default=False)
parser.add_option("-i", "--init", dest='init',
help="do not perform initialization checks",
action='store_true', default=False)
parser.add_option("-d", "--debug", dest='debug',
help='enable debug for cli (debug cli)',
action='store_true', default=False)
parser.add_option("-v", "--version", dest='desc_version',
help='select command versions (description group)',
default=None)
parser.add_option('-m', "--mode", dest='starting_mode',
help='once the cli starts, nest into this mode')
parser.add_option('-q', "--quiet", dest='quiet',
help='suppress warning messages',
action='store_true', default=False)
(self.options, self.args) = parser.parse_args()
self.controller = self.options.controller
if not self.controller:
self.controller = "127.0.0.1:8000"
self.dump_syntax = self.options.dump_syntax
if not self.dump_syntax:
self.dump_syntax = False
self.debug = self.options.debug
# command option, then env, then default
self.desc_version = self.options.desc_version
if self.desc_version == None:
self.desc_version = os.getenv('CLI_COMMAND_VERSION')
if self.desc_version == None:
self.desc_version = '2.0' # 'version200'
if self.desc_version:
self.desc_version = self.desc_version_to_path_elem(self.desc_version)
self.length = 0 # screen length.
self.set_controller_for_prompt()
if not sys.stdin.isatty():
self.batch = True
self.store = StoreClient()
self.store.set_controller(self.controller)
mi = Modi(self, CliModelInfo())
self.mi = mi
self.init_command_dict()
self.completion_reset()
self.completion_skip = False
self.completion_cache = True
readline.set_completer(self.completer)
readline.set_completer_delims("\t ")
# readline.set_pre_input_hook(self.pre_input_hook)
readline.set_completion_display_matches_hook(self.matches_hook)
if not self.batch:
self.init_history_file()
self.push_mode("login")
# starting mode,
starting_mode = self.options.starting_mode
if starting_mode == None:
starting_mode = os.getenv('CLI_STARTING_MODE')
if starting_mode:
if starting_mode == 'login':
pass
elif starting_mode == 'enable':
self.push_mode("enable")
elif starting_mode == 'config':
self.push_mode("enable")
self.push_mode("config")
else:
print 'Only login, enable or config allowed as starting modes'
# process quiet option
quiet = self.options.quiet
if quiet == None:
quiet = os.getenv('CLI_SUPPRESS_WARNING')
if quiet:
self.supress_warnings()
#
self.pp = PrettyPrinter(self)
#
# pattern matches
#
self.IP_ADDR_RE = re.compile(r'^(\d{1,3}\.){3}\d{1,3}$')
self.CIDR_RE = re.compile(r'^((\d{1,3}\.){3}\d{1,3})/(\d{1,2}?)$')
self.MAC_RE = re.compile(r'^(([A-Fa-f\d]){2}:?){5}[A-Fa-f\d]{2}$')
self.DPID_RE = re.compile(r'^(([A-Fa-f\d]){2}:?){7}[A-Fa-f\d]{2}$')
self.ACL_RE = re.compile(r'^\d+$') # just the leading digits
self.DIGITS_RE = re.compile(r'^\d+$')
self.HEX_RE = re.compile(r'^0x[0-9a-fA-F]+$')
# Initialize any middleware layers
init_midware(self, mi)
init_vnsw(self, mi)
rest_to_model.rest_to_model_init(self, mi)
run_config.init_running_config(self, mi)
# Initialize all doc tags, use a subdirectory based on
# the locale. This may be incorect if there's nothing
# in the configured locale for the returned locale value.
lc = locale.getdefaultlocale()
if lc == None or lc[0] == None:
print 'Locale not configured ', lc
lc = ('en_US', 'UTF8')
doc_dir = resource_filename(__name__, 'documentation/%s' % lc[0])
if doc_dir is None:
doc_dir = os.path.join(os.path.dirname(__file__), 'documentation', lc[0])
# print "doc_dir %s" % doc_dir
doc.add_doc_tags(doc_dir)
# Initialize the command module, than add command packages
command.init_command(self, mi)
self.add_command_packages(self.desc_version)
# save for possible later use
#print self.pp.format_table(self.pp.format_details())
#
if self.debug:
for (n,v) in self.command_submode_dict.items():
print "SUBMODE %s %s" % (n,v)
for (n,v) in self.command_dict.items():
print "MODE %s %s" % (n,v)
self.time_zone_list = None
command.add_completion('time-zone-completion', SDNSh.time_zone_completion)
command.add_validation('time-zone-validation', SDNSh.time_zone_validation)
command.add_action('set-clock', SDNSh.set_clock_action, {'kwargs': {'data': '$data'}})
command.add_action('begin-default-gateway-check', SDNSh.begin_default_gateway_check_action)
command.add_action('end-default-gateway-check', SDNSh.end_default_gateway_check_action)
command.add_command_type('config-with-default-gateway-check', {
'action': ('begin-default-gateway-check', 'write-fields', 'end-default-gateway-check'),
'no-action': ('begin-default-gateway-check', 'reset-fields', 'end-default-gateway-check')
})
#
if self.feature_enabled('experimental'):
print '***Warning: experimental features enabled***'
if self.debug:
self.sdndb = sdndb.SDNDB(self, self, self.pp)
print '--BEGIN--'
self.sdndb.display('core/switch', style='table')
self.sdndb.display('core/controller', style='table')
self.sdndb.display('core/controller', style='list')
print '--LINK--', self.pp.table_info['link']['field-orderings']
self.sdndb.display('topology/link')
self.sdndb.display('topology/switch-cluster')
self.sdndb.display('topology/switch-cluster', style='list')
self.sdndb.display('topology/enabled-port')
#
# --------------------------------------------------------------------------------
# check_rest_result
@staticmethod
def check_rest_result(result, message=None):
if isinstance(result, collections.Mapping):
error_type = result.get('error_type')
if error_type:
raise error.CommandRestError(result, message)
#
# --------------------------------------------------------------------------------
# get_table_from_store
# Caches the last result to try to cut down on the number of times large tables
# are loaded from the REST API
#
def get_table_from_store(self, obj_type, key = None, val = None, match = None):
return self.store.get_table_from_store(obj_type, key, val, match)
#
# --------------------------------------------------------------------------------
# get_object_from_store
# cover for call to get a specific object from a table, only a convenience.
#
def get_object_from_store(self, obj_type, obj_name):
return self.store.get_object_from_store(obj_type, obj_name)
#
# --------------------------------------------------------------------------------
# rest_query_objects
# cover for call to query objects from the database, only a convenience.
#
def rest_query_objects(self, obj_type, query_params=None):
return self.store.rest_query_objects(obj_type, query_params)
#
# --------------------------------------------------------------------------------
# rest_create_object
# REST API call to create an object, if this is the last table which
# was fetched, then discard that table.
#
def rest_create_object(self, obj_type, ident):
return self.store.rest_create_object(obj_type, ident)
#
# --------------------------------------------------------------------------------
# rest_delete_objects
#
def rest_delete_objects(self, obj_type, delete_params):
return self.store.rest_delete_objects(obj_type, delete_params)
#
# --------------------------------------------------------------------------------
# rest_delete_object
#
def rest_delete_object(self, obj_type, name):
if type(name) == dict:
return self.store.rest_delete_object(obj_type, name)
return self.store.rest_delete_object(obj_type, mi.pk(obj_type), name)
#
# --------------------------------------------------------------------------------
# rest_update_object
#
def rest_update_object(self, obj_type, name, obj_key_val, obj_key_data):
return self.store.rest_update_object(obj_type, name, obj_key_val, obj_key_data)
#
# --------------------------------------------------------------------------------
# rest_simple_resquest_to_dict
# Issue a store_simple_request and covert the result into a dict using json.load
# Performs no exception handling
#
def rest_simple_request_to_dict(self, url):
return json.loads(self.store.rest_simple_request(url))
#
# --------------------------------------------------------------------------------
# rest_post_request
# Forward a low-level REST request to the store
#
def rest_post_request(self, url, obj, verb='PUT'):
return self.store.rest_post_request(url, obj, verb)
#
# --------------------------------------------------------------------------------
# create_object
# Helper function to help identify call sites which create objects
# Errors result in printing an error message, then returning True
#
def create_object(self, obj_type, field_dict):
try:
self.rest_create_object(obj_type, field_dict)
return False
except Exception, e:
errors = self.rest_error_to_dict(e, obj_type)
if errors != None:
print self.rest_error_dict_to_message(errors)
return True
#
# --------------------------------------------------------------------------------
# create_row
# Helper function to help identify call sites which create new rows
#
# Return a pair of bool's, the first is an error indication, while the second
# is True when the row needed to be created.
#
#
def create_row(self, obj_type, name, row_dict = None):
# create the row with a dictionary which includes all the
# populated values for the foreign keys
# the row is created.
if row_dict == None:
updated_dict = {}
else:
updated_dict = row_dict
#
# Only set the primary key for obj_keys which aren't managed
# by the CassandraSetting/COMPOUND_KEY_FIELDS (this is currently
# a slightly different predicate than is_compound_key)
#
key = mi.pk(obj_type)
type_info = mi.obj_type_info_dict[obj_type]['fields'][key]['type']
if type_info != 'compound-key':
updated_dict[mi.pk(obj_type)] = name
updated_dict = self.associate_foreign_keys_with_dict(obj_type, updated_dict)
if self.create_object(obj_type, updated_dict):
return [True, False]
return [False, True]
#
# --------------------------------------------------------------------------------
# find_or_create_row
# Return a pair of bool's, the first is an error indication, while the second
# is True when the row needed to be created.
#
# When a new row is created, if the obj_type has a private_key, an attempt
# is made to identify all the private keys, and populate values for each
# of them.
#
def find_or_create_row(self, obj_type, name, row_dict = None):
if row_dict == None:
row_dict = {}
try:
result = self.get_object_from_store(obj_type, name)
if result[mi.pk(obj_type)] == name:
return [False, False]
except Exception:
pass
return self.create_row(obj_type, name, row_dict)
#
# --------------------------------------------------------------------------------
# associate_foreign_keys_with_dict
# Passed an obj_type, and a dictionary, returns a dictionary with updated
# key:value pairs for all the known private keys.
#
#
def associate_foreign_keys_with_dict(self, obj_type, create_dict):
#
# Private key names are 'well known', so the names are used here to
# idenify how the field ought to be populated.
#
for foreign_key_id in mi.obj_type_foreign_keys(obj_type):
if foreign_key_id in create_dict:
# already set in the dictionary
pass
elif mi.is_null_allowed(obj_type, foreign_key_id):
continue
elif foreign_key_id == 'vns':
create_dict[foreign_key_id] = self.vns_name()
elif foreign_key_id == 'vns-access-list' and \
self.get_current_mode_obj_type() == 'vns-access-list':
create_dict[foreign_key_id] = self.get_current_mode_obj()
elif foreign_key_id == 'rule':
# LOOK! this seems to need more work, what's the rule relationship?
if obj_type == 'vns-interface':
create_dict = associate_foreign_key_for_vns_interface(dict)
else:
traceback.print_stack()
print self.error_msg("Internal: %s can't determine value " \
"for foreign key %s" % (obj_type, foreign_key_id))
return create_dict
#
# methods to manage the mode_stack, prompts, and mode_obj/mode_obj_type
#
#
# --------------------------------------------------------------------------------
# set_contoller_for_prompt
#
def set_controller_for_prompt(self):
if self.controller == "127.0.0.1:8000":
self.controller_for_prompt = socket.gethostname()
else:
self.controller_for_prompt = self.controller
self.update_prompt()
#
# --------------------------------------------------------------------------------
# update_prompt
# There are several different prompts depending on the current mode:
# 'host'> -- login mode
# 'host'# -- enable mode
# 'host'(config)# -- config mode
# 'host'(config-vns-definition-name)# -- vns-definition mode
# 'host'(config-vns-definition-interface-rule-name)# -- vns-defn,
# interface-rule mode
#
def update_prompt(self):
if self.current_mode().startswith("config"):
current_mode = "(" + self.current_mode()
if self.get_current_mode_obj() != None:
if self.in_config_submode("config-vns"):
# substitute '|' with '-'
parts = self.get_current_mode_obj().split('|')
current_mode += "-" + '-'.join(parts)
self.prompt = str(self.controller_for_prompt) + current_mode + ")# "
elif self.current_mode() == "enable":
self.prompt = str(self.controller_for_prompt) + "# "
else:
self.prompt = str(self.controller_for_prompt) + "> "
#
# --------------------------------------------------------------------------------
# push_mode
# Every pushed mode is a quad: <modeName, tableName, specificRow, exitCallback>
#
# obj_type is the name of an associated table/model (tableName)
# obj is the key's value for the table/model's key (specificRow)
#
# The cli currently supports a mode of table/model row edit, where the
# name of the table/mode is entered, along with an associated value for
# key-column of the table. Once in that mode, other fields of the table
# can be edited by entering the name of the field, along with a new value.
#
# The exitCallback is the nane of a method to call when the current pushed
# level is getting pop'd.
#
def push_mode(self, mode_name, obj_type=None, obj=None, exitCallback=None):
self.mode_stack.append( { 'mode_name' : mode_name,
'obj_type' : obj_type,
'obj' : obj,
'exit' : exitCallback} )
self.update_prompt()
#
# --------------------------------------------------------------------------------
# pop_mode
# Pop the top of the stack of mode's.
#
def pop_mode(self):
m = self.mode_stack.pop()
if len(self.mode_stack) == 0:
self.run = False
else:
self.update_prompt()
return m
#
# --------------------------------------------------------------------------------
# mode_stack_to_rest_dict
# Convert the stack of pushed modes into a collection of keys.
# Can be used to build the rest api dictionary used for row creates
#
def mode_stack_to_rest_dict(self, rest_dict):
#
for x in self.mode_stack:
if x['mode_name'].startswith('config-'):
rest_dict[x['obj_type']] = x['obj']
return rest_dict
#
# --------------------------------------------------------------------------------
# current_mode
# Return the string describing the current (top) mode.
#
def current_mode(self):
if len(self.mode_stack) < 1:
return ""
return self.mode_stack[-1]['mode_name']
#
# --------------------------------------------------------------------------------
# in_config_submode
# Return true when the current mode is editing the contents of one of the
# rows of the table/model store.
#
def in_config_submode(self, prefix = "config-"):
return self.current_mode().startswith(prefix)
#
# --------------------------------------------------------------------------------
# in_config_mode
# Returns true for any config mode; this is any nested edit mode,
# along with the base config mode
#
def in_config_mode(self):
return self.current_mode().startswith("config")
#
# --------------------------------------------------------------------------------
# in_config_switch_mode
# Returns true when the switch mode has been entered via the 'switch <dpid>' command.
#
def in_config_switch_mode(self):
return self.current_mode() == "config-switch"
#
# --------------------------------------------------------------------------------
# in_config_switch_if_mode
# Returns true when the switch-interface mode has been entered via the
# 'switch <dpid>' command, then the interface <name> command
#
def in_config_switch_if_mode(self):
return self.current_mode() == "config-switch-if"
#
# --------------------------------------------------------------------------------
# vns_name
#
def vns_name(self):
mode_dict = self.mode_stack_to_rest_dict({})
if 'vns' in mode_dict:
return mode_dict['vns']
if 'vns-definition' in mode_dict:
return mode_dict['vns-definition']
return None
#
# --------------------------------------------------------------------------------
# in_config_vns_mode
# Returns true when the vns mode has been entered via the 'vns <vnsId>' command.
#
def in_config_vns_mode(self):
return self.current_mode() == "config-vns"
#
# --------------------------------------------------------------------------------
# in_config_vns_def_mode
# Returns true when the vns mode has been entered via the
# 'vns-definition <vnsId>' command.
#
def in_config_vns_def_mode(self):
return self.current_mode() == "config-vns-def"
#
# --------------------------------------------------------------------------------
# in_config_vns_def_if_rule_mode
# Returns true when the vns mode has been entered via the
# 'vns-definition <vnsId>' command, then into interface-rule mode.
#
def in_config_vns_def_if_rule_mode(self):
return self.current_mode() == "config-vns-def-if-rule"
#
# --------------------------------------------------------------------------------
# in_config_vns_acl_mode
# Returns true when the vns mode has been entered via the
# 'vns <vnsId>' command, then into acl mode.
#
def in_config_vns_acl_mode(self):
return self.current_mode() == "config-vns-acl"
#
# --------------------------------------------------------------------------------
# in_config_vns_if_mode
# Returns true when the vns mode has been entered via the
# 'vns <vnsId>' command, then into interface mode.
#
def in_config_vns_if_mode(self):
return self.current_mode() == "config-vns-if"
#
# --------------------------------------------------------------------------------
# in_config_host_mode
# Returns true when the vns mode has been entered via the
# 'host <host-id>' command
#
def in_config_host_mode(self):
return self.current_mode() == "config-host"
#
# --------------------------------------------------------------------------------
# in_config_controller_node_mode
# Returns true when the vns mode has been entered via the
# 'controller-node <controller-node-id>' command
#
def in_config_controller_node_mode(self):
return self.current_mode() == "config-controller-node"
#
# --------------------------------------------------------------------------------
# in_config_controller_interface_mode
# Returns true when the controller interface mode has been entered via the
# 'interface Ethernet <#>' command from the controller-node config mode
#
def in_config_controller_interface_mode(self):
return self.current_mode() == "config-controller-if"
#
# --------------------------------------------------------------------------------
# in_config_port_channel_mode
#
def in_config_port_channel_mode(self):
return self.current_mode() == "config-port-channel"
# --------------------------------------------------------------------------------
# set_current_mode_obj
# Sets the name of the selected row (key's value)
#
def set_current_mode_obj(self, obj):
self.mode_stack[-1]['obj'] = obj
#
# --------------------------------------------------------------------------------
# get_current_mode_obj
# Gets the name of the current mode's selected row value (key's value)
# This can return None.
#
def get_current_mode_obj(self):
return self.mode_stack[-1]['obj']
#
# --------------------------------------------------------------------------------
# set_current_mode_obj_type
# Set the table/model name for this current mode.
#
def set_current_mode_obj_type(self, obj_type):
self.mode_stack[-1]['obj_type'] = obj_type
#
# --------------------------------------------------------------------------------
# get_current_mode_obj_type
# Get the table/model name for this current mode.
#
def get_current_mode_obj_type(self):
return self.mode_stack[-1]['obj_type']
#
# --------------------------------------------------------------------------------
# get_nested_mode_obj
# Get the id of the object that matches the given object type
# starting from the current mode and working backwards to the
# top-level mode. If there's no mode that matches the given
# object type, then return None (maybe should handle as exception?).
#
def get_nested_mode_obj(self, obj_type):
for i in range(1, len(self.mode_stack)+1):
# Use negative index so we search from the top/end of the stack
mode = self.mode_stack[-i]
if mode['obj_type'] == obj_type:
return mode['obj']
return None
#
# helper functions to access commands, obj_types, and fields
#
#
# --------------------------------------------------------------------------------
# all_obj_types_starting_with
# Returns a list of all the current object types starting with the text
# parameter.
#
#
def all_obj_types_starting_with(self, text=""):
if onos == 0:
netvirt_feature = self.netvirt_feature_enabled()
else:
netvirt_feature = False
matched_obj_types = [x for x in mi.obj_types
if x.startswith(text) and
self.debug_obj_type(x) and
(netvirt_feature or (x != 'vns-definition')) ]
# synthetic object type based on the vns config submode.
if self.in_config_vns_def_mode() and "interface-rule".startswith(text):
matched_obj_types.append("interface-rule")
if self.in_config_vns_mode() and "access-list".startswith(text):
matched_obj_types.append("access-list")
if self.in_config_vns_mode() and "interfaces".startswith(text):
matched_obj_types.append("interfaces")
return matched_obj_types
#
# --------------------------------------------------------------------------------
# feature_enabled
# Return True when a particular feature is enabled.
#
def feature_enabled(self, feature):
# features not managed via store
#
if feature == 'experimental':
return os.path.exists(self.feature_allow_experimental)
if feature == 'ha':
try:
with open(self.boot_config_filename, "r") as f:
for line in f:
if line.startswith('ha-config='):
parts = line.split('=')
if len(parts) > 0 and parts[1] == 'enabled\n':
return True
except:
pass
return False
# only current features which can be enabled disabled
if feature not in [
'vns', 'static-flow-pusher', 'performance-monitor']:
return False
#
try:
entry = self.get_table_from_store('feature')
except Exception, e:
errors = self.rest_error_to_dict(e, 'feature')
print self.rest_error_dict_to_message(errors)
return True
feature_to_field_dict = {
'vns' : 'netvirt-feature',
'static-flow-pusher' : 'static-flow-pusher-feature',
'performance-monitor' : 'performance-monitor-feature',
}
if len(entry) == 0:
if feature in feature_to_field_dict:
field = feature_to_field_dict[feature]
return mi.field_default_value('feature', field)
return True
if len(entry) != 1:
# need a mechanism to select one from the list
return True
if feature in feature_to_field_dict:
return entry[0][feature_to_field_dict[feature]]
# use the default value from the model (every feature needs a default value)
defauilt_value = mi.field_default_value('feature', feature_to_field_dict[feature])
if default_value == None:
print self.error_msg('Feature %s missing default value' % feature)
return True
return default_value
'''
#
# --------------------------------------------------------------------------
# address_space_default_create
#
# Create a default address space if it doesn't exist, which enables
# 'address-space default',
#
def address_space_default_create(self):
key = mi.pk('address-space')
try:
entries = self.get_table_from_store('address-space',
key, 'default', 'exact')
errors = None
except Exception, e:
errors = self.rest_error_to_dict(e, 'address-space')
if not 'see_other' in errors:
print self.rest_error_dict_to_message(errors)
return
if len(entries) == 0:
self.create_row('address-space', 'default')
#
# --------------------------------------------------------------------------
# tenant_default_create
#
# Create default tenant and system tenant if it doesn't exist, which enables
# 'tenant default' and tenant system, router vrsystem,
#
def tenant_default_create(self):
key = mi.pk('tenant')
try:
entries = self.get_table_from_store('tenant',
key, 'default', 'exact')
errors = None
except Exception, e:
errors = self.rest_error_to_dict(e, 'tenant')
if not 'see_other' in errors:
print self.rest_error_dict_to_message(errors)
return
if len(entries) == 0:
self.create_row('tenant', 'default')
#external tenant
try:
entries = self.get_table_from_store('tenant',
key, 'external', 'exact')
errors = None
except Exception, e:
errors = self.rest_error_to_dict(e, 'tenant')
if not 'see_other' in errors:
print self.rest_error_dict_to_message(errors)
return
if len(entries) == 0:
self.create_row('tenant', 'external')
#system tenant and system router: vrsystem
try:
entries = self.get_table_from_store('tenant',
key, 'system', 'exact')
errors = None
except Exception, e:
errors = self.rest_error_to_dict(e, 'tenant')
if not 'see_other' in errors:
print self.rest_error_dict_to_message(errors)
return
if len(entries) == 0:
self.create_row('tenant', 'system')
try:
entries = self.get_table_from_store('virtualrouter',
key, 'vrsystem', 'exact')
errors = None
except Exception, e:
errors = self.rest_error_to_dict(e, 'virtualrouter')
if not 'see_other' in errors:
print self.rest_error_dict_to_message(errors)
return
if len(entries) == 0:
self.create_row('virtualrouter', 'vrsystem',{"tenant":"system","vrname":"vrsystem"})
#
# --------------------------------------------------------------------------
# netvirt_feature_init
# perform vns featrue enablement:
# Create a default vns if it doesn't exist, which enables 'vns default',
#
def netvirt_feature_init(self):
self.address_space_default_create()
self.tenant_default_create()
key = mi.pk('vns-definition')
try:
entries = self.get_table_from_store('vns-definition', key, 'default|default', 'exact')
errors = None
except Exception, e:
errors = self.rest_error_to_dict(e, 'vns-definition')
if not 'see_other' in errors:
print self.rest_error_dict_to_message(errors)
return
if len(entries) == 0:
self.create_row('vns-definition', 'default', {"tenant":"default","vnsname":"default"})
#
# --------------------------------------------------------------------------------
# netvirt_feature_enabled
# Return True when the vns feature is enabled
#
# When vns is disabled, particular vns commands are no longer
# available, along with a few specific objects. Particular
# code sites which are specifically concerned with these issues
# disable these items. Another possible approach would be to
# modify the base information sources when a feature is
# enabled or disabled, ie: mi.obj_types and command_dict.
# This more active approach isn't taken since during
# the initialization process, a variety of different object
# relationships are constructed; foreign key xref's, alias
# key xref's, object key dictionaries, etc. If the feature
# enabled were more active, then all these relationships would also
# need to be recomputed.
#
def netvirt_feature_enabled(self):
controller_netvirt_feature = self.feature_enabled("vns")
if self.netvirt_feature_enabled_cached != controller_netvirt_feature:
self.netvirt_feature_enabled_cached = controller_netvirt_feature
if self.netvirt_feature_enabled_cached:
self.netvirt_feature_init()
if controller_netvirt_feature == False:
return False
return True
'''
#
# --------------------------------------------------------------------------------
# get_obj_of_type
# Return a single row, or None, of the table who's name is passed as obj_type
# Returns None when when there's multiple matches of the nane in the table/model
# Performs no error processing
#
def get_obj_of_type(self, obj_type, name):
key = mi.pk(obj_type)
if key:
errors = None
try:
entries = self.get_table_from_store(obj_type)
except Exception, e:
errors = self.rest_error_to_dict(e, obj_type)
if errors:
print self.rest_error_dict_to_message(errors)
return None
entries = [x for x in entries if x.get(key, 'None') == name]
if len(entries) != 1:
return None
return entries[0]
else:
return None
#
# --------------------------------------------------------------------------------
# fields_for_current_submode_starting_with
# Return a list of choices which are fields names of model/store objects
# Any fields which are primary keys are excluded from edit, as are any
# foreign keys, this is managed through is_editable()
#
def fields_for_current_submode_starting_with(self, start_text=""):
if not self.in_config_submode():
return []
if self.in_config_vns_mode():
return []
obj_type = self.get_current_mode_obj_type()
if not obj_type in mi.obj_type_info_dict:
return []
fields = [x for x in mi.obj_type_info_dict[obj_type]['fields'].keys() \
if mi.is_editable(obj_type, x)]
return [x for x in fields if x.startswith(start_text)]
#
# --------------------------------------------------------------------------------
# obj_types_for_config_mode_starting_with
#
# what obj types are available in the given submode
# e.g., top-level config mode has switch and config-switch has
# flow-entry but flow-entry should not be available in top-level
# config nor should switch be available in config-switch submode!
# LOOK! hardwired for now to test parsing - need to merge with model
#
def obj_types_for_config_mode_starting_with(self, start_text=""):
if not self.in_config_mode():
return []
#
# vns features
if onos == 0:
netvirt_features = self.netvirt_feature_enabled()
else:
netvirt_features = False
vns_objects = [ 'vns-definition' ]
ret_list = [x for x in mi.obj_types
if self.debug_obj_type(x) and
not mi.is_obj_type_source_not_user_config(x)]
return [x for x in ret_list if x.startswith(start_text) and
(netvirt_features or not x in vns_objects) ]
@staticmethod
def title_of(command):
return command['title'] if type(command) is dict else command
#
# --------------------------------------------------------------------------------
# commands_feature_enabled
#
def commands_feature_enabled(self, commands):
return [self.title_of(x) for x in commands
if (not self.title_of(x) in self.command_name_feature) or
command.isCommandFeatureActive(self.title_of(x),
self.command_name_feature[self.title_of(x)])]
#
# --------------------------------------------------------------------------------
# commands_for_mode
#
def commands_for_mode(self, mode):
"""
Walk the command dict, using interior submodes and compiling
the list of available commands (could rebuild command_dict()
to contain all the possible commands, but its good to know
exactly which commands apply to this submode)
"""
# make a new list, so that items don't get added to the source
ret_list = list(self.command_nested_dict.get('login', []))
if mode == 'login':
ret_list += self.command_dict.get('login', [])
return ret_list
ret_list += self.command_nested_dict.get('enable', [])
if mode == 'enable':
ret_list += self.command_dict.get('enable', [])
return ret_list
if mode == 'config':
ret_list += self.command_nested_dict.get('config', [])
ret_list += self.command_dict.get('config', [])
return ret_list
for idx in [x for x in self.command_nested_dict.keys() if mode.startswith(x)]:
ret_list += self.command_nested_dict.get(idx, [])
ret_list += self.command_dict.get(mode, [])
# manage command who's names are regular expressions
result = [x['re'] if type(x) == dict else x for x in ret_list]
return result
#
# --------------------------------------------------------------------------------
# commands_for_current_mode_starting_with
#
def commands_for_current_mode_starting_with(self,
start_text = "", completion = None):
"""
One of the difficult issues here is when the first item
isn't a token, but rather a regular expression. This currently occur
in a few places in the command description, and the mechanism for
dealing with the issue here is ... uhm ... poor. The code here is
a stopgap, and assumes the only regular expression supported
is the <digits> one. This could be make a bit better based on
the submode, but really, this entire first-token management should
be improved.
"""
if completion == None:
completion = False
#
# vns features commands include:
netvirt_feature_commands = ['vns', 'vns-definition']
if onos == 0:
netvirt_feature = self.netvirt_feature_enabled()
else:
netvirt_feature = False
mode_list = self.commands_for_mode(self.current_mode())
ret_list = self.commands_feature_enabled(utif.unique_list_from_list(mode_list))
def prefix(x, start_text, completion):
if type(x) == str and x.lower().startswith(start_text.lower()):
return True
if not completion and type(x) == re._pattern_type:
return x.match(start_text)
return False
def pattern_items(ret_list, prefix):
matches = []
for p in [x for x in ret_list if type(x) == re._pattern_type]:
for c in command.command_registry:
if c['mode'] != self.current_mode():
continue
if type(c['name']) != dict:
continue
first_word = c['name']
if 'completion' not in first_word:
continue
completion = first_word['completion']
if first_word['pattern'] == p.pattern:
result = {}
scopes = [ first_word,
{
'completions' : result,
'data' : {},
'text' : prefix,
},
]
command._call_proc(completion,
command.completion_registry,
scopes, c)
matches = result.keys()
return matches
matches = [x for x in ret_list if prefix(x, start_text, completion)]
if completion:
matches += pattern_items(ret_list, start_text)
return matches
#
# --------------------------------------------------------------------------------
# complete_optional_parameters
#
# Parse optional parameters. These can occur in any order.
# Params argument is a hash mapping a parameter name to type
# information.
# words argument are remaining words in the command
# line that aren't yet parsed
#
def complete_optional_parameters(self, params, words, text):
i = 0
while i < len(words):
final = i+1 >= len(words)
word = words[i]
possible = [x for x in params if x.startswith(word)]
param_name = possible[0]
param = params[param_name]
if (param['type'] != 'flag'):
if (final):
argument = text
if (param['type'] == 'enum'):
return [x
for x in param['values']
if x.startswith(argument)]
elif argument == '':
if ('syntax_help' in param):
self.print_completion_help(param['syntax_help'])
else:
self.print_completion_help('[%s argument]' % word)
return
i += 1
i += 1
return [x for x in params if x.startswith(text)]
#
# --------------------------------------------------------------------------------
# parse_optional_parameters
#
@staticmethod
def parse_optional_parameters(params, words):
parsed = {}
i = 0
while i < len(words):
word = words[i]
possible = [x for x in params if x.startswith(word)]
if len(possible) == 0:
raise ParamException('unknown option: %s' % word)
elif len(possible) > 1:
raise ParamException('ambiguous option: %s\n%s' %
(word, "\n".join(possible)))
else:
param_name = possible[0]
param = params[param_name]
if (param['type'] == 'flag'):
parsed[param_name] = True
else:
if i+1 < len(words):
argument = words[i+1]
if (param['type'] == 'string'):
parsed[param_name] = argument
elif (param['type'] == 'int'):
try:
parsed[param_name] = int(argument)
except ValueError:
raise ParamException('option %s requires ' +
'integer argument'
% word)
elif (param['type'] == 'enum'):
arg_possible = [x
for x in param['values']
if x.startswith(argument)]
if (len(arg_possible) == 0):
raise ParamException('option %s value must be in (%s)' %
(word,", ".join(param['values'])))
elif (len(arg_possible) > 1):
raise ParamException('ambiguous option %s value:\n%s' %
(word, "\n".join(arg_possible)))
else:
parsed[param_name] = arg_possible[0]
i += 1
else:
raise ParamException('option %s requires an argument'
% word)
i += 1
return parsed
#
# --------------------------------------------------------------------------------
# annotated_obj_type_id
#
# Given an id's value for a compound key, crack the value into
# parts, and annotate each part with the compound key name.
#
# For 'Not Found' errors, the obj_type is known, along with the value
# for the id which wasn't found. If this is an id with a compound key,
# leaking information about the key's implementiion should be avoided.
# Here the key's value is cracked based on the composition character,
# and the items are displayed with their key-value name.
# eg: Error: Not Found vns:xXx rule-id:snapple (vns-interface-rule)
#
def annotated_obj_type_id(self, obj_type, error):
key = mi.pk(obj_type)
if mi.is_compound_key(obj_type, key):
result = { key : error}
mi.split_compound_into_dict(obj_type, key, result)
return ', '.join(["%s:%s" % tuple(x) for x in result.items()
if x[0] != key])
return error
#
# --------------------------------------------------------------------------------
#
def find_master(self):
"""
Return a dictionary with two items: 'master', and 'ips'
'master' identifes the ip address of the master, a string
which is an ip address, or None.
'ips' is a list of interface rows with populated ip addresses.
"""
# collect all the controller-interfaces
ips = [x for x in local_interfaces_firewall_open('tcp', [80, 8000], 'all')
if (x['ip'] != '' or x['discovered-ip'] != '')]
master = None
for ip in ips:
if ip['ip'] != '':
url = "http://%s/rest/v1/system/ha/role" % ip['ip']
if ip['discovered-ip'] != '': # select discovered ip over ip
url = "http://%s/rest/v1/system/ha/role" % ip['discovered-ip']
result = self.store.rest_simple_request(url, use_cache = False)
self.check_rest_result(result)
ha_role = json.loads(result)
if ha_role['role'] == 'MASTER':
if ip['ip'] != '':
master = ip['ip']
if ip['discovered-ip'] != '':
master = ip['discovered-ip']
return {'master': master, 'ips': ips}
#
# --------------------------------------------------------------------------------
# rest_error_to_dict
# Turn an exception into an error dictionary, which can later be printed.
# using rest_error_dict_to_message().
#
def rest_error_to_dict(self, e, detail=None):
errors = None
# try to identifify validation requests
if isinstance(e, httplib.BadStatusLine):
errors = {'connection_error' : 'REST API server %s: '
'server not running' %
self.controller}
return errors
elif isinstance(e, urllib2.HTTPError):
code = e.code
error_returned = e.readline()
if code == 404:
if detail:
errors = {'not_found_error' : 'Not Found: %s' % detail}
else:
errors = {'not_found_error' : 'Not Found: %s' % error_returned}
elif code == 500 or code == 403:
# traceback.print_stack()
errors = {'connection_error' : 'REST API server %s failure: %s' %
(self.controller, error_returned)}
elif code == 400:
try:
errors = json.loads(error_returned)
except:
# if the error can't be converted into a dictionary, then imbed the complete
# errors as the value for a specific error key.
errors = {'error_result_error': "Can't convert returned error: %s" % error_returned}
elif code == 301:
errors = {'moved_error': 'HttpError Moved Permanently %s' % e}
elif code == 303:
# Attempt to determine what list of ip addresses is for
# the controller, try to find the Master. if any failure
# occurs anywhere, drop down to a simple error message.
try:
minfo = self.find_master()
ips = [x['ip'] for x in minfo['ips']]
master = minfo['master']
if master:
errors = {'see_other': 'This controller is in SLAVE '
'mode. The command must be run in MASTER mode.'
'\nMASTER at %s' % master}
elif len(ips):
errors = {'see_other': 'This controller is in SLAVE mode. '
'The command must be run in MASTER mode.'
'\nNo MASTER found, possible ip\'s %s' %
(', '.join(ips))}
else:
errors = {'see_other': 'This controller is in SLAVE mode. '
'The command must be run in MASTER mode.'
'\nNo MASTER currently exists '}
except:
errors = {'see_other': 'This controller is in SLAVE mode. '
'The command must be run in MASTER mode.'
'\nNo ip addresses for controller available'}
else:
errors = {'unknown_error': 'HttpError %s' % error_returned}
elif isinstance(e, NotFound):
if e.obj_type in mi.obj_type_info_dict:
errors = {'not_found_error' : 'Not Found: %s (%s)' %
(self.annotated_obj_type_id(e.obj_type,
e.name),
e.obj_type)}
else:
errors = {'not_found_error' : 'Not Found: %s (%s)' %
(e.name, e.obj_type)}
else:
if self.debug or self.debug_backtrace:
traceback.print_stack()
errors = {'unknown_error': "Need error management for error %s" % type(e)}
return errors
#
#
# --------------------------------------------------------------------------------
# rest_error_is_not_found
# Return True if this specific error was the result of a not-found situation
#
@staticmethod
def rest_error_is_not_found(rest_error_dict):
if 'not_found_error' in rest_error_dict:
return True
return False
#
# --------------------------------------------------------------------------------
# rest_error_dict_to_message
# Turn an rest_error_dict returned from rest_error_to_dict
# into an error message which can ge printed. Code assumes multiple errors
# won't occur; if a 'field_error' exists, for example, a 'model_error' won't
# also be posted in the error
#
def rest_error_dict_to_message(self, rest_error_dict):
if rest_error_dict == None:
return rest_error_dict
error_msg = ""
if 'field_errors' in rest_error_dict:
for (k, v) in rest_error_dict['field_errors'].items():
error_msg += "Syntax error: field %s: %s" % (k, v)
# traceback.print_stack(), to find out why the error occured
elif 'model_error' in rest_error_dict:
error_msg += "%s" % rest_error_dict['model_error']
elif 'not_found_error' in rest_error_dict:
error_msg += "Error: %s" % rest_error_dict['not_found_error']
elif 'connection_error' in rest_error_dict:
error_msg += rest_error_dict['connection_error']
elif 'error_result_error' in rest_error_dict:
error_msg += rest_error_dict['error_result_error']
elif 'moved_error' in rest_error_dict:
error_msg += rest_error_dict['moved_error']
elif 'see_other' in rest_error_dict:
error_msg += rest_error_dict['see_other']
elif 'unknown_error' in rest_error_dict:
error_msg += rest_error_dict['unknown_error']
elif 'description' in rest_error_dict and \
rest_error_dict["description"] == 'saved':
# not an error: { 'description' : 'saved' }
return None
elif 'error_type' in rest_error_dict: # http 400 errors
description = rest_error_dict['description']
if description.startswith('Error: '):
description = description[len('Error: '):]
return '%s (%s)' % (description,
rest_error_dict['error_type'])
else:
error_msg = "REST API server on controller-node %s " % self.controller
error_msg += "had %s error:\n" % rest_error_dict['error_type']
error_msg += rest_error_dict['description']
return error_msg
#
# --------------------------------------------------------------------------------
#
# Commands of the CLI. A command "foo" should have two methods:
# cp_foo(self, text, state) - completion for this command, return list of options
# do_foo(self, line) - execute the command
#
# Given a string 'word', not containing any spaces, nor any break
# characters associated with python, return the a invocable method
# note that '-' are permitted, and converted to '_''s
#
# When in the vns or vns-definition mode, the selected functions
# to call back have an additional component added to the called
# back function. In the non-vns case, for example, the "show"
# command would result in a method called do_show, while in the
# vns modes, 'vns_' in inserted between the 'verb' and the noun,
# for example, resulting in 'do_vns_show'
#
# --------------------------------------------------------------------------------
# method_from_name
#
def method_from_name(self, prefix, name):
if type(name) != str:
return None
if self.in_config_submode("config-vns") and \
getattr(self, prefix + "vns_" + name.replace("-","_"), None):
return getattr(self, prefix + "vns_" + name.replace("-","_"))
return getattr(self, prefix+name.replace("-","_"), None)
#
# --------------------------------------------------------------------------------
# command_method_from_name
#
def command_method_from_name(self, name):
return self.method_from_name("do_", name) # do_XXX methods
#
# --------------------------------------------------------------------------------
# command_show_method_from_name
#
def command_show_method_from_name(self, name):
return self.method_from_name("do_show_", name) # do_show_XXX methods
#
# --------------------------------------------------------------------------------
# cloud_method_from_name
#
def cloud_method_from_name(self, name):
return self.method_from_name("cloud_", name) # cloud_XXX methods
#
# --------------------------------------------------------------------------------
# completion_method_from_name
#
def completion_method_from_name(self, name):
return self.method_from_name("cp_", name) # cp_XXX (completion) methods
#
# --------------------------------------------------------------------------------
# completion_show_method_from_name
#
def completion_show_method_from_name(self, name):
return self.method_from_name("cp_show_", name) # cp_show_XXX (completion) methods
#
# --------------------------------------------------------------------------------
# unique_key_from_non_unique
#
# Primary keys for cassandra for some keys are contenations of
# several non-unique keys separated by a character not used for
# any other purpose (in this case '|'). The concatenation
# of non-unique keys is intended to create a unique key.
#
def unique_key_from_non_unique(self, words):
return "|".join(words)
#
# --------------------------------------------------------------------------------
# prefix_search_key
# Prefix's of primary keys for keys's built through unique_key_from_non_unique()
#
def prefix_search_key(self, words):
return self.unique_key_from_non_unique(words) + "|"
#
# --------------------------------------------------------------------------------
# implement_connect
#
def implement_connect(self, data):
new_ip = data.get('ip-address')
if new_ip == None:
new_ip = data.get('controller-id')
if not self.IP_ADDR_RE.match(new_ip):
controller_id = alias_lookup('controller-alias', new_ip)
if controller_id == None:
controller_id = new_ip
try:
ifs = self.rest_query_objects('controller-interface',
{ 'controller' : controller_id } )
if len(ifs) == 1:
new_ip = ifs[0]['ip']
except:
return self.error_msg('Can\'t find controller named %s' % new_ip)
pass
if 'port' in data:
new_ip += str(data['port'])
else:
new_ip += ":80"
#
# request the version, if it fails, then don't allow the switch
try:
version_url = 'http://%s/rest/v1/system/version' % new_ip
data = self.rest_simple_request_to_dict(version_url)
except Exception, e:
return self.error_msg('Could not connect to %s' % new_ip)
self.controller = new_ip
self.store.set_controller(new_ip)
self.set_controller_for_prompt()
while (self.current_mode() != "login"):
self.pop_mode()
print "Switching to controller %s" % self.controller
return self.pp.format_entry(data[0], 'version')
def cp_exit(self, words, text, completion_char):
self.print_completion_help("<cr>")
def do_exit(self, words=None):
if self.mode_stack[-1]['exit']:
method = self.mode_stack[-1]['exit']
method()
self.pop_mode()
def cp_logout(self, words, text, completion_char):
self.print_completion_help("<cr>")
def do_logout(self, words=None):
self.run = False
def cp_end(self, words, text, completion_char):
self.print_completion_help("<cr>")
def do_end(self, words=None):
while self.current_mode().startswith("config"):
self.pop_mode()
#
# --------------------------------------------------------------------------------
# do_show_tunnel
# Command descriptions has no practical support for show commands yet.
#
def do_show_tunnel(self, words):
if len(words) < 2:
print self.syntax_msg("Usage: show tunnel [ <switch> | all ] active")
return
if words[1] != "active":
return self.error_msg("Unknown request %s" % words[1])
# active --
if words[0] != 'all':
words[0] = convert_alias_to_object_key("switch", words[0])
try:
data = self.rest_simple_request_to_dict(
'http://%s/rest/v1/tunnel-manager/%s/' %
(self.controller, words[0]))
except:
return self.error_msg('Could not load tunnel-manager details')
if 'error' in data and data['error'] != None:
return self.error_msg('tunnel-manager response: %s' % data['error'])
entries = []
for entry in data['tunnMap'].keys():
item = data['tunnMap'][entry]
for remote in item['tunnelPorts']:
remoteIp = "%s.%s.%s.%s" % ( int(remote[3:6]),
int(remote[6:9]),
int(remote[9:12]),
int(remote[12:]))
entries.append({ 'dpid': entry,
'localTunnelIPAddr' : item['localTunnelIPAddr'],
'tunnelPorts' : remoteIp
})
return self.display_obj_type_rows('tunnel-details', entries)
#
# --------------------------------------------------------------------------------
# cp_show_vns_access_list_entry
#
def cp_show_vns_access_list_entry(self, words, text, completion_char):
return self.cp_vns_access_list_entry(words, text)
#
# --------------------------------------------------------------------------------
# do_show_vns_access_list_entry
#
def do_show_vns_access_list_entry(self, words):
with_search_key = "<no_key>"
if self.vns_name() is None:
if len(words) > 0:
search_object = ["vns-access-list-entry", words[0]]
else:
search_object = ["vns-access-list-entry"]
elif len(words) > 0:
with_search_key = '-'.join(words)
words.insert(0, self.get_current_mode_obj())
search_object = ["vns-access-list-entry",
self.unique_key_from_non_unique(words)]
else:
search_object = ["vns-access-list-entry",
self.prefix_search_key([self.get_current_mode_obj()])]
return self.do_show_object(search_object, with_search_key)
#
# --------------------------------------------------------------------------------
# do_vns_no
# implement the no command while in the context of vns/vns-definition
#
def do_vns_no(self, words):
if len(words) < 1:
return "Syntax: no <item> <key> : delete from the named item the specific key"
else:
vns_name_to_table_name = { "interfaces" : "vns-interface",
"interface-rule" : "vns-interface-rule",
"access-list" : "vns-access-list",
"access-list-entry" : "vns-access-list-entry",
"access-group" : "vns-interface-access-list",
}
if words[0] in vns_name_to_table_name:
if len(words) < 2:
return "Syntax: no %s <item> <key>" % words[0]
#
# the item to remove in for access-list-entry is an integer,
# canonicalize the name before its used to search
if words[0] == 'access-list-entry':
if self.ACL_RE.match(words[1]):
words[1] = str(int(words[1]))
else:
return self.error_msg('%s key %s must be an integer' %
(words[0], words[1]))
name = self.unique_key_from_non_unique([self.get_current_mode_obj(), words[1]])
table = vns_name_to_table_name[words[0]]
errors = None
if words[0] == "entry" and not self.in_config_vns_acl_mode():
return self.do_no(words) # let do_no() print error messages
elif words[0] == "access-group" and not self.in_config_vns_if_mode():
return self.do_no(words) # let do_no() print error messages
# access-group/vns-interface-access-list has 'id's with an additional field,
# the in-out parameter, which is required to be able to delete the entry
if words[0] == "access-group":
if len(words) < 3:
return self.syntax_msg('no access-group <acl-name> <in|out>')
choices = [x for x in ["in", "out"] if x.startswith(words[2])]
if len(choices) != 1:
return self.syntax_msg('no access-group <acl-name> <in|out>')
name = self.unique_key_from_non_unique([self.get_current_mode_obj(),
self.vns_name(),
words[1]])
name = name + "|" + choices[0]
try:
self.rest_delete_object(table, name)
except Exception, e:
errors = self.rest_error_to_dict(e, words[0] + " " + words[1])
if errors:
return self.rest_error_dict_to_message(errors)
#
# cascade delete?
if not errors:
self.cascade_delete(table, name)
return None
return self.do_no(words)
#
# --------------------------------------------------------------------------------
# do_no_tag
# Since the name and value must be present, this is currently a special
# case. additionally, the two tables 'tag-mapping' and 'tag' are
# intermingled. the 'tag' table manages the <namespace><name><value>
# tuple, while the tag-mapping add <host> to that relationship When
# the removal of the entry from the tag-mapping table leaves no further
# <namespace><name><value>'s for any hosts, then the row from the
# 'tag' table must be removed
#
def implement_no_tag(self, words):
if not words or len(words) != 2 or words[1].find('=') == -1:
return "Syntax: no tag <namespace.name>=<value>"
else:
name_and_value = words[1].split("=")
if len(name_and_value) > 2:
return "Syntax: no tag <namespace.name>=<value>"
name_part = name_and_value[0].split('.')
if len(name_part) == 1:
namespace = 'default'
name = name_part[0]
elif len(name_part) >= 2:
namespace = '.'.join(name_part[:-1])
name = name_part[-1]
value = name_and_value[1]
item = self.unique_key_from_non_unique([namespace,
name,
value,
self.get_current_mode_obj()])
#
# To prevent leaking the unique key value in the 'Not Found'
# error message, look up the item first, and display a unique
# error message for this case
#
errors = None
try:
self.get_object_from_store('tag-mapping', item)
except Exception, e:
errors = self.rest_error_to_dict(e, "tag " + item)
if errors:
if self.rest_error_is_not_found(errors):
return self.error_msg("tag %s.%s=%s not found" %
(namespace, name, value))
else:
return self.rest_error_dict_to_message(errors)
try:
self.rest_delete_object('tag-mapping', item)
except Exception, e:
errors = self.rest_error_to_dict(e, "tag " + item)
if errors:
return self.rest_error_dict_to_message(errors)
#
# if there are no more items in tag-mapping for the
# <namespace>|<name>|<value>, then an entry needs to
# removed from the 'tag' table (for cleanup)
#
key = self.unique_key_from_non_unique([namespace,
name,
value])
try:
tags = self.get_table_from_store('tag-mapping', 'tag', key)
except Exception, e:
errors = self.rest_error_to_dict(e, "tag-mapping tag " + key)
if errors:
print self.rest_error_dict_to_message(errors)
return
if len(tags) == 0:
try:
self.rest_delete_object('tag', key)
except Exception, e:
errors = self.rest_error_to_dict(e, "tag " + item)
if errors:
print self.rest_error_dict_to_message(errors)
return
#
# cascade delete?
#
# --------------------------------------------------------------------------------
# vns_interface_rule_tags_validate
# Provides a warning when the associated tag doesn't exist
#
def vns_interface_rule_tags_validate(self, obj_type, field, value):
for tag_pair in value.split(','):
if tag_pair.find('=') == -1 or len(tag_pair.split('=')) != 2:
# field validation won't match the regular expression
return
(tag_name, tag_value) = tag_pair.split('=')
tag_name_parts = tag_name.split('.')
if len(tag_name_parts) == 1:
tag_namespace = 'default'
tag_name = tag_name_parts[0]
elif len(tag_name_parts) >= 2:
tag_namespace = '.'.join(tag_name_parts[:-1])
tag_name = tag_name_parts[-1]
else:
# XXX not reached
pass
# Validating using the 'tag' model to determine whether the
# tag exists depends on having the tag value removed when there's
# no more references to the entry. the cli manages the
# 'tag'/'tag-mapping' models that way, but other uses of the
# rest api may not.
#
key = self.unique_key_from_non_unique([tag_namespace, tag_name, tag_value])
try:
table = self.get_object_from_store('tag', key)
except Exception, e:
errors = self.rest_error_to_dict(e, 'tag')
# special case for 'not found' error message
if self.rest_error_is_not_found(errors):
self.warning("tag `%s.%s %s' not yet defined" % \
(tag_namespace, tag_name, tag_value))
else:
print self.rest_error_dict_to_message(errors)
return None
#
# --------------------------------------------------------------------------------
# validate_switch_core_switch
# Intended to display a warning message when the value is set to True
#
def validate_switch_core_switch(self, obj_type, field, value):
if value == 'True': # XXX odd that the value needs to be quoted.
self.warning("enabling core-switch on a switch with "
"directly connected hosts will cause the same to "
"be unable to connect")
#
# --------------------------------------------------------------------------------
# handle_specific_tag_fields
# Called by handle_specific_obj_type to convert fields values from the
# rest api into a displayable table
#
@staticmethod
def handle_specific_tag_fields(entries):
for entry in entries:
fields = entry['id'].split('|')
# XXX error if there's not four parts
entry['namespace'] = fields[0]
entry['name'] = fields[1]
entry['value'] = fields[2]
#
# --------------------------------------------------------------------------------
# append_when_missing
#
@staticmethod
def append_when_missing(unique_list, item):
if not item in unique_list:
unique_list.append(item)
#
# --------------------------------------------------------------------------------
# show_command_prefix_matches
# show command's prefix matches, return True when the command matches
# fpr the prefix described, used by get_valid_show_options() during
# cp_show() to collect available command choice.
#
def show_command_prefix_matches(self, command, prefix):
# convert any '-'s in the prefix tp "_"'s since func's have _ separators
prefix = prefix.replace("-", "_")
if command.startswith("do_show_"+prefix) and not command.startswith("do_show_vns_"):
return True
elif command.startswith("do_show_vns_" + prefix):
if self.in_config_submode("config-vns"):
if command == 'do_show_vns_access_list' and self.in_config_vns_mode():
return True
return self.vns_debug_show_commands(command)
return False
return False
#
# --------------------------------------------------------------------------------
# get_valid_show_options
# used by cp_show to identify completion optinos
#
# returns a dictionary with two elements: 'commands', and 'objects'.
# the 'commands' element is a list of possible commands while
# the 'objects' element is a list of possible objects (tables/models in the store)
#
def get_valid_show_options(self, text):
ret_hash = {}
# first get commands
opts = []
matching_methods = [x for x in dir(self)
if self.show_command_prefix_matches(x, text)]
if onos == 0:
netvirt_feature = self.netvirt_feature_enabled()
else:
netvirt_feature = False
for method in matching_methods:
m = re.search("do_show_(.*)", method)
n = re.search("do_show_vns_(.*)", method)
if n and self.in_config_submode('config-vns'):
self.append_when_missing(opts, n.group(1).replace("_","-"))
elif m:
if netvirt_feature or m.group(1) != 'vns':
self.append_when_missing(opts, m.group(1).replace("_","-"))
#
# remove command cases
opts = [x for x in opts if x not in ["statistics", "object"]]
if "access-group" in opts and not self.in_config_vns_if_mode():
if not self.vns_debug_show_commands('vns-access-group'):
opts.remove("access-group")
if "access-list" in opts and not self.in_config_vns_mode():
if not self.vns_debug_show_commands('vns-access-list'):
opts.remove("access-list")
if "interface" in opts and not self.in_config_vns_mode():
if not self.vns_debug_show_commands('vns-interface'):
opts.remove("interface")
if "interface-rule" in opts and not self.in_config_vns_def_mode():
if not self.vns_debug_show_commands('vns-interface-rule'):
opts.remove("interface-rule")
if "firewall" in opts and not self.in_config_controller_interface_mode():
opts.remove("firewall")
# synthetic object type based on the vnsconfig submode.
if "access-list-entry" in opts and not self.in_config_vns_acl_mode():
if not self.vns_debug_show_commands('vns-access-list-entry'):
opts.remove("access-list-entry")
ret_hash["commands"] = opts
# now get obj_types we can show
opts = self.all_obj_types_starting_with(text)
if self.in_config_submode() and "this".startswith(text):
opts.append("this")
ret_hash["objects"] = opts
return ret_hash
#
# --------------------------------------------------------------------------------
# cp_show_object
# show <obj_type> (words[0] == obj_type)
#
def cp_show_object(self, words, text, completion_char):
if len(words) == 1:
return objects_starting_with(words[0], text)
else:
self.print_completion_help("<cr>")
#
# --------------------------------------------------------------------------------
# get_attachment_points
#
@staticmethod
def get_attachment_points(host, host_dap_dict):
items = host_dap_dict.get(host['mac'])
if not items or len(items) <= 1:
return items
#
# sort by most recent items, if the last-seen field
# exists for all entries
#
for item in items:
if not 'last-seen' in item or item['last-seen'] == '':
return items
ordered = sorted(items,
key=lambda i: i['last-seen'],
cmp=lambda x,y: cmp(y,x))
ordered[0]['prime'] = True
return ordered
#
# --------------------------------------------------------------------------------
# create_attachment_dict
#
def create_attachment_dict(self):
return create_obj_type_dict('host-attachment-point', 'mac')
#
# --------------------------------------------------------------------------------
# get_ip_addresses
#
@staticmethod
def get_ip_addresses(host, host_ip_dict):
items = host_ip_dict.get(host['mac'])
if not items or len(items) <= 1:
return items
for item in items:
if not 'last-seen' in item or item['last-seen'] == '':
return items
#
# sort by most recent items, if every row has a 'last-seen' field
#
ordered = sorted(items,
key=lambda i: i['last-seen'],
cmp=lambda x,y: cmp(y,x))
ordered[0]['prime'] = True
return ordered
#
# --------------------------------------------------------------------------------
# create_ip_dict
# Returns a dictionary with the host id (mac address) as the key,
# and a list of associated rows for that host id.
#
def create_ip_dict(self):
return create_obj_type_dict('host-network-address', 'mac')
#
# --------------------------------------------------------------------------------
# show_sort_obj_type
# Returns a sorted list of entries based on the sort described by
# the obj-dict
#
def show_sort_obj_type(self, obj_type, entries):
sort = mi.obj_type_show_sort(obj_type)
if not sort:
return entries
if sort == 'integer':
key = mi.pk(obj_type)
return sorted(entries, key=lambda k: k[key].split('|')[-1],
cmp=lambda x,y: cmp(utif.try_int(x), utif.try_int(y)))
elif sort == 'tail-integer':
key = mi.pk(obj_type)
def comparer(left, right):
prefix = cmp(left[:-1], right[:-1])
if prefix != 0:
return prefix
return cmp(utif.try_int(left[-1]), utif.try_int(right[-1]))
return sorted(entries, key=lambda k: k[key].split('|'), cmp=comparer)
else:
return self.error_msg("Unknown sort %s" % sort)
#
# --------------------------------------------------------------------------------
# display_obj_type_rows
# Given an obj_type, rows, and whether or not a key was provided to search
# with, generate the output table.
#
def display_obj_type_rows(self, obj_type, rows, with_key = '<no_key>', detail = "default"):
#
# handle spedicific issues with particular tables returned from storage
# - change vns-id's with "|" into separate columns
# - the host case does a 'merge' for attachment-points and IPs
# (used in 'show host')
def handle_specific_obj_type(obj_type, entries, field_orderings = 'default'):
if obj_type == "host":
# host_tag_dict = create_obj_type_dict('tag-mapping', 'host')
for host in entries:
host['vendor'] = self.vendordb.get_vendor(host['mac'])
# host['tag'] = host_tag_dict.get(host['mac'], [])
if obj_type == "host-config":
host_dap_dict = self.create_attachment_dict()
host_ip_dict = self.create_ip_dict()
host_tag_dict = create_obj_type_dict('tag-mapping', 'mac')
for host in entries:
host['vendor'] = self.vendordb.get_vendor(host['mac'])
host['attachment-points'] = self.get_attachment_points(host, host_dap_dict)
host['ips'] = self.get_ip_addresses(host, host_ip_dict)
host['tag'] = host_tag_dict.get(host['mac'], [])
if obj_type == 'controller-node':
for controller_node in entries:
domain_name_servers = []
domain_name_servers = self.rest_query_objects(
'controller-domain-name-server',
{'controller': controller_node['id'],
'orderby' : 'timestamp'})
controller_node['domain-name-servers'] = [domain_name_server['ip']
for domain_name_server in domain_name_servers]
controller_node['id'] = ' '.join(controller_node['id'].split('|'))
if obj_type == 'controller-interface':
for intf in entries:
rules = [x['rule'] for x in self.get_firewall_rules(intf['id'])]
intf['firewall'] = ', '.join(rules)
# del intf['id'] XXX should the id really get displayed?
tables_with_vns_ids = [ "vns-interface-rule", "vns-interface",
"host-vns-interface", "vns-access-list",
"vns-access-list-entry", "vns-interface-access-list" ]
if obj_type in tables_with_vns_ids:
self.vns_table_id_to_vns_column(obj_type, entries)
if self.in_config_submode("config-vns") and field_orderings == 'default':
field_orderings = 'vns-config'
self.vns_join_host_fields(obj_type, entries)
self.vns_foreign_key_to_base_name(obj_type, entries)
if obj_type == 'vns-access-list-entry':
# display the alternative access-list-text format
vns_acl_entries_to_brief(entries)
# field_orderings = 'acl-brief'
if obj_type == 'vns-access-list-entry-brief':
# display the alternative access-list-text format
vns_acl_entries_to_brief(entries)
field_orderings = 'acl-brief'
#if obj_type == 'tag-mapping':
#self.handle_specific_tag_fields(entries)
# XXX may need to revisit to prevent don't leak vns information
if obj_type in ['dvs-port-group', 'firewall-rule', 'tag-mapping']:
for entry in entries:
mi.split_compound_into_dict(obj_type,
mi.pk(obj_type),
entry)
#
# objects where foreigh keys are references to
# compount key's, needing to be split.
# XXX these can be identified by scanning the objects during init
if obj_type in ['switch-interface-alias',
]:
# only pick foreign keys which are compound keys
fks = [x for x in mi.obj_type_foreign_keys(obj_type)
if mi.is_compound_key(obj_type,x)]
for entry in entries:
for fk in fks:
if fk in entry: # fk may be null-able
mi.split_compound_into_dict(obj_type, fk, entry)
if 'switch-interface' in entry:
si = entry['switch-interface']
#
if obj_type == 'firewall-rule':
self.firewall_rule_add_rule_to_entries(entries)
return field_orderings
field_orderings = handle_specific_obj_type(obj_type, rows, detail)
#
# join alias names. there is a good chance the alias's tables
# are small. since iteration over all the rows is needed,
# first identify the alias tables involved, then snap the
# complete table into memory, and then decorae with the
# specific alias fields. XXX it would be even better to
# get a size of 'rows' vs the 'alias' table, and choose
# the more performance path...
#
if obj_type in mi.alias_obj_type_xref:
obj_key = mi.pk(obj_type)
for alias in mi.alias_obj_type_xref[obj_type]:
alias_field = mi.alias_obj_type_field(alias)
if not alias_field:
print self.error_msg("internal alias in display_obj_type")
try:
alias_rows = self.get_table_from_store(alias)
except Exception, e:
errors = self.rest_error_to_dict(e, alias)
print self.rest_error_dict_to_message(errors)
alias_rows = []
# invert the row once, moving the key to the data.
alias_key = mi.pk(alias)
rows_alias = dict([[a[alias_field], a[alias_key]] for a in alias_rows])
# collect the name of the field to join (fk_name)
#
(fk_obj_type, fk_name) = \
mi.foreign_key_references(alias, alias_field)
# now associate alias's with the row's field:
for row in rows:
if fk_name in row:
if row[fk_name] in rows_alias:
row[alias] = rows_alias[row[fk_name]]
elif fk_obj_type in row:
if row[fk_obj_type] in rows_alias:
row[alias] = rows_alias[row[fk_obj_type]]
#
# this choice is better if the alias's table is large.
if 0: #for row in rows:
key = mi.pk(obj_type)
for alias in mi.alias_obj_type_xref[obj_type]:
field = mi.alias_obj_type_field(alias)
if not field:
print self.error_msg("internal alias in display_obj_type")
alias_row = self.get_table_from_store(alias,
field,
row[key],
"exact")
if len(alias_row) > 1:
print 'Error: multiple aliases for %s' % \
alias
elif len(alias_row) == 1:
row[alias] = alias_row[0][mi.pk(alias)]
if len(rows) == 0:
if with_key != '<no_key>':
return self.error_msg("No %s %s found" % (obj_type, with_key))
else:
return self.pp.format_table(rows, obj_type, field_orderings)
elif len(rows) == 1 and with_key != '<no_key>':
return self.pp.format_entry(rows[0], obj_type,
debug = self.debug)
return self.pp.format_table(self.show_sort_obj_type(obj_type, rows),
obj_type,
field_orderings)
#
# --------------------------------------------------------------------------------
# do_show_object
# Implements the show command for objects (table/model output of rows)
#
def do_show_object(self, words, with_search_key = None):
obj_type = words[0]
#
# The cli replaces some user names with table names
if obj_type == 'tag':
obj_type = 'tag-mapping'
match = "startswith"
#
# Allow "this" reference if we are in config-submode, change the
# match to an exact match to prevent prefix matching
if obj_type == "this":
if self.in_config_submode():
obj_type = self.get_current_mode_obj_type()
words = [obj_type, "this"]
match = "exact"
else:
return self.error_msg("\"this\" can only be used in configuration"
" submode, such as switch, port, host, etc.")
#
# complete table lookup: 'show <table>'
if len(words) == 1:
if with_search_key == None:
with_search_key = "<no_key>"
errors = None
try:
entries = self.get_table_from_store(obj_type)
except Exception, e:
errors = self.rest_error_to_dict(e, obj_type)
if errors:
return self.rest_error_dict_to_message(errors)
return self.display_obj_type_rows(obj_type, entries, with_search_key)
# table with key: "show <table> <key>"
if len(words) == 2:
obj = words[1]
if with_search_key == None:
with_search_key = obj
# Allow "this" reference if we are in config-submode
if obj == "this" and \
obj_type == self.get_current_mode_obj_type() \
and self.in_config_submode():
obj = self.get_current_mode_obj()
key = mi.pk(obj_type)
if key:
obj = convert_alias_to_object_key(obj_type, obj)
if mi.obj_type_has_model(obj_type):
entries = self.get_table_from_store(obj_type, key, obj, match)
else:
# XXX raise internal error? model doesn't exist.
print command._line(), obj_type
entries = []
return self.display_obj_type_rows(obj_type, entries, with_search_key)
else:
return self.pp.format_table(self.get_table_from_store(obj_type),
obj_type)
elif "stats".startswith(words[2]):
return self.helper_show_object_stats(words)
else:
return "Syntax: show <table> <key>: " \
"Unrecognized input: " + " ".join(words[2:])
#
# --------------------------------------------------------------------------------
# helper_show_object_stats
#
def helper_show_object_stats(self, words):
if self.stats_metadata == None:
self.init_stats_metadata()
# get object type
object_type = words[0]
# The rest stats api differs from the CLI in some of the
# object names, so this map allows us to fix it
if object_type in self.stats_restapi_map:
object_type = self.stats_restapi_map[object_type]
if object_type not in self.stats_type_metadata:
return self.error_msg('no statistics available for object type %s' %
object_type)
# Get the specific object to operate on
sobject = words[1];
# the controller-node objects don't currently have any real
# concept of a unique ID for a controller; for now the stats
# are always labeled 'localhost' even though that will never
# appear in the controller-node list
if ('controller-node'.startswith(object_type)):
sobject = 'localhost'
tocheck = []
# get statistic name
if len(words) > 3:
if (words[3] not in self.stats_metadata or
self.stats_metadata[words[3]]['target_type'] != object_type):
return self.error_msg('no statistic %s available for object type %s' %
(words[3], object_type))
tocheck.append(words[3])
else:
tocheck = [item['name']
for item in self.stats_type_metadata[object_type]]
parsed_options = {}
if (len(words) > 4):
try:
parsed_options = \
self.parse_optional_parameters(self.stats_optional_params,
words[4:])
except ParamException as e:
return self.error_msg(e)
display = 'latest-value'
timespec = False
now = int(time.time()*1000)
query_params = {'start-time': now - 3600000,
'end-time': now,
'sample-count': 25,
'data-format': 'value'}
if 'start-time' in parsed_options:
timespec = True
try:
query_params['start-time'] = self.parse_date(parsed_options['start-time'])
except Exception as e:
return self.error_msg('invalid start time %s: %s' %
(parsed_options['start-time'], e))
if 'end-time' in parsed_options:
timespec = True
try:
query_params['end-time'] = self.parse_date(parsed_options['end-time'])
except Exception as e:
return self.error_msg('invalid end time %s: %s' %
(parsed_options['end-time'], e))
if 'duration' in parsed_options:
timespec = True
try:
query_params['duration'] = parsed_options['duration']
if 'start-time' in parsed_options:
del query_params['end-time']
else:
del query_params['start-time']
except:
return self.error_msg('invalid duration %s' %
parsed_options['duration'])
if 'display' in parsed_options:
display = parsed_options['display']
if timespec and display == 'latest-value':
display = 'graph'
if display == 'graph':
query_params['sample-count'] = self.pp.get_terminal_size()[0]
for p in ['sample-count', 'limit', 'sample-window',
'sample-interval', 'data-format']:
if p in parsed_options:
query_params[p] = parsed_options[p]
if display == 'latest-value':
data = {}
for item in tocheck:
url = ('http://%s/rest/v1/stats/data/%s/%s/%s/%s/' %
(self.controller, self.cluster, object_type,
sobject, item))
try:
(timestamp, value) = self.rest_simple_request_to_dict(url)
data[self.stats_metadata[item]['name']] = "%d" % value
except:
data[self.stats_metadata[item]['name']] = "[Null]"
return self.pp.format_entry(data, 'stats-%s' % object_type)
else:
item = tocheck[0]
url = ('http://%s/rest/v1/stats/data/%s/%s/%s/%s/?%s' %
(self.controller, self.cluster, object_type,
sobject, item, "&".join(['%s=%s' % (k,v)
for k,v
in query_params.iteritems()])))
try:
json_data = self.rest_simple_request_to_dict(url)
except Exception as e:
if self.debug_backtrace:
print 'FAILED URL', url
return self.error_msg('could not load stats data: %s' % e)
if display == 'table':
data = []
for (timestamp, value) in json_data:
data.append({'timestamp': int(timestamp),
'value': value})
return self.pp.format_table(data, 'stats-%s-%s-%s' %
(object_type, item,
query_params['data-format']))
elif display == 'graph':
return self.pp.format_time_series_graph(json_data,
'stats-%s-%s-%s' %
(object_type, item,
query_params['data-format']))
#
# --------------------------------------------------------------------------------
# parse_date
#
@staticmethod
def parse_date(text):
if (text == 'now' or text == 'current'):
return int(time.time()*1000)
try:
return int(text)
except:
pass
for f, pre in [('%Y-%m-%dT%H:%M:%S', None),
('%Y-%m-%d %H:%M:%S', None),
('%Y-%m-%dT%H:%M:%S%z', None),
('%Y-%m-%d %H:%M:%S%z', None),
('%Y-%m-%d', None),
('%m-%d', '%Y-'),
('%H:%M', '%Y-%m-%dT')]:
try:
t = text
if pre:
pref = datetime.datetime.now().strftime(pre)
f = pre + f
t = pref + t
thetime = datetime.datetime.strptime(t, f)
return int(time.mktime(thetime.timetuple())*1000)
except:
pass
raise ValueError('count not parse %s as a timestamp' % text)
#
# --------------------------------------------------------------------------------
# display_vns_interface
# Search dist is a collection of compund key entities
#
def display_vns_interface(self, vns_name, search_dict, with_search_key, detail = 'default'):
obj_type = 'vns-interface'
obj_key = mi.pk(obj_type)
try:
entries = rest_to_model.get_model_from_url(obj_type, search_dict)
#entries = self.rest_query_objects(obj_type,
#search_dict)
errors = None
except Exception, e:
errors = self.rest_error_to_dict(e, obj_type)
if errors:
return self.rest_error_dict_to_message(errors)
vns_rules = create_obj_type_dict('vns-interface-rule',
mi.pk('vns-interface-rule'),
search_dict
)
#
# divide up the result into two parts, the first part is
# the physical interfaces, the second is the mac interfaces...
phys = []
macs = []
for entry in entries:
fields = entry[obj_key].split('|')
entry['tenant'] = fields[0]
entry['vns']=fields[1]
# all these fields must have two parts.
if len(fields) != 3:
continue
# choose between switch based rules and mac/ip based rules
rule = 'default'
switch = None
virt = None
#
# Each address-space would have a default vns named
# named <as>-default, except the 'default' adddress-space which
# has a default vns named just 'default'
#
if fields[1] == "default" or fields[1].endswith("-default"):
virt = 'default'
if fields[2].find('/') >= 0:
virt = fields[2].split('/')[1]
else:
if not 'rule' in entry or entry['rule']=='default':
if_rule = []
virt = True
# continue
else:
rule = entry['rule']
if_rule = vns_rules[rule][0]
if 'switch' in if_rule:
switch = if_rule['switch']
elif 'mac' in if_rule:
virt = if_rule['mac']
entry['mac'] = virt
elif 'ip-subnet' in if_rule:
virt = {'ip-address': if_rule['ip-subnet']}
if 'ips' in entry:
entry['ips'].append(virt)
else:
entry['ips'] = [virt]
elif 'tags' in if_rule:
virt = if_rule['tags']
entry['tags'] = virt
elif 'vlans' in if_rule:
virt = "vlan %s" % if_rule['vlans']
entry['vlans'] = virt
if switch:
phys.append(entry)
if virt:
entry['veth'] = entry[obj_key].split('|')[2]
macs.append(entry)
output = ''
if len(phys):
self.vns_join_switch_fields(vns_name, phys)
output += self.display_obj_type_rows('vns-interface-phys', phys, with_search_key, detail)
if len(macs):
if len(phys):
output += '\n'
self.vns_join_host_fields(obj_type, macs)
output += self.display_obj_type_rows('vns-interface-macs', macs, with_search_key, detail)
if output != '':
return output
return self.pp.format_table([],'display-vns-interface')
#
# --------------------------------------------------------------------------------
# find_and_display_vns_interfaces
#
def find_and_display_vns_interface(self, vns_name, words):
with_search_key = "<no_key>"
search_dict = { 'vns' : vns_name }
if len(words) == 1:
search_dict['interface'] = words[0]
elif len(words) > 1:
return self.error_msg("Additional search keys after interace")
return self.display_vns_interface(vns_name, search_dict, with_search_key)
#
# --------------------------------------------------------------------------------
# do_show_vns_interfaces
# This definition is needed to allow the vns-interface table/model to
# be displayed in basic config mode. do_show() searches names of functions
# using the prefix of the 'show' argument; without this function,
# it find 'do_show_vns_interface_rule' and selects that function to
# display results for 'show vns-interface`.
#
def do_show_vns_interfaces(self, words):
with_search_key = "<no_key>"
local_vns_name = self.vns_name()
if self.vns_name() is None:
if len(words) > 0:
local_vns_name = words[0]
search_dict = { 'vns' : local_vns_name }
else:
# only case where the vns name is included is the output
return self.do_show_object(['vns-interface'], with_search_key)
else:
search_dict = { 'vns' : local_vns_name }
if len(words) == 1:
with_search_key = words
search_dict['interface'] = words[0]
elif len(words) > 2:
return self.error_msg("Additional search keys after interace")
return self.display_vns_interface(local_vns_name, search_dict, with_search_key)
#
# --------------------------------------------------------------------------------
# display_vns_mac_address_table
# Used by 'show vns <n> mac-address-table', and vns mode 'show mac-address-table'
#
def display_vns_mac_address_table(self, vns_name, words):
# note: 'config-vns' matches both vns and vns-definition mode,
# while 'config-vns-' matches only vns-definition mode.
# the id for the host-vns-interface table has the host as the 'prefix',
# preventing searching based on the prefix. the vns is not even a foreign
# key, which means the complete table must be read, then the vns association
# must be determined, and then matched
filter = { 'vns' : vns_name } if vns_name != 'all' else {}
if len(words):
filter['mac'] = words[0]
entries = rest_to_model.get_model_from_url('host-vns-interface', filter)
for entry in entries:
fields=entry['vns'].split('|')
entry['tenant']=fields[0]
entry['vns']=fields[1]
with_key = '<no_key>'
if len(words) > 0:
with_key = words[0]
#detail = 'vns' # exclude vns column, vns is named
detail = 'default' # exclude vns column, vns is named
if vns_name == 'all':
detail = 'default' # include vns column, vns not named
# self.vns_join_host_fields('host-vns-interface', entries)
return self.display_obj_type_rows('host-vns-interface-vns', entries, with_key, 'default')
#
# --------------------------------------------------------------------------------
# do_show_vns_mac_address_table
# config and vns mode 'show mac-address-table' command
#
def do_show_vns_mac_address_table(self, words):
if words == None or len(words) > 2:
return self.syntax_msg('show mac-address-table <host>')
if self.in_config_submode('config-vns'):
return self.display_vns_mac_address_table(self.vns_name(), words)
if len(words) > 0:
return self.do_show_object(['host'] + words, 'with_key')
return self.do_show_object(['host'])
#
# --------------------------------------------------------------------------------
# do_show_switch_cluster
#
def do_show_switch_cluster(self, words):
data = self.rest_simple_request_to_dict(
'http://%s/rest/v1/realtimestatus/network/cluster/' % self.controller)
formatted_data = []
for (clusterid, switchids) in data.items():
row = {}
row['switches'] = switchids
row['cluster-id'] = clusterid
formatted_data.append(row)
return self.display_obj_type_rows('switch-cluster', formatted_data)
#
# --------------------------------------------------------------------------------
# do_show_controller_summary
#
def do_show_controller_summary(self, words):
data = self.rest_simple_request_to_dict(
'http://%s/rest/v1/controller/summary' % self.controller)
# XXX Need a way to sort the data in a way that makes sense
for (key, value) in data.items():
yield key + ": " + str(value) + "\n"
#
# --------------------------------------------------------------------------------
# get_statistics_type
#
@staticmethod
def get_statistics_type(stat_type):
for s in ["flow", "port", "table", "desc", "aggregate", "features", "trace",]:
if s.startswith(stat_type):
return s
return None
#
# --------------------------------------------------------------------------------
# fix_realtime_flows_wildcard_fields
#
def fix_realtime_flow_wildcard_fields(self, in_data):
for l in in_data:
if 'wildcards' in l:
wildcards = l['wildcards']
bit_field_map = {
0 : 'inputPort',
1 : 'dataLayerVirtualLan',
2 : 'dataLayerSource',
3 : 'dataLayerDestination',
4 : 'dataLayerType',
5 : 'networkProtocol',
6 : 'transportSource',
7 : 'transportDestination',
13 : 'networkSource',
19 : 'networkDestination',
20 : 'dataLayerVirtualLanPriorityCodePoint',
21 : 'networkTypeOfService',
}
for (k, v) in bit_field_map.items():
if wildcards & (1 << k):
l[v] = "*"
#
# --------------------------------------------------------------------------------
# fix_realtime_flows
#
def fix_realtime_flows(self, in_data):
if not in_data:
return
# flatten match data
for l in in_data:
match_dict = l['match']
l.update(match_dict)
del(l['match'])
self.fix_realtime_flow_wildcard_fields(in_data)
return in_data
#
# --------------------------------------------------------------------------------
# add_dpid_to_data
#
@staticmethod
def add_dpid_to_data(data):
if not type(data) is dict: # backward-compatible
return data
formatted_list = []
for (dpid, rows) in data.items():
if rows != None:
for row in rows:
row['switch'] = dpid
formatted_list.append(row)
## TODO - Alex - handle timeouts + sorting
return formatted_list
#
# --------------------------------------------------------------------------------
# do_show_statistics
#
# LOOK! we could get rid of show statistics at this point as it is all under
# show switch!
#
# it's confusing to remap it over here...
# we could remove show flow-entry realtime too for now
#
def do_show_statistics(self, words):
if len(words) < 1:
return "Syntax: show statistics < flow | port | table | desc | aggregate | " \
"features | trace > < Switch DPID | Switch alias | all >"
stat_type = self.get_statistics_type(words[0])
dpid = None
if len(words) > 1:
words[1] = convert_alias_to_object_key("switch", words[1])
dpid = words[1] # LOOK! Eventually optional so we can show across switches
if not dpid in objects_starting_with("switch", dpid) and dpid != "all":
return self.error_msg("No switch %s found" % dpid)
if stat_type == "flow":
data = self.rest_simple_request_to_dict(
'http://%s/rest/v1/realtimestats/flow/%s/' % (self.controller,dpid))
data = self.add_dpid_to_data(data)
data = self.fix_realtime_flows(data)
#
# it may make sense to move ['details', 'brief'] tp some sort of
# 'show_object_optional_format_keywords' list
field_ordering = "default"
if len(words) == 3:
choices = [x for x in ["details", "brief"] if x.startswith(words[2])]
if len(choices) != 1:
return self.error_msg("switch flow options are either 'details' or 'brief'")
else:
field_ordering = choices[0]
table_data = self.pp.format_table(data, "realtime_flow", field_ordering)
return table_data
elif stat_type == "trace":
return self.do_trace(words)
elif words[0] == "switches":
data = self.rest_simple_request_to_dict(
'http://%s/rest/v1/controller/stats/%s/' % (self.controller, words[0]))
table_data = self.pp.format_table(data, "controller_"+words[0])
return table_data
else:
data = self.rest_simple_request_to_dict(
'http://%s/rest/v1/realtimestats/%s/%s/' % (self.controller, stat_type, dpid))
if stat_type == "features":
for dpid in data:
data[dpid] = data[dpid]["ports"]
data = self.add_dpid_to_data(data)
table_data = self.pp.format_table(data, "realtime_"+stat_type)
return table_data
#
# --------------------------------------------------------------------------------
# do_show_version
#
def do_show_version(self, words):
# LOOK! this should probably come from the controller, but for now
# we assume the CLI/controller are from the same build
version_string = "SDNOS 1.0 - custom version"
try:
fh = open("/opt/sdnplatform/release")
version_string = fh.readline().rstrip()
fh.close()
except:
pass
return version_string
#
# --------------------------------------------------------------------------------
# do_date
#
@staticmethod
def do_date(words):
return time.strftime("%Y-%m-%d %H:%M:%S %Z", time.localtime())
#
# --------------------------------------------------------------------------------
# cp_show_logging
#
def cp_show_logging(self, words, text, completion_char):
if len(words) == 1:
return [x for x in ["sdnplatform", "cassandra", "console-access",
"syslog", "authlog", "orchestrationlog",
"all" ] if x.startswith(text)]
else:
self.print_completion_help("<cr>")
#
# --------------------------------------------------------------------------------
# generate_subpprocess_output
#
def generate_subprocess_output(self, cmd):
process = subprocess.Popen(cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
bufsize=1)
while True:
line = process.stdout.readline()
if line != None and line != "":
yield line
else:
break
#
# --------------------------------------------------------------------------------
#
def implement_show_logging(self, words):
log_files = { "sdnplatform" : "cat /opt/sdnplatform/sdnplatform/log/sdnplatform.log",
"cassandra" : "cat /opt/sdnplatform/db/log/system.log",
"console-access" : "cat /opt/sdnplatform/con/log/access.log",
"syslog" : "cat /var/log/syslog",
"authlog" : "cat /var/log/auth.log",
"orchestrationlog" : "cat /tmp/networkservice.log",
"dmesg" : "dmesg",
"all" : "" # special
}
if len(words) < 1:
yield "Syntax: show logging < %s > " % " | ".join(log_files.keys())
return
for (f, cmd) in log_files.items():
if (f.startswith(words[0]) or "all".startswith(words[0])) and f != "all":
yield "*"*80 + "\n"
yield "output of %s for %s\n" % (cmd, f)
yield "*"*80 + "\n"
for item in self.generate_subprocess_output(cmd):
yield item
#
# --------------------------------------------------------------------------------
# do_show_tech_support
#
def do_show_tech_support(self, words):
oldd = self.debug
tech_support_table = []
# Add the user customized command in tech-support-config table
entries = self.get_table_from_store('tech-support-config')
for entry in entries:
# need explicit type casting str() to make command handling work
tech_support_table.append([str(entry['cmd-type']), str(entry['cmd']), None])
# Add the list of command configured for the basic support
for entry in tech_support.get_show_tech_cmd_table():
tech_support_table.append(entry)
for entry in tech_support_table:
cmd_type = entry[0]
cmd = entry[1]
feature = entry[2]
# If feature is non-null, then check feature is enabled
# before executing the command
if feature != None and self.feature_enabled(feature) == False :
continue
if cmd_type == 'cli':
yield "\n\n" + "-"*80 + "\nExecute cli: " + cmd + "\n\n"
try:
for item in self.generate_command_output(self.handle_single_line(cmd)):
yield item
except Exception as e:
yield "Failed to execute %s: %s\n" % (cmd, e)
elif cmd_type == 'shell':
yield "\n\n" + "-"*80 + "\nExecuting os command: " + cmd + "\n\n"
try:
for item in self.generate_subprocess_output(cmd):
yield item
except Exception as e:
yield "Failed to run command %s: %s\n" % (cmd, e)
else:
yield "Unknown command type %s: %s\n" % (cmd_type, cmd)
self.debug = oldd
#
# --------------------------------------------------------------------------------
# ell_ess_minus_r
# Do "ls -R", returing the list of files underneath "prefix".
# The intended external call is
# ell_ess_minus_r(returned_items, "/opt/sdnplatform/...", ""),
# where the path parameter is null to begin the walk.
#
# The returned items won't have the original prefix in the items
#
# XXX: There's no bounding for the recursive descent.
#
def ell_ess_minus_r(self, items, prefix, path):
p = os.path.join(prefix, path)
if os.path.isdir(p):
for entry in os.listdir(p):
new_path = os.path.join(path, entry)
if os.path.isdir(os.path.join(prefix, new_path)):
self.ell_ess_minus_r(items, prefix, new_path)
else:
items.append(os.path.join(path, entry))
return items
#
# --------------------------------------------------------------------------------
# implement_show_config_file
# 'show config file' displays the local files under self.saved_configs_dirname
# currently /opt/sdnplatform/run/saved-configs
#
def implement_show_config_file(self, words):
items = []
self.ell_ess_minus_r(items, self.saved_configs_dirname, "")
if len(words) == 1:
entries = []
for i in items:
cf = os.path.join(self.saved_configs_dirname, i)
t = time.strftime("%Y-%m-%d.%H:%M:%S",
time.localtime(os.path.getmtime(cf)))
entries.append({'name' : i,
'timestamp': t,
'length' : str(os.path.getsize(cf)),
})
return self.pp.format_table(entries,'config')
elif len(words) == 2:
if words[1] in items:
src_file = self.path_concat(self.saved_configs_dirname, words[1])
if src_file == "":
return self.error_msg("file %s could not be "
"interpreted as a valid source" % words[1])
try:
return self.store.get_text_from_url("file://" + src_file)
except Exception, e:
return self.error_msg(words[1] + ":" + str(e))
else:
return self.error_msg("%s file unknown" % words[1])
#
#
# --------------------------------------------------------------------------------
# implement_show_config
#
def implement_show_config(self, words):
name = None
show_version = "latest"
# handle sh config [ <name> [ all | <version #> ] ]
if len(words) == 1:
if words[0] == "all":
show_version = "all"
elif words[0] == "file":
return self.implement_show_config_file(words)
elif words[0].startswith('config://'):
name = words[0][len('config://'):]
else:
name = words[0]
elif len(words) == 2:
if words[0] == 'file':
return self.implement_show_config_file(words)
name = words[0]
show_version = words[1]
elif len(words) == 3 and words[1] == "diff":
return self.diff_two_configs(words[0], words[2])
elif len(words) == 4 and words[1] == "diff":
return self.diff_two_versions(words[0], words[2], words[3])
data = self.store.get_user_data_table(name, show_version)
if data and len(data) > 1 or name == None:
return self.pp.format_table(data,'config')
elif data and len(data) == 1:
return self.store.get_user_data_file(data[0]['full_name'])[:-1]
#
# --------------------------------------------------------------------------------
# diff_two_versions
#
def diff_two_versions(self, name, va, vb):
va_info = self.store.get_user_data_table(name, va)
if len(va_info) == 0:
return self.error_msg("Version %s missing for %s" % (va, name))
va_txt = self.store.get_user_data_file(va_info[0]['full_name'])
vb_info = self.store.get_user_data_table(name, vb)
if len(vb_info) == 0:
return self.error_msg("Version %s missing for %s" % (vb, name))
vb_txt = self.store.get_user_data_file(vb_info[0]['full_name'])
import tempfile
fa = tempfile.NamedTemporaryFile(delete=False)
fa.write(va_txt)
fa.close()
fb = tempfile.NamedTemporaryFile(delete=False)
fb.write(vb_txt)
fb.close()
cmd = 'diff %s %s ' % (fa.name, fb.name)
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
(output, stderr) = process.communicate()
os.unlink(fa.name)
os.unlink(fb.name)
return output
#
# --------------------------------------------------------------------------------
# diff_two_configs
#
def diff_two_configs(self, config_a, config_b):
items = self.store.get_user_data_table(config_a, "latest")
if len(items) == 0:
if config_a == 'running-config':
txt_a = run_config.implement_show_running_config([]) + "\n"
else:
return self.error_msg("%s config missing" % config_a)
else:
txt_a = self.store.get_user_data_file(items[0]['full_name'])
items = self.store.get_user_data_table(config_b, "latest")
if len(items) == 0:
if config_b == 'running-config':
txt_b = run_config.implement_show_running_config([]) + "\n"
else:
return self.error_msg("%s config missing" % config_b)
else:
txt_b = self.store.get_user_data_file(items[0]['full_name'])
import tempfile
fa = tempfile.NamedTemporaryFile(delete=False)
fa.write(txt_a)
fa.close()
fb = tempfile.NamedTemporaryFile(delete=False)
fb.write(txt_b)
fb.close()
cmd = 'diff %s %s ' % (fa.name, fb.name)
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
(output, stderr) = process.communicate()
os.unlink(fa.name)
os.unlink(fb.name)
return output
#
# --------------------------------------------------------------------------
#
def get_host_attachment_switch_port (self, query_dict):
"""
Get a host's attachment point if it is not already provided.
see if the host has an attachment point, use the switch and port
of the attachment point, if its available
"""
host = rest_to_model.get_model_from_url('host', query_dict)
if len(host) == 0:
print self.error_msg('Can\'t identify host details: %s' % query_dict)
return (False,None,None)
attachment_points = host[0]['attachment-points']
if attachment_points == None or len(attachment_points) == 0:
print self.error_msg('Can\'t identify attachment point %s' % query_dict)
return (False,None,None)
if len(attachment_points) == 1:
src_sw = attachment_points[0]['switch']
src_sw_port = attachment_points[0]['ingress-port']
return (True, src_sw, src_sw_port)
interface_dict = create_obj_type_dict('interfaces', 'id')
show_list = []
for ap in attachment_points:
dpid = ap['switch']
ingress_port = ap['ingress-port']
# alias for dpid
switch_name = alias_lookup_with_foreign_key('switch-alias', dpid)
if not switch_name:
switch_name = dpid
# interface name for attachment point
ap_port_id = dpid + '|' + str(ingress_port)
if ap_port_id in interface_dict:
show_list.append("%s/%s" % (switch_name,
interface_port[ap_port_od][0]['portName']))
else:
show_list.append("%s/port %s" % (switch_name, ingress_port))
print self.error_msg('src-host %s: multiple attachment points: %s' %
(src_mac, ', '.join(show_list)))
print self.error_msg('rerun, and identify src-switch and interface')
return (False,None,None)
#
# --------------------------------------------------------------------------
# test packet-in: swap source and destination attributes
#
def test_pkt_in_swap_src_dest_attributes(self, post_data):
# Remove the source switch and port if needed
if ("srcSwitchDpid" in post_data):
post_data.pop("srcSwitchDpid")
if ("srcSwitchInPort" in post_data):
post_data.pop("srcSwitchInPort")
#
# Get destination host's attachment switch/port information
#
(result, src_sw, src_sw_port) = self.get_host_attachment_switch_port(
{ 'mac' : post_data["destinationMACAddress"]})
if not result:
return
post_data["srcSwitchDpid"] = src_sw
post_data["srcSwitchInPort"] = src_sw_port
# Swap the macs
temp = post_data["sourceMACAddress"]
post_data["sourceMACAddress"] = post_data["destinationMACAddress"]
post_data["destinationMACAddress"] = temp
# swap the IP addresses if specified
tempSrc = None
tempDst = None
if ("sourceIpAddress" in post_data):
tempSrc = post_data["sourceIpAddress"]
post_data.pop("sourceIpAddress")
if ("destinationIpAddress" in post_data):
tempDst = post_data["destinationIpAddress"]
post_data.pop("destinationIpAddress")
if (tempSrc is not None):
post_data["destinationIpAddress"] = tempSrc
if (tempDst is not None):
post_data["sourceIpAddress"] = tempDst
# swap the IP ports if specified
tempSrc = None
tempDst = None
if ("ipL4SourcePort" in post_data):
tempSrc = post_data["ipL4SourcePort"]
post_data.pop("ipL4SourcePort")
if ("ipL4DestinationPort" in post_data):
tempDst = post_data["ipL4DestinationPort"]
post_data.pop("ipL4DestinationPort")
if (tempSrc is not None):
post_data["ipL4DestinationPort"] = tempSrc
if (tempDst is not None):
post_data["ipL4SourcePort"] = tempDst
#
# --------------------------------------------------------------------------
# test packet-in: display packet-in processing result for test packet-in
#
def test_pkt_in_result_display(self, response):
out = "\nResult of packet-in processing\n"
out += ("------------------------------\n")
src_vns_name = response['srcVNSName']
dst_vns_name = response['destVNSName']
if (response['explanation'] == "Source switch not found"):
out += response['explanation']
return out
out += "\nVirtual Routing Processing iterations\n"
out += ("--------------------------------------\n")
ep_vrouting = response['expPktVRouting']
for ep_vr in ep_vrouting:
srcIface = ep_vr['srcIface']
dstIface = ep_vr['dstIface']
action = ep_vr['action']
out += ("src VNS iface : %s\n" % srcIface)
out += ("dst VNS iface : %s\n" % dstIface)
out += ("action : %s\n" % action)
if action == 'DROP':
dropReason = ep_vr['dropReason']
out += ("drop reason : %s\n" % dropReason)
else:
nextHopIp = ep_vr['nextHopIp']
out += ("next hop IP : %s\n" % nextHopIp)
nextHopGatewayPool = ep_vr['nextHopGatewayPool']
if (nextHopGatewayPool != None):
out += ("next hop Gateway Pool : %s\n" % nextHopGatewayPool)
out += "\n"
if (src_vns_name == None) and (dst_vns_name == None):
out += "Source and destination hosts are not in the same vns"
return out
out += ("Status : %s\n" % response['status'])
out += ("Explanation : %s\n" % response['explanation'])
out += "\nResult of Virtual Routing\n"
out += ("--------------------------\n")
out += ("Source VNS : %s\n" % src_vns_name)
out += ("Dest. VNS : %s\n" % dst_vns_name)
out += ("Input ACL:\n")
out += (" Input ACL Name : %s\n" % response['inputAcl']['aclName'])
out += (" Input ACL Entry : %s\n" % response['inputAcl']['aclEntry'])
out += (" Input ACL Action : %s\n" % response['inputAcl']['aclResult'])
out += ("Output ACL:\n")
out += (" Output ACL Name : %s\n" % response['outputAcl']['aclName'])
out += (" Output ACL Entry : %s\n" % response['outputAcl']['aclEntry'])
out += (" Output ACL Action : %s\n" % response['outputAcl']['aclResult'])
if response['expPktRoute'] == None:
out += "\n"
return out
out += ("Routing Action : %s\n" % response['routingAction'])
obj_type_show_alias_update('test-pktin-route')
out += ('\nFlow Path:\n')
ep_route = response['expPktRoute']
for ep_cluster in ep_route:
ep_cluster_path = ep_cluster['path']
hop = 1
route_data = []
for ep_path in ep_cluster_path:
oneHop = {}
oneHop['cluster'] = ep_cluster['clusterNum']
oneHop['hop'] = hop
hop += 1
oneHop.update(ep_path)
route_data.append(oneHop)
route_data = self.pp.format_table(route_data, 'test-pktin-route')
out += route_data
out += "\n"
return out
#
# --------------------------------------------------------------------------------
# implement_test_packet_in
#
def implement_test_packet_in(self, data):
# Currently only supports <test packet-in> for "explain packet" feature
self.debug_msg("In do_test(): data=%s" % (data))
# REST API expects MAC not host aliases
if not 'src-host' in data:
print self.error_msg("Missing src-host")
return
src_mac = data['src-host']
if not 'dst-host' in data:
print self.error_msg("Missing dst-host")
return
dst_mac = data['dst-host']
# Check that src and dest hosts are not the same
if src_mac == dst_mac:
print self.error_msg("source and destination hosts can not be same")
return
#
if 'src-switch' in data:
src_sw = data['src-switch']
src_sw_port = data['src-switch-port']
else:
#
# Get host's attachment switch/port information
#
(result, src_sw, src_sw_port) = \
self.get_host_attachment_switch_port({'mac' : src_mac})
if not result:
return
post_data = {
"sourceMACAddress": src_mac, "destinationMACAddress": dst_mac,
"srcSwitchDpid" : src_sw, "srcSwitchInPort" : src_sw_port
}
if 'vlan' in data:
post_data["vlanID"] = data['vlan']
if 'ether-type' in data:
post_data["etherType"] = data['ether-type']
if (post_data['etherType'] != "2048"):
yield(self.error_msg("Supported ethertypes: 2048 (ip)"))
return
if 'priority' in data:
post_data["priorityCode"] = data['priority']
if 'src-ip-address' in data:
post_data["sourceIpAddress"] = data['src-ip-address']
if 'dst-ip-address' in data:
post_data["destinationIpAddress"] = data['dst-ip-address']
if 'protocol' in data:
post_data["ipv4Protocol"] = data['protocol']
if 'tos' in data:
#Uncomment the line below once we support tos in the REST API
#post_data["tos"] = data['tos']
pass
if 'src-port' in data:
post_data["ipL4SourcePort"] = data['src-port']
if 'dst-port' in data:
post_data["ipL4DestinationPort"] = data['dst-port']
self.debug_msg("Post Data = %s" % post_data)
url = "http://%s/rest/v1/realtimetest/network/explain-packet" % self.controller
try:
jresponse = self.store.rest_post_request(url, post_data)
except Exception, e:
errors = self.rest_error_to_dict(e, url)
yield(self.error_msg(self.rest_error_dict_to_message(errors)))
return
response = json.loads(jresponse)
self.debug_msg("Response = %s" % response)
yield ("Input packet\n")
yield ("------------\n")
explPkt = response['explainPktParams']
switch_alias = alias_lookup_with_foreign_key("switch-alias", explPkt['srcSwitchDpid'])
src_host_alias = alias_lookup_with_foreign_key("host-alias", explPkt['sourceMACAddress'])
dst_host_alias = alias_lookup_with_foreign_key("host-alias", explPkt['destinationMACAddress'])
if (src_host_alias):
yield ("Source host : %s (%s), ip=%s\n" %
(explPkt['sourceMACAddress'], src_host_alias, explPkt['sourceIpAddress']))
else:
yield ("Source host : %s, ip=%s\n" % (explPkt['sourceMACAddress'], explPkt['sourceIpAddress']))
if (dst_host_alias):
yield ("Destination host : %s (%s), ip=%s\n" %
(explPkt['destinationMACAddress'], dst_host_alias, explPkt['destinationIpAddress']))
else:
yield "Destination host : %s, ip=%s\n" % (explPkt['destinationMACAddress'], explPkt['destinationIpAddress'])
if (explPkt['vlanID'] == '-1'):
yield "VLAN : %s (Untagged)\n" % explPkt['vlanID']
else:
yield "VLAN : %s\n" % explPkt['vlanID']
yield "802.1Q priority : %s\n" % explPkt['priorityCode']
yield "Ether type : %s\n" % explPkt['etherType']
if (switch_alias):
yield "Source switch/port : %s (%s)/%s\n" % (explPkt['srcSwitchDpid'], switch_alias, explPkt['srcSwitchInPort'])
else:
yield "Source switch/port : %s/%s\n" % (explPkt['srcSwitchDpid'], explPkt['srcSwitchInPort'])
yield "Protocol : %s\n" % explPkt['ipv4Protocol']
yield "L4 source port : %s\n" % explPkt['ipL4SourcePort']
yield "L4 destination port: %s\n" % explPkt['ipL4DestinationPort']
yield("\nForward path:")
yield("=============\n")
yield(self.test_pkt_in_result_display(response))
# Now send the reverse test packet
self.test_pkt_in_swap_src_dest_attributes(post_data)
try:
jresponse = self.store.rest_post_request(url, post_data)
except Exception, e:
errors = self.rest_error_to_dict(e, url)
yield(self.error_msg(self.rest_error_dict_to_message(errors)))
return
response = json.loads(jresponse)
self.debug_msg("Response = %s" % response)
yield("\nReverse path:")
yield("=============\n")
yield(self.test_pkt_in_result_display(response))
#
# --------------------------------------------------------------------------------
#
def implement_test_path(self, data):
# compute source
#
if 'src-switch' in data:
src_sw = data['src-switch']
src_sw_port = data['src-switch-port']
elif 'src-host' in data:
(result, src_sw, src_sw_port) = \
self.get_host_attachment_switch_port({ 'mac' : data['src-host']})
if not result:
return
elif 'src-ip' in data:
# look up the ip in the device api
(result, src_sw, src_sw_port) = \
self.get_host_attachment_switch_port({ 'ipv4' : data['src-ip']})
if not result:
return
else:
return self.error_msg('No source attachment point in request')
# compute dest
if 'dst-switch' in data:
dst_sw = data['dst-switch']
dst_sw_port = data['dst-switch-port']
elif 'dst-host' in data:
(result, dst_sw, dst_sw_port) = \
self.get_host_attachment_switch_port({ 'mac' : data['dst-host']})
if not result:
return
elif 'dst-ip' in data:
# look up the ip in the device api
(result, dst_sw, dst_sw_port) = \
self.get_host_attachment_switch_port({ 'ipv4' : data['dst-ip']})
if not result:
return
else:
return self.error_msg('No dest attachment point in request')
url = "http://%s/rest/v1/realtimetest/network/path" % self.controller
request = {
'src-switch' : src_sw,
'src-switch-port' : src_sw_port,
'dst-switch' : dst_sw,
'dst-switch-port' : dst_sw_port,
}
try:
response = self.store.rest_post_request(url, request)
self.debug_msg("Response = %s" % response)
if response != '':
command.query_result = json.loads(response)
else:
command.query_result = None
except Exception, e:
errors = self.rest_error_to_dict(e, url)
return self.error_msg(self.rest_error_dict_to_message(errors))
#
# --------------------------------------------------------------------------------
#
def cp_help(self, words, text, completion_char):
"""
Completion for the help command must be done using the collection
of command descriptions; ie: help uses the command descriptions
to complete the help commands.
"""
if completion_char == ord('?'):
if len(words) > 1:
command.do_command_completion_help(words[1:], text)
else:
print self.help_splash([], text)
return
if len(words) == 1:
items = self.commands_for_current_mode_starting_with(text)
return utif.add_delim(items, ' ')
else:
return command.do_command_completion(words[1:], text)
#
# --------------------------------------------------------------------------------
# command_short_help
# Associate short help strings with known commands
# These ought to be associated with the COMMAND_DESCRIPTIONs,
# but since not all command use that mechanism yet, provide
# these short descriptions here.
#
command_short_help = {
'access-list' : 'Define access-list',
'access-group' : 'Configure access-list to interface association',
'boot' : "Configure boot configuration",
'clock' : 'Configure timezone or set clock',
'clear' : 'Reset counters',
'connect' : "Connect to a controller's REST API via ip[:port]",
'date' : 'Display current date and time',
'debug' : 'Enter various debug modes',
'echo' : 'Echo remaining arguments',
'enable' : 'Move to enable mode',
'exit' : 'Exit current mode',
'feature' : 'Enable or disable features',
'firewall' : 'Enable controller interfaces acls',
'help' : 'Help on commands or topics',
'history' : 'Display history of commands',
'ip' : 'Configure various controller node ip values',
'logout' : 'Exit from cli',
'logging' : 'Configure logging/syslog',
'ntp' : 'Configure ntp',
'ping' : 'Ping request from controller to switch or ip address',
'show' : 'Display configuration or settings',
'test' : 'Test various behaviors',
'trace' : 'Trace various streams',
'traceroute' : 'Traceroute from controller to switch or ip address',
'configure' : 'Enter configuration mode',
'reload' : 'Reboot controller, reload configuration',
'write' : 'Write configuraion',
'no' : 'Delete or disable configuration parameters',
'vns-definition' : 'Enter vns-definiton submode, describe membership',
'vns' : 'Enter vns submode, manage access lists',
'copy' : 'Copy configurations',
'switchto' : 'Switch to another vns definition',
'interface-rule' : 'VNS Membership rule',
'end' : 'End all nested configuration modes',
'interface' : 'Enter interface submode',
'watch' : 'Iterate indicated command displaying results',
}
#
# --------------------------------------------------------------------------------
# obj_type_short_help
#
obj_type_short_help = {
'controller-node' : 'Configure specific controller nodes',
'host' : 'Configure host details',
'statd-config' : 'Statd Configuration',
'statdropd-config' : 'Stat dropd configuration',
'statdropd-progress-info' : 'Stat dropd progress configuration',
'switch' : 'Switch Configuration',
# -- debug only tables
'vns-access-list' : 'VNS Access List object',
'vns-access-list-entry' : 'VNS Access List Entry object',
'vns-interface' : 'VNS Interface object',
'vns-interface-access-list' : 'VNS Interface Access List object',
'vns-interface-rule' : 'VNS Interface Rule object',
'host-alias' : 'Host Alias object',
'port-alias' : 'Port Alias object',
'switch-alias' : 'Switch Alias object',
}
#
# --------------------------------------------------------------------------------
# help_splash
#
def help_splash(self, words, text):
ret = ""
if not words:
if text == "":
ret += "For help on specific commands type help <topic>\n"
count = 0
longest_command = 0
# this submode commands
s_ret = ""
mode = self.current_mode()
nested_mode_commands = [self.title_of(x) for x in
self.command_nested_dict.get(mode, [])]
possible_commands = [self.title_of(x) for x in
self.command_dict.get(mode, []) ] + \
nested_mode_commands
available_commands = self.commands_feature_enabled(possible_commands)
submode_commands = sorted(utif.unique_list_from_list(available_commands))
if len(submode_commands):
longest_command = len(max(submode_commands, key=len))
for i in submode_commands:
if not i.startswith(text):
continue
count += 1
short_help = command.get_command_short_help(i)
if not short_help:
short_help = self.command_short_help.get(i, None)
if short_help:
s_ret += " %s%s%s\n" % (i,
' ' * (longest_command - len(i) + 1),
short_help)
else:
s_ret += " %s\n" % i
# commands
c_ret = ""
upper_commands = [x for x in self.commands_for_current_mode_starting_with()
if not x in submode_commands]
commands = sorted(upper_commands)
if len(commands):
longest_command = max([len(x) for x in commands] + [longest_command])
for i in commands:
if not i.startswith(text):
continue
count += 1
short_help = command.get_command_short_help(i)
if not short_help:
short_help = self.command_short_help.get(i, None)
if short_help:
c_ret += " %s%s%s\n" % (i,
' ' * (longest_command - len(i) + 1),
short_help)
else:
c_ret += " %s\n" % i
# objects
o_ret = ""
if self.in_config_mode():
obj_types = sorted(self.obj_types_for_config_mode_starting_with())
if len(obj_types) > 0:
for i in obj_types:
longest_command = max([len(x) for x in commands] +
[longest_command])
for i in obj_types:
if i in commands:
continue
if i.startswith(text):
count += 1
short_help = self.obj_type_short_help.get(i, None)
if short_help:
o_ret += " %s%s%s\n" % (i,
' ' * (longest_command - len(i) + 1),
short_help)
else:
o_ret += " %s\n" % i
# fields
f_ret = ""
if self.in_config_submode():
# try to get both the fields and the commands to line up
longest_field = longest_command
for i in self.fields_for_current_submode_starting_with():
if i.startswith(text):
longest_field = max(longest_field, len(i))
f_count = 0
# LOOK! could be getting the help text for each of these...
for i in sorted(self.fields_for_current_submode_starting_with()):
if not i.startswith(text):
continue
count += 1
field_info = mi.obj_type_info_dict[
self.get_current_mode_obj_type()]['fields'].\
get(i, None)
if not field_info and self.debug:
print 'no field for %s:%s' % (self.get_current_mode_obj_type(), i)
if field_info and field_info.get('help_text', None):
f_ret += " %s%s%s\n" % (i,
' ' * (longest_field - len(i) + 1),
field_info.get('help_text'))
else:
f_ret += " %s\n"% i
if (text == "" or count > 1) and s_ret != "":
ret += "Commands:\n"
ret += s_ret
if (text == "" or count > 1) and c_ret != "":
ret += "All Available commands:\n"
ret += c_ret
if (text == "" or count > 1) and o_ret != "":
ret += "\nAvailable config submodes:\n"
ret += o_ret
if (text == "" or count > 1) and f_ret != "":
ret += "\nAvailable fields for %s:\n" % self.get_current_mode_obj_type()
ret += f_ret
elif words[0] in ["show", "help", "copy", "watch" ]:
method = self.command_method_from_name(words[0])
if method:
ret = method(None)
else:
#try:
#ret = command.get_command_syntax_help(words, 'Command syntax:')
#except:
#if self.debug or self.debug_backtrace:
#traceback.print_exc()
#ret = "No help available for command %s" % words[0]
try:
ret = command.get_command_documentation(words)
except:
if self.debug or self.debug_backtrace:
traceback.print_exc()
ret = "No help available for command %s" % words[0]
else:
#try:
#ret = command.get_command_syntax_help(words, 'Command syntax:')
#except:
#if self.debug or self.debug_backtrace:
#traceback.print_exc()
#ret = "No help available for command %s" % words[0]
try:
ret = command.get_command_documentation(words)
except:
if self.debug or self.debug_backtrace:
traceback.print_exc()
ret = "No help available for command %s" % words[0]
return ret
#
# --------------------------------------------------------------------------------
# do_help
#
def do_help(self, words):
return self.help_splash(words, "")
#
# --------------------------------------------------------------------------------
# do_lint
#
def do_lint(self, words):
return command.lint_command(words)
#
# --------------------------------------------------------------------------------
# cp_history
#
def cp_history(self, words, text, completion_char):
if len(words) == 1:
ret_val = " <num> - to display a specific number of commands (default:all)\n"
ret_val += " <cr>\n"
self.print_completion_help(ret_val)
else:
self.print_completion_help("<cr>")
#
# --------------------------------------------------------------------------------
# do_history
#
def do_history(self, words = None):
ret_val = ""
how_many = num_commands = readline.get_current_history_length()
if words:
how_many = words[0]
for i in range(num_commands-int(how_many) + 1, num_commands):
yield "%s: %s\n" % (i, readline.get_history_item(i))
return
debug_cmd_options = ["python", "bash", "cassandra-cli", "netconfig", "tcpdump",
"cli", "cli-backtrace", "cli-batch", "cli-interactive"]
#
# --------------------------------------------------------------------------------
# do_debug
#
def implement_debug(self, words):
if len(words) < 1 or len([x for x in self.debug_cmd_options if x.startswith(words[0])]) < 1:
return "Syntax: debug < %s >" % " | ".join(self.debug_cmd_options)
def shell(args):
subprocess.call(["env", "SHELL=/bin/bash", "/bin/bash"] + list(args), cwd=os.environ.get("HOME"))
print
print "\n***** Warning: this is a debug command - use caution! *****"
if "python".startswith(words[0]):
print '***** Type "exit()" or Ctrl-D to return to the SDNOS CLI *****\n'
shell(["-l", "-c", "python"])
elif "bash".startswith(words[0]):
print '***** Type "exit" or Ctrl-D to return to the SDNOS CLI *****\n'
shell(["-l", "-i"])
elif "cassandra-cli".startswith(words[0]):
print '***** Type "exit" or Ctrl-D to return to the SDNOS CLI *****\n'
shell(["-l", "-c", "/opt/sdnplatform/db/bin/cassandra-cli --host localhost"])
elif "netconfig".startswith(words[0]):
if not re.match("/dev/ttyS?[\d]+$", os.ttyname(0)):
print '***** You seem to be connected via SSH or another remote protocol;'
print '***** reconfiguring the network interface may disrupt the connection!'
print '\n(Press Control-C now to leave the network configuration unchanged)\n'
subprocess.call(["sudo", "env", "SHELL=/bin/bash", "/opt/sdnplatform/sys/bin/bscnetconfig", "eth0"], cwd=os.environ.get("HOME"))
elif "tcpdump".startswith(words[0]):
print '***** Type Ctrl-C to return to the SDNOS CLI *****\n'
try:
shell(["-l", "-c", "sudo /opt/openflow/sbin/tcpdump " + " ".join(words[1:])])
except:
pass # really, we need to ignore this unconditionally!
time.sleep(0.2)
elif "cli".startswith(words[0]):
if self.debug:
self.debug = False
print "debug disabled"
else:
self.debug = True
print "debug enabled"
elif "cli-backtrace".startswith(words[0]):
# This feature is separated from the cli debug mode so that backtraces
# can be collected during cli qa
self.debug_backtrace = True
print '***** Enabled cli debug backtrace *****'
elif "cli-batch".startswith(words[0]):
self.batch = True
print '***** Enabled cli batch mode *****'
elif "cli-interactive".startswith(words[0]):
self.batch = False
print '***** Disabled cli batch mode *****'
else:
return self.error_msg("invoking debug")
#
# --------------------------------------------------------------------------------
# do_echo
#
def do_echo(self, words):
print " ".join(words)
#
# --------------------------------------------------------------------------------
# cp_trace
#
trace_optional_params = {
'screen': {'type': 'flag'},
# 'port': {'type': 'string',
# 'syntax_help': "Enter <switch dpid> <physical port#>, where the packets traces are spanned."},
'file': {'type': 'string',
'syntax_help': "Enter <filename> where the packets traces are captured."},
}
trace_cmds = ["detail", "oneline", "vns", "in", "out", "both",
"echo_reply", "echo_request", "features_rep", "flow_mod", "flow_removed", "get_config_rep", "hello",
"packet_in", "packet_out", "port_status", "set_config", "stats_reply", "stats_reques"]
def cp_trace(self, words, text, completion_char):
vns_cache = objects_starting_with('vns-definition')
if len(words) == 1:
return [x for x in self.trace_cmds if x.startswith(text)]
elif len(words) == 2 and words[1].lower().startswith("vns"):
return vns_cache
elif len(words) == 2 and words[1].lower().startswith("output"):
return self.complete_optional_parameters(self.trace_optional_params,
words[len(words):], text)
elif (len(words) == 3 and
words[1].lower().startswith("vns") and
words[2].lower() in vns_cache):
return [x for x in ["in", "out", "both", "output"] if x.startswith(text)]
elif (len(words) == 4 and
words[1].lower().startswith("vns") and
words[2].lower() in objects_starting_with('vns-definition') and
words[3].lower() in ["in", "out", "both"]):
return [x for x in ["output"] if x.startswith(text)]
elif len(words) == 2 and words[1].lower()in ["in", "out", "both"]:
return [x for x in ["output"] if x.startswith(text)]
elif (len(words) > 2 and
(words[1].lower().startswith("vns") or
words[1].lower().startswith("output") or
words[2].lower().startswith("output"))) :
offset = len(words)
if words[len(words)-1].lower() == 'screen':
self.print_completion_help("<cr>")
return []
elif words[len(words)-1].lower() in ['file']:
offset = len(words) - 1
return self.complete_optional_parameters(self.trace_optional_params, words[offset:], text)
self.print_completion_help("<cr>")
#
# --------------------------------------------------------------------------------
# do_trace
#
def do_trace(self, *args):
dpid = None
if len(args) > 0:
args = args[0] # first element is the array of 'real' args
if len(args) > 1 and args[0].lower() in ['vns', 'in', 'out', 'both', 'output']:
try :
return self.do_sdnplatform_trace(args)
except KeyboardInterrupt, e:
return
if len(args) > 1 and args[0].lower() == 'trace':
dpid = args[1]
args = args[2:] # And in this case, args are after the first 2 parameters
return self.do_tcpdump_trace(dpid, args)
def do_sdnplatform_trace(self, args):
vns = None
direction = 'both'
output = 'screen'
dpid = None
port = None
file_name = None
sessionId = None
error = 'Error: Invalid command syntax.\n' + \
'trace [vns <vnsId>] [in|out|both] output [screen]'
# 'trace [vns <vnsId>] [in|out|both] output [screen|port <dpid> <physical port>|file <filename>]'
if args[0].lower() == 'vns':
if len(args) > 1:
vns = args[1]
args = args[2:]
else:
return error
while args:
if args[0].lower() == 'output':
args = args[1:]
continue
if args[0].lower() in ['in', 'out', 'both']:
direction = args[0].lower()
args = args[1:]
continue
if args[0].lower() == 'screen':
output = 'screen'
break
if args[0].lower() == 'port':
output = 'port'
if len(args) > 2:
dpid = args[1]
port = args[2:]
break
else:
return error
if args[0].lower() == 'file':
output = 'file'
if len(args) > 1:
file_name = args[1]
break
else:
return error
filter_request = {FT_DIRECTION:direction, FT_OUTPUT:output, FT_PERIOD:FT_PERIOD_DEFAULT}
if vns :
filter_request[FT_VNS] = vns
if dpid and port :
filter_request[FT_PORT] = {FT_PORT_DPID:dpid, FT_PORT_PORT:port}
post_data = json.dumps(filter_request)
while 1:
response_text = None
sessionId = None
url = 'http://%s/rest/v1/packettrace/' % cli.controller
request = urllib2.Request(url, post_data, {'Content-Type':'application/json'})
try:
response = urllib2.urlopen(request)
response_text = response.read()
response_text = json.loads(response_text)
except Exception, e:
return "Error: failed to get a response for a trace request. %s" % e
if response_text and SESSIONID in response_text:
sessionId = response_text[SESSIONID]
else :
return "Error: failed to get a trace session. %s" % response_text
# Span to a physical port
# No data is shown on cli. ^C to stop the trace
if output.lower() == 'port':
while 1:
try :
time.sleep(1000)
except KeyboardInterrupt, e:
self.terminateTrace(sessionId)
return
lpurl = None
if sessionId:
lpurl = 'http://%s/poll/packets/%s' % (cli.controller, sessionId)
else:
return "Error: failed to start a trace session. %s" % response_text
FILE = None
if file_name:
FILE = open(file_name, "w")
flagTimeout = False
while 1:
try:
response_text = urllib2.urlopen(lpurl).read()
data = json.loads(response_text)
if output.lower() == "screen":
flagTimeout = self.dumpPktToScreen(data)
elif output.lower() == 'file' and FILE != None:
self.dumpPktToFile(FILE, data)
except KeyboardInterrupt, e:
self. terminateTrace(sessionId)
return
except Exception, e:
return "Error: failed to start a trace session. %s" % e
if flagTimeout:
continueString = raw_input("Do you want to continue tracing? [y/n]: ")
if 'y' in continueString.lower():
break
else:
return
@staticmethod
def dumpPktToScreen(data):
for entry in data:
if FT_TIMEOUT in entry:
return True
else:
print entry
return False
@staticmethod
def dumpPktToFile(FILE, data):
FILE.writelines(data)
@staticmethod
def terminateTrace(sid):
post_data = json.dumps({SESSIONID:sid, FT_PERIOD:-1})
url = 'http://%s/rest/v1/packettrace/' % cli.controller
request = urllib2.Request(url, post_data, {'Content-Type':'application/json'})
try:
response = urllib2.urlopen(request)
response_text = response.read()
except Exception, e:
# Sdnplatform may not be running, but we don't want that to be a fatal
# error, so we just ignore the exception in that case.
pass
def do_tcpdump_trace(self, dpid, args):
ret = ''
bsc_port = '6633' # LOOK: listen addr/port are wrong in the controller-node, so hard code 6633 for now
trace_cmd = 'sudo /opt/sdnplatform/cli/bin/trace --filter \'%s\' %s'
trace_rule = '((tcp) and (port %s))' % (bsc_port,)
single_session = False
trace_args = '--alias'
if 'detail' in args:
trace_args += ' --detail'
args.remove('detail')
if 'oneline' in args:
trace_args += ' --oneline'
args.remove('oneline')
if 'single_session' in args:
single_session = True
args.remove('single_session')
if dpid:
query_dict = { 'dpid' : dpid }
row = rest_to_model.get_model_from_url('switches', query_dict)
if len(row) >= 1:
if not 'ip-address' in row[0] or row[0].get('ip-address') == '':
return self.error_msg("switch %s currently not connected " % dpid)
addr = row[0]['ip-address']
port = row[0]['tcp-port']
if single_session:
trace_rule = '((tcp) and (port %s) and (host %s) and (port %s))' % (bsc_port, addr, port)
else:
trace_rule = '((tcp) and (port %s) and (host %s))' % (bsc_port, addr)
if len(args) > 0:
trace_args += (' ' + ' '.join(args))
try:
# print args, dpid, trace_cmd % (trace_rule, trace_args)
process = subprocess.Popen(trace_cmd % (trace_rule, trace_args), shell=True)
status = os.waitpid(process.pid, 0)[1]
if status != 0:
ret = 'Errno: %d' % (status, )
except:
pass # really, we need to ignore this unconditionally!
time.sleep(0.2)
return ret
#
# --------------------------------------------------------------------------------
# get_auth_token_file_path
#
@staticmethod
def get_auth_token_file_path():
auth_token_path = os.environ.get('BSC_AUTH_TOKEN_PATH')
if auth_token_path is None:
auth_token_path = '/opt/sdnplatform'
auth_token_path += '/auth_token'
return auth_token_path
#
# --------------------------------------------------------------------------------
# play_config_lines
#
def play_config_lines(self, src_text):
"""
The complete collection of lines to replay are in src_text.
In the future, this would provide for a way to first identify
what needs to be removed, then apply what needs to be added.
Some smart diffing from the exiting running-config would
be needed to support that. The stanza groups would need to
be collected, the diff'd
"""
print "Updating running-config ..."
num_lines_played = 0
# scan the lines looking for the version number.
#
version = None
for line in src_text.splitlines():
m = re.match("(\s*)(\w+)\s*", line) # only match non-blank lines
if m:
if m.group(0).startswith('version '):
line_parts = line.split()
if line_parts > 1:
version = line_parts[1]
break
# construct the command to run.
command = ['env']
if version:
command.append('CLI_COMMAND_VERSION=%s' % version)
command.append('CLI_STARTING_MODE=config')
command.append('CLI_SUPPRESS_WARNING=True')
if os.path.exists('/opt/sdnplatform/cli/bin/cli'):
# controller VM
command.append('/opt/sdnplatform/cli/bin/cli')
command.append('--init')
else:
# developer setup
base = os.path.dirname(__file__)
command.append(os.path.join(base, 'cli.py'))
command.append('--init')
# create a subprocess for the configuration, then push
# each of the lines into that subprocess.
p = subprocess.Popen(command,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
bufsize=1)
postprocesslines=[]
for line in src_text.splitlines(1):
m = re.match("(\s*)(\w+)\s*", line) # only match non-blank lines
if m:
if 'tenant' or 'router' in line: #special handling for routing rule commands VNS-226
postprocesslines.append(line)
p.stdin.write(line)
num_lines_played += 1
for line in postprocesslines:
p.stdin.write(line)
num_lines_played += 1
p.stdin.close()
output = p.stdout.read()
if output and (self.debug or self.debug_backtrace or self.description):
print output
p.stdout.close()
return "Num lines applied: %s\n" % num_lines_played
#
# --------------------------------------------------------------------------------
# path_concat
# Concatenate a suffix path to a prefix, making the guarantee that the
# suffix will always be "under" the prefix. the suffix is normalized,
# then any prefix up-dirs ("..") are removed.
#
def path_concat(self, prefix, path):
suffix = posixpath.normpath(path.lstrip('/').rstrip('/'))
(head, tail) = os.path.split(suffix)
tails = [tail]
while head:
(head, tail) = os.path.split(head)
tails.insert(0, tail)
drop = ''
while tails[0] == '..':
drop = os.path.join(drop, tails.pop(0))
if drop != '':
self.note("Ignoring %s prefix" % drop)
for t in tails:
prefix = os.path.join(prefix, t)
return prefix
#
# --------------------------------------------------------------------------------
# implement_copy
# startup-config and update-config are simply abbreviations for
# config://startup-config and config://update_config
#
def implement_copy(self, words):
if not words or len(words) > 3:
print "Syntax: copy <src> <dst>"
print "where <src> and <dst> can be"
print " running-config startup-config update-config"
print " config://<name-of-config-in-db> - A-Za-z0-9_-.@ "
print " <url> - starting with either tftp://, ftp://, http:// or file://"
return
if len(words) == 1:
src = words[0]
dst = "terminal"
elif len(words) == 2:
(src, dst) = (words[0], words[1])
# Complete as required.
# NOTE: No completion for upgrade-config as only our scripts should be using it
if "running-config".startswith(src):
src = "running-config"
elif "startup-config".startswith(src):
src = "startup-config"
if "running-config".startswith(dst):
dst = "running-config"
elif "startup-config".startswith(dst):
dst = "startup-config"
elif "terminal".startswith(dst):
dst = "terminal"
if src == dst:
print "src and dst for copy command cannot be equal"
return
# get from the source first
src_text = ""
# map any abbreviations
abbreviations = {'startup-config': 'config://startup-config',
'upgrade-config': 'config://upgrade-config'
}
src = abbreviations.get(src, src)
data = None
if src == "running-config": # get running
src_text = run_config.implement_show_running_config([]) + "\n"
elif src.startswith("config://"): # get local file
m = re.search(self.local_name_pattern, src)
if m:
data = self.store.get_user_data_table(m.group(1), "latest")
if data and len(data) > 0:
src_text = self.store.get_user_data_file(data[0]['full_name'])
else:
print self.error_msg("src name does not match %s" % self.local_name_pattern)
return
elif src.startswith("ftp") or src.startswith("http"): # get URL
src_text = self.store.get_text_from_url(src)
elif src.startswith("file://"):
#src_file = self.saved_configs_dirname + posixpath.normpath(src[7:]).lstrip('/').rstrip('/')
src_file = self.path_concat(self.saved_configs_dirname, src[7:])
if src_file == "":
return self.error_msg("src %s could not be "
"interpreted as a valid source for a file" % src)
try:
src_text = self.store.get_text_from_url("file://" + src_file)
except Exception, e:
return self.error_msg(src + ":" + str(e))
else:
return self.error_msg("Unknown configuration")
message = ""
if len(words) > 2:
message = " ".join(words[2:]).strip('"')
#
# map any abbreviations
dst = abbreviations.get(dst, dst)
# now copy to dest
if dst == "running-config":
return self.play_config_lines(src_text)
elif dst == "terminal":
return src_text # returning src_text here allow '|' to work
elif dst.startswith("config://"):
m = re.search(self.local_name_pattern, dst)
if m:
store_result = self.store.set_user_data_file(m.group(1), src_text)
if store_result:
result = json.loads(store_result)
else:
return self.error_msg("rest store result not json format")
if 'status' in result and result['status'] == 'success':
return None
elif 'message' not in result:
return self.error_msg("rest store result doesn't contain error message")
else:
return self.error_msg(result['message'])
else:
return self.error_msg("dst name does not match %s" % self.local_name_pattern)
elif dst.startswith("ftp") or dst.startswith("http"):
self.store.copy_text_to_url(dst, src_text, message)
elif dst.startswith("file://"):
dst_file = self.path_concat(self.saved_configs_dirname, dst[7:])
dst_dir = '/'.join(dst_file.split('/')[:-1])
if not os.path.exists(dst_dir):
try:
os.makedirs(dst_dir)
except Exception as e:
return self.error_msg("in creating destination directory: %s [%s]"
% (str(e), dst_dir))
if not os.path.isdir(dst_dir):
return self.error_msg("destination directory is not a "
"valid directory: %s" % dst_dir)
with open(dst_file, 'w') as f:
try:
f.write(src_text)
except Exception as e:
return self.error_msg("in saving config file: %s [%s]" %
(str(e), dst_file))
elif dst == 'trash':
if data:
result = self.store.delete_user_data_file(data[0]['full_name'])
if 'status' in result and result['status'] == 'success':
return None
elif 'message' not in result:
return self.error_msg("rest store result doesn't contain error message")
else:
return self.error_msg(result['message'])
else:
print self.error_msg("source file retrieved,"
"but could not copy to destination %s" % dst)
return
#
# --------------------------------------------------------------------------------
# cp_conf_object_type
# Completion function for a named object, returns names of
# available obj_types
#
def cp_conf_object_type(self, words, text):
if words[0] in mi.obj_types and len(words) == 1:
return utif.add_delim(objects_starting_with(words[0], text), ' ')
self.print_completion_help("<cr>")
return []
#
# --------------------------------------------------------------------------------
# cp_conf_field
# Handle if we've got a bunch of fields being concatenated,
# e.g., priority 42 src-port 80
#
def cp_conf_field(self, obj_type, words, text):
if len(words) % 2 == 1:
latest_field_name = words[-1]
field_info = mi.obj_type_info_dict[obj_type]['fields'].get(latest_field_name, None)
# if there was no shallow match of text, do deep match of xrefs if any
if field_info is None:
if obj_type in mi.alias_obj_type_xref:
if latest_field_name in mi.alias_obj_type_xref[obj_type]:
field_info = mi.obj_type_info_dict[latest_field_name]['fields']['id']
if field_info:
completion_text = "< %s >: " % field_info['verbose-name']
completion_text += field_info.get('help_text', "")
self.print_completion_help(completion_text)
# return choices based on the types
if mi.is_field_boolean(obj_type, latest_field_name):
return utif.add_delib([x for x in ["True", "False"] if x.startswith(text)],
' ')
# Use the 'Values:' prefix in the help_text as a way
# of enumerating the different choices
if field_info.get('help_text', "").startswith('Values:'):
values = field_info.get('help_text').replace("Values:", "")
return utif.add_delim([x for x in values.replace(" ","").split(',')
if x.startswith(text)], ' ')
#
# special cases:
if obj_type == 'vns-interface-rule' and latest_field_name == 'mac':
return utif.add_delim(objects_starting_with('host', text), ' ')
elif obj_type == 'vns-interface-rule' and latest_field_name == 'switch':
return utif.add_delim(objects_starting_with('switch', text), ' ')
else:
# we've got an even number of field-value pairs, so just give the list
# of fields for this obj_type
return utif.add_fields(
self.fields_for_current_submode_starting_with(text),
' ')
#
# --------------------------------------------------------------------------------
# vns methods.
#
#
# --------------------------------------------------------------------------------
# vns_obj_type
# return True for an obj_type associated with vns, intended to identify
# tables which are or aren't available in debug mode
#
@staticmethod
def vns_obj_type(obj_type):
if obj_type in [ 'vns-interface', 'vns-access-list-entry', 'vns-access-list',
'vns-interface-access-list', 'vns-interface-rule',
'vns-access-group', 'vns-interfaces', 'host-vns-interface']:
return True
return False
#
# --------------------------------------------------------------------------------
# vns_debug_obj_type
# return True if the obj_type is available in the non-debug mode
#
def vns_debug_obj_type(self, obj_type):
if self.debug:
return True
if self.in_config_submode("config-vns-") and obj_type == 'vns-access-list-entry':
return False
return not self.vns_obj_type(obj_type)
#
# --------------------------------------------------------------------------------
# vns_debug_show_commands
# return True if the show command vns option is availabe in the current debug mode
#
def vns_debug_show_commands(self, show_command):
if self.debug:
return True
if self.in_config_submode() and show_command == 'do_show_vns_interface_rule':
return True
if self.in_config_vns_if_mode() and show_command == 'do_show_vns_access_group':
return True
if show_command == 'do_show_vns':
return True
return not self.vns_obj_type(show_command.replace('_', '-').replace('do-show-', '', 1))
#
# --------------------------------------------------------------------------------
# vns_find_name
# Return True when found, False otherwise
#
def vns_find_name(self, name):
try:
self.get_object_from_store("vns-definition", name)
return True
except Exception, e:
pass
return False
#
# --------------------------------------------------------------------------------
# vns_find_and_set_name
# Return True when the name is known, as a side effect, set self.vns_name
# Invalid names are managed by the model, see VnsNameValidator
#
def vns_find_and_set_name(self, words):
if len(words) == 0:
print self.error_msg("vns <name> required")
return False
elif len(words) > 1:
print self.error_msg("Additional text after vns name ignored")
name = words[0]
if self.vns_find_name(name):
return True
return False
#
# --------------------------------------------------------------------------------
# vns_find_and_set_existing_name
# Return True when the name is known, as a side effect, set self.vns_name
# And display an error message concerning the failure.
#
def vns_find_and_set_existing_name(self, words):
if self.vns_find_and_set_name(words):
return True
if len(words) > 0:
print self.error_msg("Not Found: vns '%s'" % words[0])
return False
#
# --------------------------------------------------------------------------------
# vns_find_or_add_name
# Return True when either the vns name currently exists, or of a create
# for the vns name succeeded.
#
def vns_find_or_add_name(self, words):
if self.vns_find_and_set_name(words):
return True
name = words[0]
errors = None
ident = {mi.pk("vns-definition"): name }
try:
self.rest_create_object("vns-definition", ident)
except Exception, e:
errors = self.rest_error_to_dict(e, 'vns-definition')
print self.rest_error_dict_to_message(errors)
return False
return True
#
# --------------------------------------------------------------------------------
# vns_all_ids
#
def vns_all_ids(self):
return [x['id'] for x in self.get_table_from_store("vns-definition")]
#
# --------------------------------------------------------------------------------
# vns_convert_table_id
# return a list of two entries, the first is the vns name, the second is the
# updated column value
#
def vns_convert_table_id(self, obj_type, row, id):
fields = row[id].split('|')
if len(fields) == 1:
# Just in case there's an error in the table
return [fields[0], "<error>"]
if len(fields) == 2:
return fields
elif len(fields) == 3:
if obj_type == 'host-vns-interface':
return [fields[1], fields[2]]
elif obj_type == 'vns-access-list-entry':
row['vns-access-list'] = fields[1]
return [fields[0], fields[2]]
else:
print self.error_msg("3: vns_convert_table_id case %s" % obj_type)
elif len(fields) == 4:
if obj_type == 'vns-interface-access-list':
# XXX ought to validate
if row['vns-access-list'].split('|')[1] != fields[2]:
print self.error_msg('vns-interface-access-list inconsistent %s and id %d' % \
(row['vns-access-list'], row[id]))
row['vns-access-list'] = fields[2]
row['vns-interface'] = fields[1]
return [fields[0], fields[2]]
else:
print self.error_msg("4: vns_convert_table_id case %s" % obj_type)
else:
print self.error_msg("vns_convert_table_id: length %d not managed" % len(fields))
#
# --------------------------------------------------------------------------------
# vns_table_id_to_vns_column
#
# vns related tables in the model have unique id's created by concatenating the
# vns name with other fields. For those tables, separate the vns id's from the
# associated fields, and transform the vns association into its own column.
#
# obj_type is the name of the table.
#
# for the vns_interface, the vns name is extracted from several fields,
# validated, updated to exclude the vns name, then a new column is added
#
def vns_table_id_to_vns_column(self, obj_type, entries):
id = mi.pk(obj_type)
for row in entries:
if row[id]:
type_info = mi.obj_type_info_dict[obj_type]['fields'][id]['type']
if type_info == 'compound-key':
mi.split_compound_into_dict(obj_type, id, row)
else:
convert_id = self.vns_convert_table_id(obj_type, row, id)
row['vns'] = convert_id[0]
row[id] = convert_id[1]
#
# --------------------------------------------------------------------------------
# vns_foreign_key_to_base_name
# For foreign key's which vns wants to 'show', convert the
# foriegn key to the last entry for the field, and display
# that entry
#
def vns_foreign_key_to_base_name(self, obj_type, entries):
foreign_keys = mi.obj_type_foreign_keys(obj_type)
for row in entries:
# convert the rule id into the rule suffix
for foreign_key in foreign_keys:
if foreign_key in row and row[foreign_key].find('|'):
fields = row[foreign_key].split('|')
row[foreign_key] = fields[-1]
#
# --------------------------------------------------------------------------------
# vns_join_host_fields
# For vns-interfaces new fields are joined from the host table.
#
def vns_join_host_fields(self, obj_type, entries):
if obj_type == 'vns-interface':
#
host_dap_dict = self.create_attachment_dict()
host_ip_dict = self.create_ip_dict()
#
vns_interface_key = mi.pk('vns-interface')
#
# for vns-interface, currently vlan is shown in the output,
# and this must be joined from the host's table. Again, it
# is better to collect the complee host table, then create
# a host dictionary
hosts_rows_dict = create_obj_type_dict('host', 'mac')
#
# re-index host_rows_dict based not on mac, but on attachment point,
# which is the sum of the switch+port. the objective here is to
# identify the number of items on a specific-switch port.
#
ap_dict = {} # indexed by dpid|port
for (mac, values) in host_dap_dict.items():
for value in values:
key = "%s|%s" % (value['switch'], value['ingress-port'])
if not key in ap_dict:
ap_dict[key] = 0
ap_dict[key] += 1
#
# the ap_dict counts the number of mac's associated with an ap.
# sort the host_rows_dict based on the lowest ap in each group.
#
for (mac, value) in host_dap_dict.items():
new_value = sorted(value,
key=lambda k:ap_dict["%s|%s" % (
k['switch'],
k['ingress-port'])],
cmp=lambda x,y: int(x) - int(y))
# add a tag to the dictionary of the first list item
# when the ap_dict's entry's count is 1.
first = new_value[0]
if ap_dict['%s|%s' % (first['switch'], first['ingress-port'])] == 1:
new_value[0]['prime'] = True
host_dap_dict[mac] = new_value
for row in entries:
fields = row['id'].split('/')
if not 'rule' in row:
row['rule'] = fields[0]
if len(fields) != 2:
continue # silently ignore any id's not containing hosts
host = fields[1]
row['mac'] = host
host_dict = {'mac' : host}
row['attachment-points'] = self.get_attachment_points(
host_dict,
host_dap_dict)
row['ips'] = self.get_ip_addresses(host_dict, host_ip_dict)
host_row = hosts_rows_dict.get(host, None)
if host_row and len(host_row) == 1 and 'vlan' in host_row[0]:
row['vlan'] = host_row[0]['vlan']
#
# --------------------------------------------------------------------------------
# vns_join_switch_fields
# For vns-interfaces with entries arising from switch interface rules,
# join in the switch and port.
#
def vns_join_switch_fields(self, vns_name, entries):
#
# store all the rules associated with a specific vns,
# index them by the primary key.
key = mi.pk('vns-interface-rule')
if vns_name == None:
# vns_name == None, this means 'all'
vns_ifr_dict = create_obj_type_dict('vns-interface-rule',
key)
else:
search_key = self.unique_key_from_non_unique([vns_name])
vns_ifr_dict = create_obj_type_dict('vns-interface-rule',
key,
key,
search_key)
for entry in entries:
if 'rule' in entry:
rule = entry['rule']
if rule in vns_ifr_dict:
entry['switch'] = vns_ifr_dict[rule][0].get('switch', "")
entry['ports'] = vns_ifr_dict[rule][0].get('ports', "")
#
# end of vns methods.
# --------------------------------------------------------------------------------
#
#
#
# --------------------------------------------------------------------------------
# debug_obj_type
# Return True when the object is available, in self.debug mode, more objects
# are available.
#
def debug_obj_type(self, obj_type):
if self.debug:
return True
if mi.is_obj_type_source_debug_only(obj_type):
return False
if self.vns_debug_obj_type(obj_type):
if not obj_type in mi.alias_obj_types:
return True
return False
#
# generic parsing routines
#
#
# --------------------------------------------------------------------------------
# completion_reset
#
def completion_reset(self):
self.last_line = None
self.last_options = None
self.completion_cache = True
self.last_completion_char = readline.get_completion_type()
#
# --------------------------------------------------------------------------------
# completer
# This is the main function that is called in order to complete user input
#
def completer(self, text, state):
question_mark = ord('?')
if readline.get_completion_type() == question_mark:
if len(readline.get_line_buffer()) == 0:
#
# manage printing of help text during command completion
help_text = self.help_splash(None, text)
if help_text != "":
self.print_completion_help(help_text)
return
try:
origline = readline.get_line_buffer()
# See if we have a cached reply already
if (self.completion_cache and origline == self.last_line and
self.last_completion_char == readline.get_completion_type() and
self.last_options):
if state < len(self.last_options):
return self.last_options[state]
else:
# apparently, for the linux VM choice don't print
if self.last_options and \
len(self.last_options) > 1 and \
self.last_completion_char == ord('\t'):
choices_text = self.choices_text_builder(self.last_options)
self.print_completion_help(choices_text)
if self.completion_skip:
self.completion_cache = False
self.completion_skip = False
return None
self.completion_reset()
# parse what user has typed so far
begin = readline.get_begidx()
end = readline.get_endidx()
# Find which command we're in for a semicolon-separated list of single commands
# LOOK! This doesn't handle cases where an earlier command in the line changed
# the mode so the completion for later commands in the line should be different.
# For example, if you typed "enable; conf" it won't detect that it should be
# able to complete "conf" to "configure" because the enable command has not been
# executed yet, so you're not in enable mode yet. Handling that case would be
# non-trivial I think, at least with the current CLI framework.
command_begin = 0
command_end = 0
while True:
command_end = self.find_with_quoting(origline, ';', start_index=command_begin)
if command_end < 0:
command_end = len(origline)
break
if begin >= command_begin and end <= command_end:
break
command_begin = command_end + 1
# Skip past any leading whitespace in the command
while command_begin < begin and origline[command_begin].isspace():
command_begin += 1
words = origline[command_begin:end].split()
# remove last term if it is the one being matched
if begin != end:
words.pop()
# LOOK! there are at least three places that try to parse the valid options:
# 1. When actually handling a command
# 2. When trying to show completions (here)
# 3. When displaying help
# complete the first word in a command line
if not words or begin == command_begin:
options = self.commands_for_current_mode_starting_with(text, completion = True)
if self.in_config_mode():
for item in self.obj_types_for_config_mode_starting_with(text):
self.append_when_missing(options, item)
if self.in_config_submode():
for item in self.fields_for_current_submode_starting_with(text):
self.append_when_missing(options, item)
options = [x if x.endswith(' ') else x + ' ' for x in sorted(options)]
# Complete the 2nd word or later
else:
commands = self.commands_for_current_mode_starting_with(words[0])
obj_types = self.obj_types_for_config_mode_starting_with(words[0]) if self.in_config_mode() else []
fields = self.fields_for_current_submode_starting_with(words[0]) if self.in_config_submode() else []
if len(commands) + len(obj_types) + len(fields) > 1:
if len(fields) > 1:
fields = [words[0]] if words[0] in fields else []
if len(commands) > 1:
commands = [words[0]] if words[0] in commands else []
if len(obj_types) > 1:
obj_types = [words[0]] if words[0] in obj_types else []
if len(fields) == 1:
options = self.cp_conf_field(self.get_current_mode_obj_type(), words, text)
elif len(obj_types) == 1:
options = self.cp_conf_object_type(obj_types + words[1:], text)
elif len(commands) == 1:
try:
# options[0] is expanded while words[0] is not
method = self.completion_method_from_name(commands[0])
if method:
options = method(words, text, readline.get_completion_type())
if not options:
# no match
return None
else:
if readline.get_completion_type() == question_mark:
options = command.do_command_completion_help(words, text)
else:
options = command.do_command_completion(words, text)
#else:
#if options:
#print syntax_help
#else:
#pass
#self.print_completion_help(syntax_help)
except AttributeError:
if self.debug or self.debug_backtrace:
traceback.print_exc()
return None
else:
options = None
except Exception, e:
if self.debug or self.debug_backtrace:
traceback.print_exc()
# errors in connect are caught silently, complain here
# TODO - Maybe we should log this in a file we can review
# at a later date?
try:
if options:
self.last_line = origline
self.last_options = options
self.last_completion_char = readline.get_completion_type()
return options[state]
except IndexError:
return None
return None
#
# --------------------------------------------------------------------------------
# handle_alias
# Manage alias creation for an obj_type, only manage one alias for each of the
# targets, although that requirement exists so that a single alias
# can be displayed for output from (show) commands
#
# Note that setting the alias to its current value currently causes the
# alias to be created (ie: there's no specific search to find the item)
#
def handle_alias(self, obj_type, alias_obj_type, alias_value):
if alias_value in self.reserved_words:
return self.error_msg("alias value %s is a reserved word (%s)" %
(alias_value, ', '.join(self.reserved_words)))
#
# allow the use of 'alias' when only one alias entry
# exists for the obj_type. only-one ought to be typical.
# this may need to be removed after a compatability period.
if alias_obj_type == 'alias':
# there should be only one alias table for this obj_type
aliases = mi.alias_obj_type_xref[obj_type]
if len(aliases) != 1:
print self.error_msg("Internal more than one alias choice")
alias_obj_type = aliases[0]
obj = self.get_current_mode_obj()
alias_key = mi.pk(alias_obj_type)
#
# create row for table with foreign key
# find the name of the field which is the foreign key...
foreign_field = mi.alias_obj_type_field(alias_obj_type)
if not foreign_field:
print self.error_msg("internal handle_alias: alias_obj_type_field")
return None
#
# delete the current alias if it exists
try:
exists = self.get_object_from_store(alias_obj_type, alias_value)
if len(exists):
self.rest_delete_object(alias_obj_type, alias_value)
except:
pass
try:
create_dict = { alias_key : alias_value, foreign_field : obj }
self.rest_create_object(alias_obj_type, create_dict)
errors = None
except Exception, e:
errors = self.rest_error_to_dict(e, alias_obj_type)
if errors:
return self.error_msg("could not create %s for %s (%s): %s" %
(alias_obj_type, alias_value, obj_type,
self.rest_error_dict_to_message(errors)))
#
# remove other existing alias for the same foreign key
# find any other alias for this config object, then remove them
#
try:
rows = self.get_table_from_store(alias_obj_type,
foreign_field,
obj,
"exact")
except Exception, e:
errors = self.rest_error_to_dict(e, alias_obj_type)
print self.rest_error_dict_to_message(errors)
rows = []
#
#
for row in rows:
#
# skip the entry which was just inserted
if row[alias_key] == alias_value and row[foreign_field] == obj:
continue
try:
self.rest_delete_object(alias_obj_type, row[alias_key])
self.warning("removed other alias '%s' for %s '%s'" %
(row[alias_key], foreign_field, row[foreign_field]))
except:
pass
return None
#
# --------------------------------------------------------------------------------
# update_foreign_key
# Given an obj_type, its primary key name, and the old and new
# id values, find any associated tables which have foreign keys
# associated with this table, and update the foreign key so that
# the table again points to a valid id.
#
# its unlikely, although not impossible, for the foreign key
# update to need to cascade.
#
def update_foreign_key(self, obj_type, obj_key, old_id, new_id):
if obj_type in mi.foreign_key_xref and \
obj_key in mi.foreign_key_xref[obj_type]:
for (fk_obj_type, fk_name) in mi.foreign_key_xref[obj_type][obj_key]:
#
# find any affected rows
try:
rows = self.get_table_from_store(fk_obj_type,
fk_name,
old_id,
"exact")
except:
rows = []
key = mi.pk(fk_obj_type)
for row in rows:
self.warning("updating %s key %s field %s to %s" % \
(fk_obj_type, row[key], fk_name, new_id))
try:
self.rest_update_object(fk_obj_type,
key,
row[key],
{ fk_name : new_id })
errors = None
except Exception, e:
errors = self.rest_error_to_dict(e, fk_obj_type)
if errors:
print self.rest_error_dict_to_message(errors)
#
# --------------------------------------------------------------------------------
# handle_field
#
# handle_field calls itself recursively to parse fields and build
# a field dict. It then passes the field dict to one rest call.
#
def handle_field(self, words, accumulated_data=None):
if accumulated_data is None:
accumulated_data = {}
if len(words) < 2:
return self.error_msg("incorrect number of args (must be <field> <value>)")
obj_type = self.get_current_mode_obj_type()
obj = self.get_current_mode_obj()
last_word = 2
field = words[0]
value = words[1]
# complete the field if needed
field_choices = self.fields_for_current_submode_starting_with(words[0])
# LOOK!: robv: Fix to work with a field names which is a prefix of another
if len(field_choices) > 1:
for field_choice in field_choices:
if field_choice == words[0]:
field_choices = [field_choice]
break
if len(field_choices) > 1:
return "Multiple matches for field name %s." % field
if len(field_choices) == 0:
return self.error_msg("%s has no field named %s." % (obj_type, field))
field = field_choices[0]
#
# handle special case alias's which aren't understood via xref
# (this is because vns-interface-rule doesn't foreignKey neigther
# switch or mac references to the switch/host tables)
#
if obj_type == 'vns-interface-rule' and field == 'switch':
if not self.DPID_RE.match(value):
alias_value = alias_lookup('switch-alias', value)
if alias_value:
value = alias_value
else:
return "Syntax: Unknown switch alias '%s'; Specify switch as DPID or alias" % value
if obj_type == 'vns-interface-rule' and field == 'mac':
if not self.MAC_RE.match(value):
alias_value = alias_lookup('host-alias', value)
if alias_value:
value = alias_value
else:
return "Syntax: Unknown host alias '%s'; Specify host as MAC or alias" % value
#
# Replace common type values with expected types, for example true or false
# for True/False.
if mi.is_field_boolean(self.get_current_mode_obj_type(), field):
if value.lower() == 'false':
value = 'False'
elif value.lower() == 'true':
value = 'True'
#
elif mi.is_hex_allowed(obj_type, field) and self.HEX_RE.match(value):
value = str(int(value, 16))
#
# Look up any validation or value changing callouts...
validate = mi.field_validation(self.get_current_mode_obj_type(), field)
if validate:
validate_error = validate(obj_type, field, value)
if validate_error:
return validate_error
accumulated_data[field] = value
ret_val = None
if len(words) > last_word:
# more to munch
ret_val = self.handle_field(words[last_word:], accumulated_data)
else:
# munched everything, now update
obj_key = mi.pk(obj_type)
prepare_update = mi.obj_type_prepare_row_update(obj_type)
if prepare_update:
accumulated_data = prepare_update(obj_type, obj_key, obj,
accumulated_data)
# in case the obj_type's key is updated
obj = accumulated_data[obj_key]
#
# Note: if all the fields for a row are all manually reverted
# to a default value, perhaps the row ought to be deleted.
errors = None
try:
self.rest_update_object(obj_type, obj_key, obj, accumulated_data)
except Exception, e:
errors = self.rest_error_to_dict(e, obj_type)
if errors:
ret_val = self.rest_error_dict_to_message(errors)
else:
#
# if the primary key was part of the update. find relatred
# tables and update the foreign key. XXX perhaps this is
# the rest api's problem?
#
if obj_key in accumulated_data and \
accumulated_data[obj_key] != obj:
self.update_foreign_key(obj_type, obj_key, obj,
accumulated_data[obj_key])
#
# delete the old key.
self.rest_delete_object(obj_type, obj)
#
# move the the current id
self.set_current_mode_obj(accumulated_data[obj_key])
return ret_val
#
# --------------------------------------------------------------------------------
# convert_hex_to_decimal
# Review the contents of all the values, looking for hex
# valued fields. When a hex value is identified, change
# it to decimal when 'is_hex_allowed' is true.
#
def convert_hex_to_decimal(self, obj_type, field_dict):
for key in field_dict.keys():
if mi.is_hex_allowed(obj_type, key) and \
self.HEX_RE.match(field_dict[key]):
field_dict[key] = int(field_dict[key], 16)
#
# --------------------------------------------------------------------------------
# handle_obj_type
# In config mode, this handles if first word is an object-type
# (ex: "flow-entry catch-web")
#
def handle_obj_type(self, words):
if len(words) < 2:
return "Syntax: %s <key>: where key is an id of %s" % (words[0], words[0])
(obj_type, obj_name) = (words[0], words[1])
obj_name = convert_alias_to_object_key(obj_type, obj_name)
# First check if this is something we can actually configure
if obj_type not in mi.obj_types:
return self.error_msg("unknown command or object.")
# Next, find the object
# Deal with any changes to the lookup name based on the 'concatenation'
# of the config mode name to the named identifer.
#
found_obj = self.get_obj_of_type(obj_type, obj_name)
if found_obj == None:
# need to create object, obj_data is the rest api dictionary used
# to create the new row.
obj_data = { mi.pk(obj_type): obj_name }
if self.in_config_submode():
# add in all the key value from modes in the stack
# LOOK! this is brittle as it depends on the name of
# the mode matching the name of the attribute.
#
obj_data = self.mode_stack_to_rest_dict(obj_data)
#
self.convert_hex_to_decimal(obj_type, obj_data)
# make sure all the foreign keys are populated
#
for key in mi.obj_type_foreign_keys(obj_type):
if not key in obj_data:
print self.error_msg("foreign key '%s' missing from mode stack %s" %
(key, obj_data))
prepare_update = mi.obj_type_prepare_row_update(obj_type)
if prepare_update:
obj_data = prepare_update(obj_type,
mi.pk(obj_type), obj_name,
obj_data)
# create the object
errors = None
try:
self.rest_create_object(obj_type, obj_data)
except Exception, e:
errors = self.rest_error_to_dict(e, obj_type)
if errors:
return self.rest_error_dict_to_message(errors)
# get it back, populating found_obj
found_obj = self.get_obj_of_type(obj_type, obj_name)
# push on the submode for the object
# LOOK! assumes all object commands drop you into a submode...
if found_obj:
sub_mode = "config-%s" % obj_type
self.push_mode(sub_mode, obj_type, obj_name)
# hand off the rest of the line to handle_field
if len(words) > 2:
return self.handle_field(words[2:])
else:
return self.error_msg("No %s with %s = %s" %
(obj_type, mi.pk(obj_type), obj_name))
#
# --------------------------------------------------------------------------------
# print_completion_help
#
def print_completion_help(self, completion_help_text):
origline = readline.get_line_buffer()
end = readline.get_endidx()
cur_command = origline[0:end]
help_text = "\n%s\n%s%s" % ( completion_help_text,
self.prompt,
cur_command)
self.completion_skip = True
sys.stdout.write(help_text)
#
# --------------------------------------------------------------------------------
# get_ip_from_switch_dpid_or_alias
# Returns the IP associated with the switch if it exists
# or the original string if it's not a dpid or alias.
#
def get_ip_from_switch_dpid_or_alias(self, alias):
dpid = convert_alias_to_object_key("switches", alias)
if self.DPID_RE.match(dpid):
query_dict = { 'dpid' : dpid }
row = rest_to_model.get_model_from_url('switches', query_dict)
if len(row) >= 1:
if not 'ip-address' in row[0] or row[0].get('ip-address') == '':
return self.error_msg("switch %s currently not connected "
% alias)
return row[0].get('ip-address')
return alias
#
# --------------------------------------------------------------------------------
# implement_write
#
def implement_write(self, words):
if len(words) == 1:
if "memory".startswith(words[0]):
return self.implement_copy(["running-config", "startup-config"])
elif "erase".startswith(words[0]):
print "This will clear the startup-config and set it to be empty."
resp = raw_input("Are you sure that want to proceed? [n]")
if resp and "yes".startswith(resp.lower()):
print "Erasing startup config ..."
result = self.store.delete_user_data_file("startup-config/time/len/version")
if 'status' in result and result['status'] == 'success':
return None
elif 'message' not in result:
return self.error_msg("rest store result doesn't contain error message")
else:
return self.error_msg(result['message'])
else:
print "Command aborted by user: write erase"
return
elif "terminal".startswith(words[0]):
return self.implement_copy(["running-config", "terminal"])
return "Syntax: write < terminal | memory | erase>"
#
# --------------------------------------------------------------------------------
#
@staticmethod
def set_clock_action(data):
time_values = data['time'].split(':')
if len(time_values) != 3:
raise error.CommandError('Invalid time; must be HH:MM:SS')
hour = int(time_values[0])
minute = int(time_values[1])
second = int(time_values[2])
MONTH_NAMES = ('January', 'February', 'March', 'April', 'May', 'June',
'July', 'August', 'September', 'October', 'November', 'December')
day_of_month = int(data['day-of-month'])
month_name = data['month']
if month_name not in MONTH_NAMES:
raise error.CommandError('Invalid month name (e.g. January, May, July)')
month = MONTH_NAMES.index(month_name) + 1
year = int(data['year'])
date_time_info = {
'year': year,
'month': month,
'day': day_of_month,
'hour': hour,
'minute': minute,
'second': second
}
url = 'http://%s/rest/v1/system/clock/local' % cli.controller
result = cli.store.rest_post_request(url, date_time_info)
date_time_info = json.loads(result)
clock_string = SDNSh.get_clock_string(date_time_info, False)
return clock_string
#
# --------------------------------------------------------------------------------
# get_misconfigured_default_gateway
#
@staticmethod
def get_misconfigured_default_gateway():
"""
Determine if the controller is configured with a default gateway
setting that doesn't match (i.e. is not on the same subnet)
any of the interfaces configured with static IP addresses.
This is used by the begin_default_gateway_check_action and
end_default_gateway_check_action actions that check if a command
results in a misconfigured default gateway setting and, if so,
emit an error message.
If the default gateway is misconfigured, the return value is the
default gateway value. Otherwise, the return value is None.
"""
# First figure out which controller-node we're working with.
# This is a little kludgy right now. We check the mode stack
# looking for a controller node element.
controller_id = cli.get_nested_mode_obj('controller-node')
if not controller_id:
raise error.CommandDescriptionError('check_default_gateway_action must be called from a (possibly nested) controller node config mode')
controller = cli.get_object_from_store('controller-node', controller_id)
if not controller:
# This shouldn't really happen unless someone/thing has mucked with the
# controller object out from under this instance of the CLI
# but just to be safe...
raise error.CommandInvocationError('Current controller settings have been deleted.')
# Check if the controller node is configured with a default gateway.
# If not, then there's no possible misconfiguration and we're done.
default_gateway = controller.get('default-gateway')
if default_gateway == '':
return
# There is a default gateway configured, so we need to check if there's
# an interface that matches (i.e. is on the same subnet as) the default
# gateway
interfaces = cli.rest_query_objects('controller-interface', {'controller': controller_id})
for interface in interfaces:
mode = interface.get('mode')
if mode == 'static':
ip = interface.get('ip')
netmask = interface.get('netmask')
if (ip != '') and (netmask != '') and same_subnet(default_gateway, ip, netmask):
return None
return default_gateway
#
# --------------------------------------------------------------------------------
# check_default_gateway_action
#
@staticmethod
def begin_default_gateway_check_action():
"""
This is an action proc for the data-driven command module that is used
in conjunction with the end_default_gateway_check_action to check if a
CLI command results in an improperly configured default gateway setting.
Currently the backend code that maps the network/interface settings
for the controller to the /etc/network/interfaces file will only
apply the default gateway setting if it's on the same subnet as an
interface that's configured with a static IP address/netmask.
So if there's no interface that matches the default gateway (either
because it's configured to use DHCP or the subnet doesn't match)
then the default gateway setting will be ignored and we want to warn
the user about the misconfiguration. The check should be performed
on any configuration change that could affect this check. This includes:
1) setting the default gateway
2) setting the mode of an interface to DHCP
3) setting/resetting the ip/netmask of an interface
4) deleting an interface
We only want to emit the warning if the default gateway was previously
not misconfigured and the current command resulted in a misconfiguration,
so we want to check for a misconfiguration before applying the command
and then check again after the settings have been updated. The
begin_default_gateway_check_action is the action that is performed before
the settings are updated and the corresponding end_default_gateway_check_action
action is the one that is performed after the settings are updated.
LOOK!: Ideally we should be doing this check in the sdncon code instead
of here in the CLI code. That way the warning would also be returned
for clients that are changing these settings directly via the REST
API instead of via the CLI. But there isn't a really good mechanism
currently for the REST API to return a warning but still apply the
config change.
"""
# Stash away if the gateway setting was already misconfigured at the
# beginning of the current command.
# LOOK! This is a bit kludgy to stash this away in the CLI object.
# When the command module action API is changed to allow access to the
# context, this code should be updated to stash the value in the context
# instead of the CLI.
cli.begin_misconfigured_default_gateway = SDNSh.get_misconfigured_default_gateway()
@staticmethod
def end_default_gateway_check_action():
"""
This is an action proc for the data-driven command module that is used
in conjunction with the begin_default_gateway_check_action to check if a
CLI command results in an improperly configured default gateway setting.
Check the doc comments for begin_default_gateway_check_action for more
details about how the two actions are intended to be used.
"""
end_misconfigured_default_gateway = SDNSh.get_misconfigured_default_gateway()
if (end_misconfigured_default_gateway and
(end_misconfigured_default_gateway != cli.begin_misconfigured_default_gateway)):
return ('The controller is configured with a default gateway setting (%s), that\n'
'is not on the same subnet as any of the interfaces configured to use a\n'
'static IP address. The default gateway setting will be ignored.' %
end_misconfigured_default_gateway)
#
# --------------------------------------------------------------------------------
# load_time_zone_list
# Use the rest api to collect all the known time zones
#
@staticmethod
def load_time_zone_list():
if not cli.time_zone_list:
url = "http://%s/rest/v1/system/timezones/all" % cli.controller
cli.time_zone_list = cli.rest_simple_request_to_dict(url)
#
# --------------------------------------------------------------------------------
# time_zone_completion
#
@staticmethod
def time_zone_completion(words, text, completions):
SDNSh.load_time_zone_list()
completion_dict = {}
tz_completions = []
for tz in cli.time_zone_list:
if tz.lower().startswith(text.lower()):
tz_completions.append(tz)
for index in range(len(text), len(tz)):
if tz[index] == '/':
tz = tz[:index+1]
break
completion_dict[tz] = 'Timezone Choice'
if len(completion_dict) >= 1:
completions.update(completion_dict)
#
# --------------------------------------------------------------------------------
# time_zone_validation
#
@staticmethod
def time_zone_validation(typedef, value):
SDNSh.load_time_zone_list()
if value not in cli.time_zone_list:
raise error.ArgumentValidationError('Invalid time zone')
#
# --------------------------------------------------------------------------------
# cp_clock
#
@staticmethod
def cp_clock(words, text, completion_char):
return command.do_command_completion(words, text)
#
# --------------------------------------------------------------------------------
# do_clock
#
@staticmethod
def do_clock(words):
return command.do_command(['clock'] + words)
#
# --------------------------------------------------------------------------------
# do_show_clock
#
def cp_show_clock(self, words, text, completion_char):
if len(words) == 1 and 'detail'.startswith(text.lower()):
return ['detail']
@staticmethod
def get_clock_string(time_info, detail = None):
# The tz item contains the abbreviated time zone string (e.g. PST, EST)
# This is different from the full time zone string (e.g. America/Los_Angeles)
# which we get from the controller-node object below when we're showing
# detail info.
tz = time_info['tz']
del time_info['tz']
dt = datetime.datetime(**time_info)
if detail:
time_info['tz'] = tz
# Arista-style format
#show_result = dt.strftime('%c')
# Cisco-style format
clock_string = dt.strftime('%H:%M:%S '+ tz + ' %a %b %d %Y')
return clock_string
#
# --------------------------------------------------------------------------------
# do_show_clock
#
@staticmethod
def do_show_clock(words):
syntax_help = "Syntax: show clock [detail]"
if len(words) == 0:
detail = False
elif len(words) == 1:
if not 'detail'.startswith(words[0].lower()):
return syntax_help
detail = True
else:
return syntax_help
url = "http://%s/rest/v1/system/clock/local/" % cli.controller
time_info = cli.rest_simple_request_to_dict(url)
clock_string = SDNSh.get_clock_string(time_info, detail)
return clock_string
#
# --------------------------------------------------------------------------------
# cp_show_vns
#
def cp_show_vns(self, words, text, completion_char):
if len(words) == 1:
return objects_starting_with('vns-definition', text)
elif len(words) == 2:
return [x for x in
[ 'interface', 'mac-address-table', 'interface-rules', \
'access-lists', 'running-config', 'switch', 'flow' ]
if x.startswith(text)]
elif len(words) == 3 and 'switch'.startswith(words[2]):
return objects_starting_with("switch", text)
elif (len(words) >= 3) and (words[2] == 'flow'):
return self.cp_show_vns_flow(words, text)
else:
self.print_completion_help("<cr>")
#
# --------------------------------------------------------------------------------
# show_vns_definition_running_config
# Display the vns-definition -- the interface rules for the vns.
#
def show_vns_definition_running_config(self, config, vns_name,tenant=None,indent=0):
if tenant==None and vns_name!='all':
vns_id='default|'+vns_name
else:
vns_id=tenant +'|'+vns_name
try:
vns = self.get_object_from_store('vns-definition', vns_id)
except:
return self.error_msg('no vns named %s' % vns_name)
config.append(' ' *2*indent + "vns-definition %s\n" % vns_name)
run_config.running_config_vns_details(config, vns, indent+1)
vns_rules = None
try:
vns_rules = self.get_table_from_store('vns-interface-rule',
'vns', vns_id, "exact")
except Exception:
pass
if vns_rules:
run_config.running_config_vns_if_rule(config,
vns_rules,indent+1)
#
# --------------------------------------------------------------------------------
# show_vns_running_config
# In the larger 'running-config' for vns, the complete vns tables are read
# since the complete 'running-config' will display all the data from the
# fields. Here, the tables are searched only for specific vns entries.
#
# The procedure's name is choosen carefully, since its not intended to
# part of any of show command, completion, or command processing
#
def show_vns_running_config(self, vns_name, tenant=None, indent=0):
config=[]
preconfig=[' '*2*indent +"vns %s\n" % vns_name]
if tenant==None and vns_name!='all':
vns_name='default|'+vns_name
if tenant!=None:
vns_name=tenant+'|'+vns_name
try:
self.get_object_from_store('vns-definition', vns_name)
except:
return self.error_msg('no vns named %s' % vns_name)
vns_acls = []
try:
vns_acls = self.get_table_from_store('vns-access-list',
'vns', vns_name, 'exact')
except Exception, e:
pass
for acl in vns_acls:
# note use of key initialized above
vns_acl_entries = None
try:
vns_acl_entries = self.get_table_from_store('vns-access-list-entry',
'vns-access-list',
acl['id'],
'exact')
except Exception:
pass
run_config.running_config_vns_acl(config, vns_name, acl, vns_acl_entries,indent+1)
vns_interface_acl = None
try:
vns_interface_acl = self.get_table_from_store('vns-interface-access-list')
except Exception:
pass
for vns_if in run_config.running_config_active_vns_interfaces(vns_name, vns_interface_acl):
config.append(' ' *2*(indent+1) + "interface %s\n" % vns_if)
run_config.running_config_vns_if_and_access_group(config,
vns_name,
vns_if,
vns_interface_acl,indent+2)
if len(config) > 0:
config = preconfig + config
return ''.join(config)
#generate tenant xxx running config
def show_tenant_running_config(self, config, tenant_name):
try:
tenants = self.get_object_from_store('tenant', tenant_name)
except:
return self.error_msg('no tenant named %s' % tenant_name)
config.append("!\ntenant %s\n" % tenant_name)
run_config.running_config_tenant_details(config,tenants)
try:
vnses = self.get_table_from_store('vns-definition','tenant',tenant_name,"exact")
except Exception:
vnses = {}
pass
try:
virtual_routers = self.get_table_from_store('virtualrouter','tenant', tenant_name, "exact")
except Exception:
virtual_routers = {}
pass
for vns in vnses:
vns_name=vns['vnsname']
self.show_vns_definition_running_config(config, vns_name, tenant=tenant_name,indent=1)
config += self.show_vns_running_config(vns_name, tenant=tenant_name,indent=1)
for virtual_router in virtual_routers:
virtual_router_name=virtual_router['vrname']
virtual_router_id=virtual_router['id']
config.append(" router %s\n" % virtual_router_name)
run_config.running_config_tenant_router_details(config,virtual_router,indent=1)
try:
vr_interfaces = self.get_table_from_store('virtualrouter-interface','virtual-router', virtual_router_id, "exact")
except Exception:
vr_interfaces = {}
pass
try:
vr_routes = self.get_table_from_store('virtualrouter-routingrule','virtual-router', virtual_router_id, "exact")
except Exception:
vr_routes = {}
pass
try:
vr_gwpools = self.get_table_from_store('virtualrouter-gwpool','virtual-router', virtual_router_id, "exact")
except Exception:
vr_gwpools = {}
pass
for vr_interface in vr_interfaces:
run_config.running_config_router_interface_details(config,vr_interface,indent=2)
for vr_route in vr_routes:
run_config.running_config_router_rule_details(config,vr_route,indent=2)
for vr_gwpool in vr_gwpools:
run_config.running_config_router_gwpool_details(config,vr_gwpool,indent=2)
#
# --------------------------------------------------------------------------------
# switch_port_match
# Return True when the port matches a port specirfication "pattern"
#
# The port specification of an interface rule is a command separated list,
# which can contain a tail of "-<d>". That tail describes a range.
# With a port range, determine whether or not the 'port' parameter
# is a match.
#
def switch_port_match(self, port, pattern):
# XXX validate port is something which ends in a number?
for field in pattern.split(','):
m = re.match(r'^([A-Za-z0-9-]*?)(\d+)-(\d+)$', pattern)
if not m:
if field == port:
return True
continue
prefix = m.group(1)
startport = int(m.group(2))
endport = int(m.group(3))
if not port.startswith(prefix):
continue
tail = port[len(prefix):]
if not self.DIGITS_RE.match(tail):
print self.error_msg("port name tail %s must be all digits" % tail)
continue
m = re.search(r'(\d+)$', port)
if not m:
continue
port = m.group(1)
if int(port) >= int(startport) and int(port) <= int(endport):
return True
else:
print self.error_msg("port %s out of port-spec range %s-%s" %
(port, startport, endport))
return False
#
# ---------------------------------------------------------------------------
# cp_show_event_history
# Command completion for the following command to see
# last <n> events of <name> events
# Used in "show event-history <name> [ last <n> ]"
#
def cp_show_event_history(self, words, text, completion_char):
options = ['attachment-point',
'packet-in',
'topology-link',
'topology-switch',
'topology-cluster',
# Add more event history options above this line
# Add the same item in do_show_event_history() below also
]
completion_help = ''
for op in options:
ev_help = '%s show %s events\n' % (op, op)
completion_help = completion_help + ev_help
# syntax: show event-history <name> [ last <n> ]
if (len(words) == 1) and text=='':
self.print_completion_help(completion_help)
return options
elif (len(words) == 1):
return [op for op in options if op.startswith(text)]
elif (len(words) == 2):
if text == '':
self.print_completion_help("last Show lastest <n> events\n" +
"<cr> Enter")
return ['last', '<cr>']
elif "last".startswith(text):
return ["last"]
elif (len(words) == 3):
self.print_completion_help("<number> Enter number of latest events to display (1-10000)")
return range(0, 10000)
else:
self.print_completion_help('<cr>')
#
# --------------------------------------------------------------------------
# do_show_event_history
#
# Show the event history of the specified events
# Syntax: show event-history <event-history-name> [last <count>]
# <event-history-name> is words[0], <count> is words[2]
#
def do_show_event_history(self, words):
self.debug_msg("do-show-event-history words: %s" % words)
# Check syntax of the command
syntax = self.syntax_msg('show event-history <name> [ last <n> ]')
options = ['attachment-point',
'packet-in',
'topology-link',
'topology-switch',
'topology-cluster',
# Add more event history options above this line
# Add the same item in do_cp_event_history() above also
]
if (words[0] not in options):
yield("Event history name %s not found" % words[0])
return
if (len(words) >= 3) and (words[1] != 'last'):
yield(syntax)
return
if (len(words) == 2) or (len(words) > 4):
yield(syntax)
return
if (len(words) >= 3) and (not words[2].isdigit()):
yield(syntax)
return
if (len(words) >= 3) and (words[2].isdigit()):
count = int(words[2])
if (count < 1) or (count > 10000):
yield("Number of events must be between 1 and 10000")
return
last_n_count = 1024 # default
if (len(words) >= 3):
last_n_count = words[2]
ev_hist_name = words[0]
ev_hist_field_name = 'ev-hist-' + ev_hist_name
url = 'http://%s/rest/v1/event-history/%s/%s' % \
(self.controller, ev_hist_name, last_n_count)
ev_hist = self.rest_simple_request_to_dict(url)
#ev_hist - json.dumps(ev_hist)
events = ev_hist['events']
tableData = []
for ev in events:
info = ev['info']
base_info = ev['base_info']
info.update(base_info)
tableData.append(info)
# Prepare the date for CLI display
tableData = self.pp.format_table(tableData, ev_hist_field_name)
yield("\n")
yield(tableData)
#
# -------------------------------------------------------------------------------
# cp_show_vns
# Command completion for the following command
# Used in "show vns { <vns-name> | all } flow [ brief | full-detail | detail | summary ]
#
def cp_show_vns_flow(self, words, text, completion_char):
cmd1 = 'brief show flow information in brief format'
cmd2 = 'detail show detailed flow information'
cmd3 = 'full-detail show full details of flow information'
cmd4 = 'summary show summarized flow information'
syntax = self.syntax_msg('show vns {<vns-name> | all} flow [ brief | detail | full-detail | summary ]')
if (len(words) == 3) and text=='':
self.print_completion_help(cmd1+'\n'+cmd2+'\n'+cmd3+'\n'+cmd4)
return ['brief', 'detail', 'full-detail', 'summary', '<cr>' ]
elif (len(words) == 3) and ('detail'.startswith(text)):
return ['detail']
elif (len(words) == 3) and ('full-detail'.startswith(text)):
return ['full-detail']
elif (len(words) == 3) and ('summary'.startswith(text)):
return ['summary']
elif (len(words) == 3) and ('brief'.startswith(text)):
return ['brief']
elif (len(words) == 4) and (words[3] not in ['brief', 'detail', 'full-detail', 'summary']):
self.print_completion_help(syntax)
elif (len(words) >= 3) and (text != ''):
self.print_completion_help(syntax)
else:
self.print_completion_help('<cr>')
#
# --------------------------------------------------------------------------------
# show_vns_flow_annotated
#
# For a given vns-name, show all the active flows in that vns
# or
# for show active-flows in all vnses, categorized by vns
# Used in "show vns { <vns-name> | all } flow [ brief | full-detail | detail | summary ]
# flow records are annotated in the sdnplatform with vns name
#
def show_vns_flow_annotated(self, words):
syntax = self.syntax_msg('show vns {<vns-name> | all} flow [ brief | detail | full-detail |summary ]')
if (len(words) == 3) and (words[2] not in ['brief', 'details', 'full-detail', 'summary']):
print syntax
return
if (len(words) > 3):
print syntax
return
# all = False is this used anywhere
vns = words[0]
option = 'none'
if (len(words) == 3):
option = words[2]
# Get all the flows in the network
annotated_flow_data = {}
url = 'http://%s/rest/v1/vns/realtimestats/flow/%s' % (self.controller, vns)
annotated_flow_data = self.rest_simple_request_to_dict(url)
#print "Data=%s" % json.dumps(annotated_flow_data, sort_keys=True, indent=4)
# annotated_flow_data response is in the following format:
# Data={
# "vnsCount": 1,
# "vnsFlowMap": {
# "two": {
# "flowCount": 10,
# "flowList": [
# {
# "dpid": "00:00:00:00:00:00:00:0f",
# "flowEntry": {
# "actions": [
# {
# vnsCount = annotated_flow_data["vnsCount"]
vnsFlowMap = annotated_flow_data["vnsFlowMap"]
vnsAddressSpaceMap = annotated_flow_data["vnsAddressSpaceMap"]
if (option == "brief"):
table_field_ordering = "vns_flow"
elif (option == "detail"):
table_field_ordering = "details"
elif (option == "full-detail"):
table_field_ordering = "undefined" # prints everything!
elif (option == "summary"):
table_field_ordering = "summary"
else:
table_field_ordering = "default"
summaryTable = [] # used for holding the data for "summary" option
for vnsName in vnsFlowMap:
if (option == 'brief') or (option == "summary"):
flow_tuple_list = []
briefFlowCnt = 0
# Table Data will hold all the flow entries, one list element per row of output
# It is reinitilized for each VNS
tableData = []
vnsFlowCnt = vnsFlowMap[vnsName]["flowCount"]
vnsFlowList = vnsFlowMap[vnsName]["flowList"]
for vnsFlowEntry in vnsFlowList:
flowEntry = vnsFlowEntry["flowEntry"]
dpid = vnsFlowEntry["dpid"]
if (option == "brief") or (option == "summary"):
src_mac = flowEntry['match']['dataLayerDestination']
dst_mac = flowEntry['match']['dataLayerSource']
vlan = flowEntry['match']['dataLayerVirtualLan']
etherType = flowEntry['match']['dataLayerType']
flowList = []
flowList.append(src_mac)
flowList.append(dst_mac)
flowList.append(vlan)
flowList.append(etherType)
if flowList in flow_tuple_list:
# duplicate flow (due to same flow entry on multiple switches along the path,
# skip it if the option if brief or summary
continue
else:
flow_tuple_list.append(flowList)
briefFlowCnt += 1
#print "DPID = %s" % dpid
#print " New Data = %s" % json.dumps(flowEntry, indent=4)
if (option != "summary"):
tableEntry = {}
tableEntry[dpid] = []
tableEntry[dpid].append(flowEntry)
tableEntry = self.add_dpid_to_data(tableEntry)
tableEntry = self.fix_realtime_flows(tableEntry)
#print "Table Entry : %s" % json.dumps(tableEntry, indent=4)
tableData.append(tableEntry[0])
#print "*** Table Data: %s" % json.dumps(tableData[0], indent=4)
#printf tenant + vnsname
names=vnsName.split('|')
tenant=names[0]
vns=names[1]
if (option == "brief"):
yield("\nTenant %s VNS %s (address-space %s) flows (count: %s)" % (tenant, vns, vnsAddressSpaceMap[vnsName], briefFlowCnt))
elif (option != "summary"):
yield("\nTenant %s VNS %s (address-space %s) flow entries (count: %s)" % (tenant, vns, vnsAddressSpaceMap[vnsName], vnsFlowCnt))
# Print flow data for one vns, unless option is summary
if (option == "summary"):
summaryData = dict()
# summaryData['tenant'] =tenant
summaryData["vnsName"] = vns
summaryData["flowEntryCnt"] = vnsFlowCnt
summaryData["vnsFlowCnt"] = briefFlowCnt
summaryTable.append(summaryData)
else:
yield("\n")
# print "*** TD = %s" % tableData
tableData = self.pp.format_table(tableData, "realtime_flow", table_field_ordering)
yield(tableData)
if (option == "summary"):
# print "*** ST %s" % summaryTable
yield("\n")
summaryTable = self.pp.format_table(summaryTable, "realtime_flow", table_field_ordering)
yield(summaryTable)
print(" ")
return
#
# --------------------------------------------------------------------------------
# show_vns_switch_ports
# For some vns-name, collect all the interfaces, and from that,
# collect all the attachment points. The objective here is to
# name all the switch's and ports associated with a vns
#
def show_vns_switch_ports(self, words):
if len(words) < 1:
return
# words: [ vns_name, 'switch', switch_name ]
vns_name = words[0]
switch = None
if len(words) > 2:
switch = convert_alias_to_object_key('switch', words[2])
port = None
if len(words) > 3:
port = words[3]
vns_interface_key = mi.pk('vns-interface')
if vns_name == 'all':
vns_ifs = create_obj_type_dict('vns-interface',
vns_interface_key,
'id')
vns_rules = create_obj_type_dict('vns-interface-rule',
mi.pk('vns-interface-rule'),
'id',)
else:
vns_ifs = create_obj_type_dict('vns-interface',
vns_interface_key,
'vns',
vns_name)
vns_rules = create_obj_type_dict('vns-interface-rule',
mi.pk('vns-interface-rule'),
'vns',
vns_name)
host_dap_dict = self.create_attachment_dict()
bsp = {} # _b_vs _s_witch _p_ort
for ifs in vns_ifs:
fields = ifs.split('|')
# all these fields must have two parts.
if len(fields) != 3:
continue
# choose between switch based rules and mac/ip based rules
rule = 'default'
vns_name = vns_ifs[ifs][0]['vns']
switch_rule = None
if fields[1] != 'default':
rule = vns_ifs[ifs][0]['rule']
if not rule in vns_rules:
continue
if_rule = vns_rules[rule][0]
if 'switch' in if_rule:
switch_rule = if_rule['switch']
else:
if_rule = { 'mac' : 'defaultLie' } # for default rules
# There's two major classes of rules: host and switch
# Use existance of a 'switch' to differentiate between the two.
if switch_rule:
# if_rule/switch are both set, part after the '/' is the port
if fields[2].find('/') < 0:
# skip Eth<n> general interface
continue
#
# Prefix this port with a plus sign, which will be recognized
# in the printing code as already describing an openflow port name
port = '+' + fields[2].split('/')[1]
tenant_vns=vns_name.split('|')
tenant_name=tenant_vns[0]
vns_real_name=tenant_vns[1]
key = "%s|%s|%s|%s" % (tenant_name,vns_real_name, switch, port)
if not key in bsp:
bsp[key] = {
'tenant' : tenant_name,
'vns' : vns_real_name,
'switch' : switch_rule,
'port' : port,
'reason' : ["Rule:%s" % rule.split('|')[-1], fields[1]],
}
else:
pass # should only be one.
else:
# the second part (fields[1]) is the interface-long name,
items = fields[2].split('/')
if len(items) == 1:
if items[0].startswith('VEth'):
if not 'mac' in rule:
continue
mac = if_rule['mac']
elif items[0].startswith('Eth'):
self.debug_msg('should have been a switch in if_rule')
continue
else:
self.debug_msg('item length of 1')
continue
else:
mac = items[1]
if not re.match(r'^(([A-Fa-f\d]){2}:?){5}[A-Fa-f\d]{2}$', mac):
print 'Not a mac address: %s' % mac
# currently just use the mac to find the attachment points.
if mac in host_dap_dict:
for attachment_point in host_dap_dict[mac]:
# if switch is named, skip any which don't match
if switch and attachment_point['switch'] != switch:
continue
if port and attachment_point['ingress-port'] != port:
continue
tenant_vns=vns_name.split('|')
tenant_name=tenant_vns[0]
vns_real_name=tenant_vns[1]
key = "%s|%s|%s|%s" % (tenant_name,
vns_real_name,
attachment_point['switch'],
attachment_point['ingress-port'])
if not key in bsp:
bsp[key] = {
'tenant' : tenant_name,
'vns' : vns_real_name,
'switch' : attachment_point['switch'],
'port' : utif.try_int(attachment_point['ingress-port']),
'reason' : ["Rule:%s" % rule.split('|')[-1], mac]
}
else:
self.append_when_missing(bsp[key]['reason'],
"Rule:%s" % rule.split('|')[-1])
self.append_when_missing(bsp[key]['reason'], mac)
sort = [bsp[x] for x in sorted(bsp.keys(),
cmp=lambda a,b: cmp(utif.try_int(a.split('|')[2]),
utif.try_int(b.split('|')[2]))
if a.split('|')[1] == b.split('|')[1]
else cmp(b.split('|')[1],a.split('|')[1]))]
return self.display_obj_type_rows('vns-switch-ports', sort)
#
# --------------------------------------------------------------------------------
# show_switch_ports_vns
#
def show_switch_ports_vns(self, words):
switch = None
if len(words) > 1 and words[0] != 'all':
switch = words[0]
#
# switch alias conversion
value = alias_lookup('switch-alias', switch)
if value:
switch = value
#
# dictionary from the vns side, indexed by host.
vns_ifs_dict = create_obj_type_dict('vns-interface',
mi.pk('vns-interface'))
#
# dictionary of the interface-rules, by rule
vns_rules = create_obj_type_dict('vns-interface-rule',
mi.pk('vns-interface-rule'))
#
# from the list of hosts, identify the attachment points
host_dap_dict = self.create_attachment_dict()
#
# there can be multiple attachment points for each of the
# hosts. iterate over the hosts, find all the attachment points,
# manage an association for the entries
spb = {} # _s_witch _p_ort _b_vs
for ifs in vns_ifs_dict:
fields = vns_ifs_dict[ifs][0]['id'].split('|')
# all these fields must have two parts.
if len(fields) != 2:
continue
# id parts are vns|interface
vns_name = fields[0]
# choose between switch based rules and mac/ip based rules
rule = 'default'
switch_rule = None
mac_rule = None
rule_fields = [rule]
if vns_name == 'default':
if fields[1].find('/') >= 0:
mac_rule = fields[1].split('/')[1]
else:
if not 'rule' in vns_ifs_dict[ifs][0]:
continue
rule = vns_ifs_dict[ifs][0]['rule']
rule_fields = rule.split('|')
if_rule = vns_rules[rule][0]
if 'switch' in if_rule:
if switch and if_rule['switch'] != switch:
continue
switch_rule = if_rule['switch'] # switch may be None.
elif 'mac' in if_rule:
mac_rule = if_rule['mac']
elif 'ip-subnet' in if_rule:
mac_rule = if_rule['ip-subnet']
elif 'tags' in if_rule:
mac_rule = if_rule['tags']
elif 'vlans' in if_rule:
mac_rule = if_rule['vlans']
if mac_rule:
if not mac_rule in host_dap_dict:
self.debug_msg("Unknown attachment point for %s" % mac_rule)
continue
for attachment_point in host_dap_dict[mac_rule]:
key = "%s|%s" % (attachment_point['switch'],
attachment_point['ingress-port'])
if switch and attachment_point['switch'] != switch:
continue
if not key in spb:
spb[key] = {
'switch' : attachment_point['switch'],
'port' : utif.try_int(attachment_point['ingress-port']),
'vns' : {vns_name : 1},
'reason' : ["Rule:%s" % rule_fields[-1], mac_rule]
}
else:
if vns_name in spb[key]['vns']:
spb[key]['vns'][vns_name] += 1
else:
spb[key]['vns'][vns_name] = 1
self.append_when_missing(spb[key]['reason'],
"Rule:%s" % rule_fields[-1])
self.append_when_missing(spb[key]['reason'], mac_rule)
if switch_rule:
if fields[1].find('/') >= 0:
#
# Prefix this port with a plus sign, which will be recognized
# in the printing code as already describing an openflow port name
port = '+' + fields[1].split('/')[1]
key = "%s|%s" % (switch_rule, port)
if not key in spb:
spb[key] = {
'switch' : switch_rule,
'port' : port,
'vns' : {vns_name : 1},
'reason' : ["Rule:%s" % rule_fields[-1], fields[1]]
}
sort = [spb[x] for x in sorted(spb.keys(),
cmp=lambda a,b: cmp(utif.try_int(a.split('|')[1]),
utif.try_int(b.split('|')[1]))
if a.split('|')[0] == b.split('|')[0]
else cmp(b.split('|')[0],a.split('|')[0]))]
return self.display_obj_type_rows('switch-ports-vns', sort)
# [spb[x] for x in sorted(spb.keys())])
#
# --------------------------------------------------------------------------------
# do_show_vns
#
def do_show_vns(self, words):
choices = ['interface', 'mac-address-table',
'interface-rules', 'access-lists', 'running-config', 'switch', 'flow' ]
if words == None or len(words) > 2:
if words[1] not in ['switch', 'flow']:
return self.syntax_msg('show vns <vns-name> [ %s ] ' %
' | '.join(choices))
if len(words) in [3, 4]:
if words[1] == 'switch':
return self.show_vns_switch_ports(words)
elif words[1] == 'flow':
return self.show_vns_flow_annotated(words)
else:
return self.syntax_msg('show vns <vns-name> [ %s ] ' %
' | '.join(choices))
elif len(words) == 2:
# words[0] ought to an existing vns
# Allow show vns all flow [detail]
if (not self.vns_find_name(words[0])) and (words[1] != 'flow'):
return self.error_msg("show vns '%s': vns Not Found" % words[0])
vns_key = self.prefix_search_key([words[0]])
selection = utif.full_word_from_choices(words[1], choices)
if not selection:
return self.syntax_msg('show vns <vns-name> [ %s ' %
' | '.join(choices))
if selection == 'interface':
return self.find_and_display_vns_interface(words[0], words[2:])
elif selection == 'mac-address-table':
# the id for the host-vns-interface table has the host as the 'prefix',
# preventing searching based on the prefix. the vns is not even a foreign
# key, which means the complete table must be read, then the vns association
# must be determined, and then matched
return self.display_vns_mac_address_table(words[0], words[2:])
elif selection == 'interface-rules':
return self.do_show_object(['vns-interface-rule', vns_key], "<no_key>")
elif selection == 'access-lists':
return self.do_show_object(['vns-access-list-entry', vns_key], "<no_key>")
elif selection == 'running-config':
return self.show_vns_running_config(words[0])
elif selection == 'switch':
return self.show_vns_switch_ports(words)
elif selection == 'flow':
return self.show_vns_flow_annotated(words)
elif len(words) == 1:
return self.do_show_object(["vns-definition", words[0]])
else:
return self.do_show_object(["vns-definition"])
#
# --------------------------------------------------------------------------------
# do_show_vns_interface_rule
# do_show_object is used to construct the output for the table search.
# However, since a vns prefix key search is used to display the table,
# and since do_show_object behaves differently when displaying tables
# depending on whether the table is a key search or not, the 'with_search_key'
# parameter is set to "with_key" when the caller included an additional
# prefix for (key) for the rule, and otherwise '<no_key>' is used when
# the caller wants the complete interface-rule table for a single vns
# (which obvioulsy also implies a key search for 'vns|' prefied rules.
#
def do_show_vns_interface_rule(self, words):
with_search_key = "<no_key>"
if self.vns_name() is None:
if len(words) > 0:
search_object = ["vns-interface-rule", words[0]]
else:
search_object = ["vns-interface-rule"]
elif len(words) > 0:
with_search_key = '-'.join(words)
words.insert(0, self.vns_name())
search_object = ["vns-interface-rule",
self.unique_key_from_non_unique(words)]
else:
search_object = ["vns-interface-rule",
self.prefix_search_key([self.vns_name()]) ]
obj_type = 'vns-interface-rule'
# --- this ought to be promoted to be used more ..
s_dict = {}
# for all foreign keys in this obj_type
mode_dict = self.mode_stack_to_rest_dict({})
# for fk in mi.obj_type_foreign_keys(obj_type):
for kf in mi.compound_key_fields(obj_type, mi.pk(obj_type)):
if mi.is_foreign_key(obj_type, kf):
(ref_ot, ref_fn) = mi.foreign_key_references(obj_type, kf)
if ref_ot in mode_dict:
s_dict[kf] = mode_dict[ref_ot]
# for (n,v) in self.mode_stack_to_rest_dict({}).items():
# for (fk_ot, fk_fn) in mi.foreign_key_xref[n][mi.pk(n)]:
# print n, fk_ot, fk_fn
# if fk_ot == obj_type:
# s_dict[fk_fn] = v
entries = self.store.rest_query_objects(obj_type, s_dict)
return self.display_obj_type_rows(obj_type, entries, with_search_key)
return self.do_show_object(search_object, with_search_key)
#
# --------------------------------------------------------------------------------
# cp_is_alias
# Used in cp_no to determine if the particular request is an alias completion
#
def cp_is_alias(self, words, text):
if not self.in_config_submode() or len(words) != 2:
return False
obj_type = self.get_current_mode_obj_type()
# LOOK! robv: Tweaked this from the commented out version below
return obj_type in mi.alias_obj_type_xref
#
# --------------------------------------------------------------------------------
# cascade_delete
# Delete interior objects' rows related via foreign keys
#
def cascade_delete(self, obj_type, id_value):
global modi
obj_key = mi.pk(obj_type)
if obj_type in mi.foreign_key_xref and \
obj_key in mi.foreign_key_xref[obj_type]:
for (fk_obj_type, fk_name) in mi.foreign_key_xref[obj_type][obj_key]:
if mi.is_cascade_delete_enabled(fk_obj_type):
#
# find any affected rows
try:
rows = self.get_table_from_store(fk_obj_type,
fk_name,
id_value,
"exact")
except Exception, e:
if self.debug or self.debug_backtrace:
errors = self.rest_error_to_dict(e, fk_obj_type)
print self.rest_error_dict_to_message(errors)
rows = []
# determine whether the foreign key can have a null
# value, in which case the row doesn't have to be deleted,
# just updated the foreign key to `None'.
if mi.is_force_delete_enabled(fk_obj_type):
delete = True
elif mi.is_null_allowed(fk_obj_type, fk_name):
delete = False
else:
delete = True
key = mi.pk(fk_obj_type)
for row in rows:
try:
if delete:
self.rest_delete_object(fk_obj_type, row[key])
else: # update
self.rest_update_object(fk_obj_type, key, row[key],
{ fk_name : None } )
errors = None
except Exception, e:
errors = self.rest_error_to_dict(e,
fk_obj_type + " "
+ row[key])
if errors:
return self.rest_error_dict_to_message(errors)
self.debug_msg("cascade delete: %s: %s" % \
(fk_obj_type, ', '.join(row[key].split('|'))))
if delete:
self.cascade_delete(fk_obj_type, row[key])
#
# --------------------------------------------------------------------------------
# do_no
# Delete rows from a table, or update a field. For fields which
# have defaults, 'no' referts the field to its default value.
#
def do_no(self, words):
# format is no < obj_type > < id >
if not self.in_config_mode():
if len(words) < 1 or words[0] != 'debug':
return self.error_msg("'no' command only valid in config mode")
obj_type = self.get_current_mode_obj_type()
option = words[0]
#
# manage deletion of complete rows in obj_types'
#
if option in self.obj_types_for_config_mode_starting_with():
if not len(words) > 1:
return self.error_msg("<id> must be specified for the object to delete")
item = convert_alias_to_object_key(option, words[1])
try:
self.rest_delete_object(option, item)
errors = None
except Exception, e:
errors = self.rest_error_to_dict(e, option + " " + item)
#
# cascade delete?
if not errors:
self.cascade_delete(option, item)
#
# manage removal/set-to-default of values in fields of an obj_type
#
elif option in self.fields_for_current_submode_starting_with(option):
#
# replace the obj_type with the alias obj_type when for
# fields called 'alias' when the obj_type has one alias
if obj_type in mi.alias_obj_type_xref:
aliases = mi.alias_obj_type_xref[obj_type]
if option in aliases:
obj_type = option
if len(aliases) == 1 and option == 'alias':
obj_type = aliases[0]
if len(aliases) != 1:
print self.error_msg("Internal 'no' more than one alias choice")
if len(words) < 2:
return "Syntax: no %s <value>" % option
item = words[1]
try:
self.rest_delete_object(obj_type, item)
errors = None
except Exception, e:
errors = self.rest_error_to_dict(e, obj_type + " " + item)
return self.rest_error_dict_to_message(errors)
key = mi.pk(obj_type)
#
# note: field_default_value returns None when no default is
# provided. its not clear whether default values are always
# provided for fields which don't accept null values.
#
default_value = mi.field_default_value(obj_type, option)
if mi.is_null_allowed(obj_type, option) and default_value:
self.warning("'%s' accepts null and had a default "
"value; %s is set to the default value '%s" %
(obj_type, option, default_value))
errors = self.rest_update_object(obj_type,
key,
self.get_current_mode_obj(),
{option:default_value})
# fall through to return
elif self.in_config_vns_acl_mode() and self.ACL_RE.match(option):
return self.do_vns_no(['access-list-entry'] + words)
#elif self.in_config_controller_interface_mode() and 'firewall'.startswith(option):
# return self.do_no_firewall(words)
else:
try:
command_words = ['no'] + words
# Just try to execute the command. It will either succeed or
# throw an exception
return command.do_command(command_words)
except urllib2.HTTPError, e:
raise e
except Exception, e:
if self.debug or self.debug_backtrace:
traceback.print_exc()
return self.error_msg("'%s' must be either a valid object type or a field" %
option)
# when errors == None, rest_error_dict_to_message returns None.
return self.rest_error_dict_to_message(errors)
#
# --------------------------------------------------------------------------------
# implement_ping
# Performs a traceroute to a switch or host.
# Input can either be a DPID, switch alias, or host (IP or domain).
def implement_ping(self, data):
count = '-c %d ' % data.get('count', 5)
if not 'ip-address' in data:
yield('Can\'t determine ping target')
return
ip_host = data['ip-address']
if self.DPID_RE.match(ip_host):
ip_host = self.get_ip_from_switch_dpid_or_alias(ip_host)
cmd = 'ping %s%s' % (count, self.shell_escape(ip_host))
for item in self.generate_subprocess_output(cmd):
yield item
#
# --------------------------------------------------------------------------------
# implement_traceroute
# Performs a traceroute to a switch or host.
# Input can either be a DPID, switch alias, or host (IP or domain).
def implement_traceroute(self, data):
if not 'ip-address' in data:
yield('Can\'t determine traceroute target')
return
ip_host = data['ip-address']
if self.DPID_RE.match(ip_host):
ip_host = self.get_ip_from_switch_dpid_or_alias(ip_host)
cmd = 'traceroute %s' % self.shell_escape(ip_host)
for item in self.generate_subprocess_output(cmd):
yield item
#
# --------------------------------------------------------------------------------
# do_no_firewall
#
#def do_no_firewall(self, words):
# return self.do_firewall(words[1:], True)
#
# --------------------------------------------------------------------------------
# firewall_rule_add_rule_to_entries
#
def firewall_rule_add_rule_to_entries(self, entries):
for entry in entries:
entry['rule'] = run_config.firewall_rule(entry)
return entries
#
# --------------------------------------------------------------------------------
# get_firewall_rules
# Returns a list of strings describing the firewall rules for a particular
# controller-node name.
#
def get_firewall_rules(self, node):
key = mi.pk('firewall-rule')
key_value = self.unique_key_from_non_unique([node])
entries = self.get_table_from_store('firewall-rule', key, key_value)
return self.firewall_rule_add_rule_to_entries(entries)
#
# --------------------------------------------------------------------------------
# do_show_firewall
# Depends on get_firewall_rules to add 'rule' to entries so that
# the 'firewall-rule' table can display the rule's value in a
# easily identified syntax.
#
def do_show_firewall(self, words):
return self.display_obj_type_rows('firewall-rule',
self.get_firewall_rules(self.get_current_mode_obj()))
# --------------------------------------------------------------------------------
# handle_command
#
def handle_command(self, command_word, words):
if type(command_word) == str:
method = self.command_method_from_name(command_word)
if method:
return method(words)
# XXX It would be better to only call do_command if it
# was clear that this command actually existed.
return command.do_command([command_word] + words)
#
# --------------------------------------------------------------------------------
# find_with_quoting
#
# Assumes start_index is not inside a quoted string.
#
@staticmethod
def find_with_quoting(line, find_char, reverse=False, start_index=0):
in_quoted_arg = False
line_length = len(line)
i = start_index
found_index = -1;
while i < line_length:
c = line[i]
if c in "\"'":
if not in_quoted_arg:
quote_char = c
in_quoted_arg = True
elif c == quote_char:
in_quoted_arg = False
# otherwise leave in_quoted_arg True
elif c == "\\" and in_quoted_arg:
i += 1
elif (c == find_char) and not in_quoted_arg:
found_index = i
if not reverse:
break
i += 1
return found_index
#
# --------------------------------------------------------------------------------
# split_with_quoting
#
@staticmethod
def split_with_quoting(line, separators=" \t"):
word_list = []
current_word = ""
in_quoted_arg = False
line_length = len(line)
i = 0
while i < line_length:
c = line[i]
i += 1
if c in "\"'":
if not in_quoted_arg:
in_quoted_arg = True
quote_char = c
elif c == quote_char:
in_quoted_arg = False
word_list.append(current_word)
current_word = ""
else:
current_word += c
elif c == "\\" and in_quoted_arg:
if i < line_length:
c = line[i]
current_word += c
i += 1
elif (c in separators) and not in_quoted_arg:
if current_word:
word_list.append(current_word)
current_word = ""
else:
current_word += c
if current_word:
word_list.append(current_word)
return word_list
#
# --------------------------------------------------------------------------------
# quote_item
# Some of the new model columns available as choices to select have the '|'
# character as a separator. For these choices to word, they need to be
# quoted
#
@staticmethod
def quote_item(obj_type, item):
if item.find("|") >= 0:
return '"' + str(item) + '"'
else:
return str(item)
#
# --------------------------------------------------------------------------------
#
def replay(self, file, verbose = True, command_replay = False):
# Only replay the STR values, since the code ought to
# stuff back the JSON values.
play = open(file)
rest_line_format = re.compile(r'^REST ([^ ]*)( *)([^ ]*)( *)(.*)$')
cmd_line_format = re.compile(r'^COMMAND (.*)$')
skip_command = True
for line in play.read().split('\n'):
# the format ought to be url<space>[STR|JSON]<space> ...
match = rest_line_format.match(line)
if match:
if match.group(3) == 'STR':
if verbose:
print 'REST STR', match.group(1)
url_cache.save_url(match.group(1), match.group(5), 1000000)
elif match.group(3) == 'JSON':
if verbose:
print 'REST JSON', match.group(1)
entries = json.loads(match.group(5))
url_cache.save_url(match.group(1), entries, 1000000)
else:
print 'REST REPLAY NOT STR|JSON'
elif len(line):
match = cmd_line_format.match(line)
if command_replay and match:
# skip the first command since it ought to be the replay enablement
if skip_command:
if verbose:
print 'SKIP COMMAND %s' % match.group(1)
skip_command = False
else:
line = self.split_with_quoting(match.group(1))
if verbose:
print 'COMMAND %s' % line
output = self.handle_multipart_line(line[0])
if output != None:
print output
else:
print 'no MATCH +%s+' % line
play.close()
#
# --------------------------------------------------------------------------------
# handle_single_line
#
def handle_single_line(self, line):
ret_val = None
if len(line) > 0 and line[0]=="!": # skip comments
return
words = self.split_with_quoting(line)
if not words:
return
#
self.completion_reset()
# Look for the replay keyword, use the first two tokens if the replay
# keyword is in the first part of the command.
if self.debug and len(words) >= 2:
if words[0] == 'replay':
# replay the file, remove the first two keywords
self.replay(words[1], command_replay = len(words) == 2)
if len(words) == 2:
return
words = words[2:]
# the first word of a line is either:
# - a command - dependent on mode (show anywhere but configure only in enable)
# - an object type - if we're in a config mode (either config or config submode)
# - a field for an object - if we're in a config submode
matches = [(x, "command") for x in self.commands_for_current_mode_starting_with(words[0])]
matches.extend([(x, "config object") for x in self.obj_types_for_config_mode_starting_with(words[0])])
matches.extend([(x, "field") for x in self.fields_for_current_submode_starting_with(words[0])])
# LOOK!: robv Fix to work with field names where one name is a prefix of another
if len(matches) > 1:
for match_tuple in matches:
if match_tuple[0] == words[0]:
matches = [match_tuple]
break
if len(matches) == 1:
match = matches[0]
# Replace the (possibly) abbreviated argument with the full name.
# This is so that the handlers don't need to all handle abbreviations.
if type(match[0]) == str:
words[0] = match[0]
if match[1] == "field":
ret_val = self.handle_field(words)
elif match[1] == "config object":
ret_val = self.handle_obj_type(words)
else:
ret_val = self.handle_command(words[0], words[1:])
#ret_val = self.handle_command(match[0], words[1:])
elif len(matches) > 1:
ret_val = self.error_msg("%s is ambiguous\n" % words[0])
for m in matches:
ret_val += "%s (%s)\n" % m
else:
ret_val = self.error_msg("Unknown command: %s\n" % words[0])
url_cache.command_finished(words)
return ret_val
#
# --------------------------------------------------------------------------------
# generate_pipe_output
#
def generate_pipe_output(self, p, output):
fl = fcntl.fcntl(p.stdout, fcntl.F_GETFL)
fcntl.fcntl(p.stdout, fcntl.F_SETFL, fl | os.O_NONBLOCK)
for item in output:
try:
p.stdin.write(item)
except IOError:
break
try:
out_item = p.stdout.read()
yield out_item
except IOError:
pass
p.stdin.close()
fcntl.fcntl(p.stdout, fcntl.F_SETFL, fl)
while True:
out_item = p.stdout.read()
if (out_item):
yield out_item
else:
p.stdout.close()
break
p.wait()
#
# --------------------------------------------------------------------------------
# write_to_pipe
#
def write_to_pipe(self, p, output):
for item in output:
try:
p.stdin.write(item)
except IOError:
break
p.stdin.close()
p.wait()
#
# --------------------------------------------------------------------------------
# shell_escape
# Return a string, quoting the complete string, and correctly prefix any
# quotes within the string.
#
def shell_escape(self, arg):
return "'" + arg.replace("'", "'\\''") + "'"
#
# --------------------------------------------------------------------------------
# handle_pipe_and_redirect
#
def handle_pipe_and_redirect(self, pipe_cmds, redirect_target, output):
# if redirect target is tftp/ftp/http/file, then we should actually stick
# curl at the end of the pipe_cmds so it gets handled below
if redirect_target:
if redirect_target.startswith("tftp") or redirect_target.startswith("ftp") or \
redirect_target.startswith("http") or redirect_target.startswith("file"):
redirect_target = self.shell_escape(redirect_target)
# add so it can be used below
if pipe_cmds == None:
pipe_cmds = ""
else:
pipe_cmds += " | "
if redirect_target.startswith("ftp"): # shell_escape added quote
pipe_cmds += " curl -T - %s" % self.shell_escape(redirect_target)
else:
pipe_cmds += " curl -X PUT -d @- %s" % self.shell_escape(redirect_target)
if pipe_cmds:
new_pipe_cmd_list = []
for pipe_cmd in [x.strip() for x in pipe_cmds.split('|')]:
# doing it this way let us handles spaces in the patterns
# as opposed to using split/join which would compress space
new_pipe_cmd = pipe_cmd
m = re.search('^(\w+)(.*)$', pipe_cmd)
if m:
first_tok = m.group(1)
rest_of_cmd = m.group(2).strip()
if first_tok.startswith("in"):
new_pipe_cmd = "grep -e " + rest_of_cmd
elif first_tok.startswith("ex"):
new_pipe_cmd = "grep -v -e" + rest_of_cmd
elif first_tok.startswith("begin"):
new_pipe_cmd = "awk '/%s/,0'" % rest_of_cmd
new_pipe_cmd_list.append(new_pipe_cmd)
new_pipe_cmds = "|".join(new_pipe_cmd_list)
if new_pipe_cmds:
if redirect_target:
p = subprocess.Popen(new_pipe_cmds,
shell=True,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output = self.generate_pipe_output(p, output)
else:
p = subprocess.Popen(new_pipe_cmds,
shell=True,
stdin=subprocess.PIPE)
self.write_to_pipe(p, output)
output = None
# only handle local file here as http/ftp were handled above via pipe
if redirect_target:
if redirect_target.startswith("config://"):
m = re.search(self.local_name_pattern, redirect_target)
if m:
join_output = ''.join(iter(output))
store_result = self.store.set_user_data_file(m.group(1), join_output)
if store_result:
result = json.loads(store_result)
else:
return self.error_msg("rest store result not json format")
if 'status' in result and result['status'] == 'success':
return None
elif 'message' not in result:
return self.error_msg("rest store result doesn't contain error message")
else:
return self.error_msg(result['message'])
else:
print self.error_msg("invalid name-in-db (%s)\n" % redirect_target)
else:
return output
return None
#
# --------------------------------------------------------------------------------
# generate_command_output
#
@staticmethod
def generate_command_output(ret_val):
if (isinstance(ret_val, str) or \
isinstance(ret_val, buffer) or \
isinstance(ret_val, bytearray) or \
isinstance(ret_val, unicode)):
# yield ret_val
if len(ret_val) and ret_val[-1] == '\n':
ret_val = ret_val[:-1]
for line in ret_val.split('\n'):
yield line + '\n'
elif ret_val != None:
for item in ret_val:
yield item
#
# --------------------------------------------------------------------------------
# generate_line_output
#
# This is a generator that will generate the output of the
# command either as a string, or by iterating over a returned
# iterable. This way, a subcommand can return an iterable to
# lazily evaluate large amounts of output
#
def generate_line_output(self, line, dont_ask):
while line:
subline_index = self.find_with_quoting(line, ';')
if subline_index < 0:
subline_index = len(line)
subline = line[:subline_index]
line = line[subline_index+1:]
ret_val = self.handle_single_line(subline)
cnt = 1
total_cnt = 0
(col_width, screen_length) = self.pp.get_terminal_size()
if type(self.length) == int:
screen_length = self.length
for item in self.generate_command_output(ret_val):
if not dont_ask:
incr = 1 + (max((len(item.rstrip()) - 1), 0) / col_width)
if screen_length and cnt + incr >= screen_length:
raw_input('-- hit return to continue, %s) --' % total_cnt)
cnt = 0
cnt += incr
total_cnt += incr
yield item
#
# --------------------------------------------------------------------------------
# handle_multipart_line
#
# this is the outermost handler that should print
#
def handle_multipart_line(self, line):
pipe_cmds = None
redirect_target = None
output = None
# pattern is:
# single line [; single line]* [| ...] [> {conf|ftp|http}]
# first take off the potential redirect part then the pipe cmds
redirect_index = self.find_with_quoting(line, '>', True)
if redirect_index >= 0:
redirect_target = line[redirect_index+1:].strip()
line = line[:redirect_index].strip()
pipe_index = self.find_with_quoting(line, '|')
if pipe_index >= 0:
pipe_cmds = line[pipe_index+1:].strip()
line = line[:pipe_index].strip()
# remaining text is single lines separated by ';' - handle them
output = self.generate_line_output(line, pipe_cmds or redirect_target)
# now output everything
if pipe_cmds or redirect_target:
output = self.handle_pipe_and_redirect(pipe_cmds, redirect_target, output)
if output != None:
for line in output:
print line.rstrip()
#
# --------------------------------------------------------------------------------
# cp_watch
#
def cp_watch(self, words, text, completion_char):
if completion_char == ord('?'):
if len(words) > 1:
command.do_command_completion_help(words[1:], text)
else:
self.print_completion_help(self.help_splash([], text))
return
if len(words) == 1:
items = self.commands_for_current_mode_starting_with(text)
return utif.add_delim(items, ' ')
else:
return command.do_command_completion(words[1:], text)
#
# --------------------------------------------------------------------------------
# do_watch
# only called to display help
#
def do_watch(self, words):
return 'watch: repeat indicated command after watch keyword'
#
# --------------------------------------------------------------------------------
# handle_watch_command
#
# handle this here because this is a CLI-only command
# LOOK! This could be using curses, but that has some complications with
# potentially messing up the terminal. This is cheap but downside
# is it uses up the scrollbuffer...
#
def handle_watch_command(self, line):
#
words = line.split()
if len(words) == 0:
return self.syntax_msg('watch: command to watch missing')
if len(words) and words[0] == 'watch':
return self.error_msg('watch command not supported for watch')
while True: # must control-C to get out of this
output = self.handle_multipart_line(line)
if output:
os.system("clear")
print "Executing %s " % line
print output
else:
print "Executing %s " % line
time.sleep(2)
#
#
# --------------------------------------------------------------------------------
# loop
# this is just dispatching the command and handling errors
#
def loop(self):
command.action_invoke('wait-for-controller', (5))
if self.controller:
try:
version_url = 'http://%s/rest/v1/system/version' % self.controller
version = self.rest_simple_request_to_dict(version_url)
except Exception, e:
version = [{'controller' : 'REST API FAILURE\n'}]
print "default controller: %s, %s" % (self.controller,
version[0]['controller'])
#
# vns feature enablement.
# when vns is enabled, call a init procedure
#
if onos == 0:
self.netvirt_feature_enabled()
while self.run:
# Get command line - this will use the command completion above
try:
#rest_to_model.validate_switch()
url_cache.clear_cached_urls()
line = raw_input(self.prompt)
if self.batch:
print line
m = re.search('^watch (.*)$', line)
if m:
self.handle_watch_command(m.group(1))
else:
self.handle_multipart_line(line)
except KeyboardInterrupt:
self.completion_reset()
print "\nInterrupt."
except EOFError:
print "\nExiting."
return
except urllib2.HTTPError, e:
errors = self.rest_error_to_dict(e)
print self.error_msg("%s" % self.rest_error_dict_to_message(errors))
except urllib2.URLError, e:
print self.error_msg("communicating with REST API server on %s "
"- Network error: %s" %
(self.controller, e.reason))
except Exception, e:
print "\nError running command '%s'.\n" % line
if self.debug or self.debug_backtrace:
traceback.print_exc()
#
# --------------------------------------------------------------------------------
# Initialization crazyness to make it work across platforms. Many platforms don't include
# GNU readline (e.g. mac os x) and we need to compensate for this
try:
import readline
except ImportError:
try:
import pyreadline as readline
except ImportError:
print "Can't find any readline equivalent - aborting."
else:
if 'libedit' in readline.__doc__:
# needed for Mac, please fix Apple
readline.parse_and_bind ("bind ^I rl_complete")
else:
readline.parse_and_bind("tab: complete")
readline.parse_and_bind("?: possible-completions")
#
# --------------------------------------------------------------------------------
# Run the shell
def main():
global cli
# Uncomment the next two lines to enable remote debugging with PyDev
# LOOK! Should have logic here that enables/disables the pydevd stuff
# automatically without requiring uncommenting (and, more importantly,
# remembering to recomment before committing).
# (e.g. checking environment variable or something like that)
#python_path = os.environ.get('PYTHONPATH', '')
#if 'pydev.debug' in python_path:
try:
import pydevd
pydevd.settrace()
except Exception, e:
pass
# Process '--init' argument since it gates progress to rest of processing
# as this is a special argument, it is required to be first argument (if used)
check_ready_file = True
if len(sys.argv) > 1:
if sys.argv[1] == '--init':
check_ready_file = False
# Do not start CLI till the systemn is ready
# (allow user to ^C and get to SDNSh for debug etc)
not_ready_file = '/opt/sdnplatform/run/starting'
if check_ready_file:
try:
while True:
if os.path.exists(not_ready_file):
with open(not_ready_file, "r") as f:
message = f.read()
if len(message):
print message,
else:
print 'Controller not yet ready ... waiting 5 sec'
time.sleep(5)
else:
break
except:
if os.path.exists(not_ready_file):
resp = raw_input('Controller is not yet ready. Do you still want to continue to the CLI? [n]')
if resp and "yes".startswith(resp.lower()):
print 'Continuing with CLI despite initialization error ...'
else:
print 'Aborting Controller CLI login.'
time.sleep(1)
return
# Start CLI
cli = SDNSh()
cli.init()
cli.loop()
if __name__ == '__main__':
main()