#!/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"
    
    known_sdn_platforms = ["127.0.0.1:8080"]
    sdn_controller_paltform = None

    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.sdn_controller_paltform)
        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()
        if self.controller is None:
            self.controller = "127.0.0.1:8000"
        self.sdn_controller_paltform = self.options.controller
        if not self.sdn_controller_paltform:
            self.sdn_controller_paltform = "127.0.0.1:8080"
        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)
        self.store.set_sdn_controller_platform_rest_if(self.sdn_controller_paltform)

        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()