cli/modi.py

#
# Copyright (c) 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.
#

import sys
# from midw import *

#
# MODel Information (modi)
#

class Modi():

    def __init__(self, sdnsh, cli_model_info):
        self.sdnsh = sdnsh

        self.obj_type_info_dict = {}
        self.obj_types = []
        self.obj_keys = {}

        # self.cli_model_info = CliModelInfo()
        self.cli_model_info = cli_model_info

        self.init_obj_type_info_dict(cli_model_info)
        self.init_foreign_key_xref()
        self.init_alias_obj_type_xref()

    @staticmethod
    def _line():
        # pylint: disable=W0212
        f = sys._getframe().f_back
        return '[%s:%d]' % (f.f_code.co_filename, f.f_lineno)
    #
    # --------------------------------------------------------------------------------

    def init_obj_type_info_dict(self, cli_model_info):
        """
        When obj_type_info_dict is indexed by the table/model name,
        the value is a dictionary.  That dictionary has several keys:
        
        - 'cascade_delete' True/False, set to true when foreign key's in this
                           obj_type will be used o identify rows to delete based
                           on rows removed from the parent table.
        - 'force_delete' True/False, set to true when foreign keys in this
                         obj_type are allowed to be null, but when they are not,
                         the rows identified by cascade_delete must be deleted
                         when rows are removed from the parent table
        - 'source' set to 'user-config' for obj_types which user's configure
                   set to 'debug-only' to enable viewing object only in debug mode
      
        The 'fields' indexed result returns a dictionary, each of which
        is indexed by the names of the fields within the table/model. further
        indicies describe details about that field within the table:
        
        Some of the key's are intended to be added to the dictionary
        to further decorate details about the field.  The objective is
        to modify cli behavior, or override the model details.  These
        values, tho, ought to really come from the model description.

        - 'verbose-name' identfies an additonal name for the field, inteneded
                         to be more descriptive

        - 'hex' True/False, True for fields when a hex value can
                         be replaced with a decimal value
        - 'edit' True/Falue,  False when a field cannot be edited within
                         the nested config mode.

        - 'validate' function to call to validate the field value

        Various key's use '_' vs the typical '-' since they're 
        currently constructed via the django model description

        - 'primary_key' identifes this field as the key for the table/model.
        - 'has_rest_model'  True/False
        - 'json_serialize_string'  True/False
        - 'help_text'  String providing more clues about the intent of this field
        - 'type' various values, intended to be populated by tools/extract_model.py
                         allowing access of the type to the cli.  the allows the
                         cli to find foreign_keys, and possibly determine
        - 'max_length' 
        
        Other key decorations:  sorting

        The 'field_ordering' dictionary associated with the name of the table/model
        is used to order the output.
        
        Also populates the self.obj_keys[], which is a dictionary mapping the table/model
        name to the name of the storage key (table/model's column) for that table.

        @param cli_model_info instantiated class CliModelInfo()
        """
        self.obj_type_info_dict = self.cli_model_info.get_complete_obj_type_info_dict()
        self.obj_types = [k for (k, v) in self.obj_type_info_dict.items()
                          if 'has_rest_model' in v]
        for (k, d) in self.obj_type_info_dict.items():
            if not 'fields' in d:
                print '%s: Missing "fields"' % k
                continue
            candidate_keys = [f for f in d['fields'].keys()
                              if d['fields'][f].get('primary_key', False)]
            if len(candidate_keys) > 0:
                self.obj_keys[k] = candidate_keys[0]

    #
    # --------------------------------------------------------------------------------
    
    def init_foreign_key_xref(self):
        """
        Walk through the obj_type_info_dict, looking for foreign keys.
        Build a cross references, so that a <obj_type, field> can be
        used to identify all the obj_types which reference that field.
      
        To allow for both <obj_type, field> to be used to index
        self.foreign_key_xref, two levels of dictionaries are built.
        The first maps from obj_type to a dictionary of fields, and
        the fields dictionary has values which are lists.  Each of the
        lists has two members: the <obj_type, field>, which will be
        a foreign key to the original pair.
      
        This allows identificaion of fields which have single foreign
        key xref's, which can then be used to identify "sub-modes"
        for particular obj_types.
        """

        self.foreign_key_xref = {}
        for (obj_type, obj_type_dict) in self.obj_type_info_dict.items():
            if not 'fields' in obj_type_dict:
                print '%s: Missing "fields"' % obj_type
                continue
            for (fn, fd) in obj_type_dict['fields'].items():
                if 'type' in fd:
                    if fd['type'] == 'ForeignKey':
                        ref_foreign_obj_type = fd['rel_obj_type']
                        ref_foreign_field = fd['rel_field_name']
                        if not ref_foreign_obj_type in self.foreign_key_xref:
                            self.foreign_key_xref[ref_foreign_obj_type] = {}
                        if not ref_foreign_field in self.foreign_key_xref[ref_foreign_obj_type]:
                            self.foreign_key_xref[ref_foreign_obj_type][ref_foreign_field] = []
                        self.foreign_key_xref[ref_foreign_obj_type][ref_foreign_field].append(
                            [obj_type, fn])

    #
    # --------------------------------------------------------------------------------
    
    def init_alias_obj_type_xref(self):
        """
        Alias obj types have a non-compound primary key, a foreign key, and
        possibly 'DateTimeField' fields, but no other fields.  These can
        be identified by scanning the dictionary.

        The alias_obj_type_xref dictionary is indexed by the obj_type referenced
        by the foreign key of the original obj_type (its a cross ref)
        """

        self.alias_obj_type_xref = {}
        self.alias_obj_types = []
        for (obj_type, obj_type_dict) in self.obj_type_info_dict.items():
            if not 'fields' in obj_type_dict:
                print '%s: Missing "fields"' % obj_type
                continue
            foreign_key_obj_type = None
            foreign_key_count = 0
            other_types = False
            for (fn, fd) in obj_type_dict['fields'].items():
                # 'Idx' field is only for display counting of rows
                if fn != 'Idx' and 'type' in fd:
                    if fd['type'] == 'ForeignKey':
                        foreign_key_count += 1
                        foreign_key_obj_type = fd['rel_obj_type']
                    elif 'primary_key' in fd:
                        if self.is_compound_key(obj_type, fn):
                            other_types = True
                    elif fd['type'] != 'DateTimeField':
                        other_types = True
            if foreign_key_count == 1 and other_types == False:
                self.alias_obj_types.append(obj_type)
                if not foreign_key_obj_type in self.alias_obj_type_xref:
                    self.alias_obj_type_xref[foreign_key_obj_type] = []
                self.alias_obj_type_xref[foreign_key_obj_type].append(
                    obj_type
                )
            #
            # if the primariy key is a compound key, and the first item
            # is also a foreign key here, then allow the first item to
            # match up with the alias.  currenly, only use the first item
            # since the 'startswith' can use used to find the assocaited
            # members
            #
            elif foreign_key_count >= 1:
                key = self.obj_keys[obj_type]
                compound_fields = self.compound_key_fields(obj_type, key)
                if compound_fields:
                    first_field = compound_fields[0]
                    if first_field in self.obj_type_foreign_keys(obj_type):
                        #
                        # This is nasty -- assuming that the foreign_key's table
                        # name will then have an alias table associated with it.
                        # Perhaps some model field can help describe these
                        # associations, something like 'allow-alias: <obj_type>'
                        if first_field == 'vns':
                            pass
                        if not "%s-alias" % first_field in self.obj_type_info_dict:
                            # only build references to tables which exist.
                            pass
                        elif obj_type in self.alias_obj_type_xref:
                            self.alias_obj_type_xref[obj_type] += ["%s-alias" % first_field]
                        else:
                            self.alias_obj_type_xref[obj_type] = ["%s-alias" % first_field]

    #
    # --------------------------------------------------------------------------------

    def pk(self, obj_type):
        """
        Return the primary key name for the object

        @param obj_type string, name of the object-type (ie: 'host', 'switch')
        """

        # Raise an exception when the name doesn't exist?
        return self.obj_keys.get(obj_type, None)

    #
    # --------------------------------------------------------------------------------

    def obj_type_exists(self, obj_type):
        """
        Return True if there's details about obj_type in obj_types_info_dict
        """
        return obj_type in self.obj_type_info_dict.keys()
    
    #
    # --------------------------------------------------------------------------------

    def obj_type_has_model(self, obj_type):
        """
        Return True if the obj_type is serviced via the model rest api
        (in other words, there's a db table which supports this model)
        """
        return obj_type in self.obj_types
    
    #
    # --------------------------------------------------------------------------------

    def obj_type_has_url(self, obj_type):
        """
        Returns a url suffix describing a path which returns the
        data associated with thie obj_type
        """
        if obj_type in self.obj_type_info_dict:
            return self.obj_type_info_dict[obj_type].get('url', None)
        return None
    
    #
    # --------------------------------------------------------------------------------
    
    def is_foreign_key(self, obj_type, field):
        """
        Return True when the field within the obj_type is a foreign key.

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """
        if not obj_type in self.obj_type_info_dict:
            return False
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return False

        field_info = self.obj_type_info_dict[obj_type]['fields'].get(field, [])
        if 'type' in field_info:
            if field_info['type'] == 'ForeignKey':
                return True
        return False

    #
    # --------------------------------------------------------------------------------
    
    def is_integer_field(self, obj_type, field):
        """
        Return True when the type associated with the obj_type's field is an integer

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        if not obj_type in self.obj_type_info_dict:
            return False
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return False

        field_info = self.obj_type_info_dict[obj_type].get('fields', [])[field]
        if 'type' in field_info:
            if field_info['type'] == 'IntegerField':
                return True
        return False


    #
    # --------------------------------------------------------------------------------

    def is_primary_key(self, obj_type, field):
        """
        Return true when the obj_type's field is a primary key

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        if not obj_type in self.obj_type_info_dict:
            return False
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return False

        field_info = self.obj_type_info_dict[obj_type].get('fields',[])[field]
        if 'primary_key' in field_info:
            return field_info['primary_key'] # should be true if exists
        return False

    #
    # --------------------------------------------------------------------------------
    
    def is_field_editable(self, obj_type, field):
        """
        Return True if the field is editable.  Default is True.

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        if not obj_type in self.obj_type_info_dict:
            return False
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return False

        field_info = self.obj_type_info_dict[obj_type].get('fields',[])[field]
        if 'edit' in field_info:
            return field_info['edit'] # should be False if exists
        return True

    #
    # --------------------------------------------------------------------------------
    
    def is_editable(self, obj_type, field):
        """
        Return true if the obj_type/field is available for editing
        Excludes foreign keys, and primary keys (unless edit: True
        is specifically enabled for the field)

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        if not obj_type in self.obj_type_info_dict:
            return False
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return False

        if not field in self.obj_type_info_dict[obj_type]['fields']:
            return False
        field_info = self.obj_type_info_dict[obj_type]['fields'][field]
        if 'edit' in field_info and field_info['edit'] == True:
            return True
        if self.is_foreign_key(obj_type, field):
            return False
        if self.is_primary_key(obj_type, field):
            return False
        if not self.is_field_editable(obj_type, field):
            return False
        return True

    #
    # --------------------------------------------------------------------------------

    def obj_type_disable_edit(self, obj_type, field):
        """
        Mark an obj_type's field as not being directly editable.
        When the command descriptions are used for all obj_type's edit, the need
        for 'disabling edit' ought to disappear
        """
        if not obj_type in self.obj_type_info_dict:
            return False
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            self.obj_type_info_dict[obj_type]['fields'] = {}
        if not field in self.obj_type_info_dict[obj_type]['fields']:
            self.obj_type_info_dict[obj_type]['fields'][field] = {}
        self.obj_type_info_dict[obj_type]['fields'][field]['edit'] = False

    #
    # --------------------------------------------------------------------------------

    def is_marked_searchable(self, obj_type, field):
        """
        Return true if a field is searchable.

        This ought to be true for any fields which is part of the
        primary key construction.

        This predicate, however, in intended to look for fields
        which are identified by the model as being searchable,
        even when the field doesn't appear in the primary key.

        @param obj_type
        @param field
        """

        if not obj_type in self.obj_type_info_dict:
            return False
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return False
        if not field in self.obj_type_info_dict[obj_type]['fields']:
            return False

        key = self.pk(obj_type)
        if self.is_compound_key(obj_type, key):
            if field in self.compound_key_fields(obj_type, key):
                return True
            
        field_info = self.obj_type_info_dict[obj_type]['fields'][field]
        if 'searchable' in field_info:
            return field_info['searchable'] == True
        return False

    #
    # --------------------------------------------------------------------------------
    
    def get_obj_type_field_case_sensitive(self, obj_type, field):
        """
        Return true if a field is case sensitive.

        @param obj_type
        @param field
        """

        if not obj_type in self.obj_type_info_dict:
            return None
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return None
        if not field in self.obj_type_info_dict[obj_type]['fields']:
            return None

        field_info = self.obj_type_info_dict[obj_type]['fields'][field]
        if 'case' in field_info:
            return field_info['case']
        return None


    #
    # --------------------------------------------------------------------------------
    
    def set_obj_type_field_case_sensitive(self, obj_type, field, case):
        """
        Set case sensitivity for a field in an obj_type

        @param obj_type
        @param field
        @param case either 'upper', or 'lower'
        """

        if case not in ['upper', 'lower']:
            print 'set_case_sensitive: obj_type %s field %s case %s ' \
                'case not upper/lower' % (obj_type, field, case)
            return

        if not obj_type in self.obj_type_info_dict:
            self.obj_type_info_dict[obj_type] = {}
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            self.obj_type_info_dict[obj_type]['fields'] = {}
        if not field in self.obj_type_info_dict[obj_type]['fields']:
            self.obj_type_info_dict[obj_type]['fields'][field] = {}
        self.obj_type_info_dict[obj_type]['fields'][field]['case'] = case


    #
    # --------------------------------------------------------------------------------
    
    def is_hex_allowed(self, obj_type, field):
        """
        Return true if the obj_type/field allows hex instead of decimal

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        if not obj_type in self.obj_type_info_dict:
            return False
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return False

        field_info = self.obj_type_info_dict[obj_type]['fields'][field]
        if 'hex' in field_info:
            return field_info['hex'] # likely False if exists
        if self.is_integer_field(obj_type, field):
            return True
        return False

    #
    # --------------------------------------------------------------------------------

    def is_field_boolean(self, obj_type, field):
        """
        Return true if the obj_type/field is a boolean type

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        if not obj_type in self.obj_type_info_dict:
            return False
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return False

        field_info = self.obj_type_info_dict[obj_type]['fields'][field]
        if 'type' in field_info:
            return field_info['type'] == 'BooleanField'
        return False

    #
    # --------------------------------------------------------------------------------
    # is_field_string
    #  Return true if the obj_type/field is a character (CharType) type
    #
    def is_field_string(self, obj_type, field):
        """

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        if not obj_type in self.obj_type_info_dict:
            return False
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return False

        field_info = self.obj_type_info_dict[obj_type]['fields'][field]
        if 'type' in field_info:
            return field_info['type'] == 'CharField'
        return False

    #
    # --------------------------------------------------------------------------------
    # is_null_allowed
    #  Return true if the obj_type/field is allowed to be null.
    #
    def is_null_allowed(self, obj_type, field):
        """

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        if not obj_type in self.obj_type_info_dict:
            return False
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return False

        field_info = self.obj_type_info_dict[obj_type]['fields'][field]
        if 'null' in field_info:
            return field_info['null']
        return False

    #
    # --------------------------------------------------------------------------------
    
    def obj_type_fields(self, obj_type):
        """
        Return a list of field names (strings) for the obj_type,
        includes all fields, including primary keys and foreign keys
        """

        if obj_type in self.obj_type_info_dict:
            if not 'fields' in self.obj_type_info_dict[obj_type]:
                return []
            return self.obj_type_info_dict[obj_type]['fields'].keys()
        return []
    #
    # --------------------------------------------------------------------------------
    
    def obj_type_has_field(self, obj_type, field):
        """
        Return true if the obj_type has a field named 'field'

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        if not obj_type in self.obj_type_info_dict:
            return False
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return False

        if obj_type in self.obj_type_info_dict:
            fields_info = self.obj_type_info_dict[obj_type]['fields']
            if field in fields_info:
                return True
        return False

    #
    # --------------------------------------------------------------------------------

    def obj_type_config_fields(self, obj_type):
        """
        For an obj_type, return a list of fields which are possibly user configurable.

        @param obj_type string, name of the object-type
        """

        if obj_type in self.obj_type_info_dict:
            if not 'fields' in self.obj_type_info_dict[obj_type]:
                return []
            fields_info = self.obj_type_info_dict[obj_type]['fields']
            return [x for x in fields_info if self.is_editable(obj_type, x)]
        return []


    #
    # --------------------------------------------------------------------------------

    def obj_type_show_this(self, obj_type):
        """
        Return a list of addition types to display for 'show this'

        @param obj_type string, name of the object-type
        """

        if obj_type in self.obj_type_info_dict:
            if 'show-this' in self.obj_type_info_dict[obj_type]:
                result = self.obj_type_info_dict[obj_type]['show-this']
                if type(result) == str or type(result) == 'unicode':
                    return [result]
                return result
        return []

    #
    # --------------------------------------------------------------------------------
    
    def is_cascade_delete_enabled(self, obj_type):
        """
        Cascade is enabled for an obj_type by setting 'cascade_enabled': True for
        the primary key of an obj_type.

        @param obj_type string, name of the object-type
        """

        if not obj_type in self.obj_type_info_dict:
            return False

        if 'cascade_delete' in self.obj_type_info_dict[obj_type]:
            return self.obj_type_info_dict[obj_type]['cascade_delete']
        return False

    def is_force_delete_enabled(self, obj_type):
        """
        Force delete is enabled for an obj_type by setting 'force_delete': True
        for the primary key of an obj_type.

        @param obj_type string, name of the object-type
        """

        if not obj_type in self.obj_type_info_dict:
            return False

        if 'force_delete' in self.obj_type_info_dict[obj_type]:
            return self.obj_type_info_dict[obj_type]['force_delete']
        return False

    #
    # --------------------------------------------------------------------------------
    
    def cascade_delete_set_enable(self, obj_type):
        """
        Enable cascade_delete for an obj_type
        """
        if not obj_type in self.obj_type_info_dict:
            self.obj_type_info_dict[obj_type] = {}
        self.obj_type_info_dict[obj_type]['cascade_delete'] = True

    def cascade_delete_enable_force(self, obj_type):
        """
        Force cascade_delete for an obj_type
        """
        if not obj_type in self.obj_type_info_dict:
            self.obj_type_info_dict[obj_type] = {}
        self.obj_type_info_dict[obj_type]['cascade_delete'] = True
        self.obj_type_info_dict[obj_type]['force_delete'] = True

    #
    # --------------------------------------------------------------------------------
    
    def has_display_field(self, obj_type, field):
        """
        Determine if a particular obj_type has a particular field on the
        display (ie: during a show command).  Uses the 'field_orderings'
        of the obj_type_info_dict.
      
        Currently used to deterine whether an alias table needs to be
        re-cached in preparation for the display of some obj_type

        @param obj_type string, name of the object-type
        """

        if obj_type in self.obj_type_info_dict and \
          'field_orderings' in obj_type in self.obj_type_info_dict[obj_type]:
            order = self.obj_type_info_dict[obj_type]['field_orderings']['default']
            return field in order
        return False

    #
    # --------------------------------------------------------------------------------
    
    def is_obj_type_source_not_user_config(self, obj_type):
        """
        Return True if the obj_type is intended to be configured,
        some tables are intended to be written by sdnplatform as a way
        of presenting information; it makes no sense for the cli
        to present these tables to the user as configurable.
      
        keep in mind that this returns True only if 'source' exists,
        and the source isn't get to user-config.  This means that
        for a table to be excluded, 'source' must be added, and
        it must be set to something other than 'user-config'

        @param obj_type string, name of the object-type
        """

        if obj_type in self.obj_type_info_dict and \
          'source' in self.obj_type_info_dict[obj_type]:
            if self.obj_type_info_dict[obj_type]['source'] != 'user-config':
                if self.sdnsh.debug and \
                  self.obj_type_info_dict[obj_type]['source'] == 'debug-only':
                    return False
                return True
        return False

    #
    # --------------------------------------------------------------------------------
    
    def is_obj_type_source_debug_only(self, obj_type):
        """
        Return True if the obj_type is marked to be viewed only in debug mode

        @param obj_type string, name of the object-type
        """

        if obj_type in self.obj_type_info_dict and \
          'source' in self.obj_type_info_dict[obj_type]:
            if self.obj_type_info_dict[obj_type]['source'] == 'debug-only':
                return True
        return False

    #
    # --------------------------------------------------------------------------------

    def obj_type_source_set_debug_only(self, obj_type):
        """
        Set the source for the obj-type
        """

        if obj_type in self.obj_type_info_dict:
            self.obj_type_info_dict[obj_type]['source'] = 'debug-only'

    #
    # --------------------------------------------------------------------------------
    
    def compound_key_text(self, obj_type, field):
        """
        Return a text string which describes the construction of a compound key.
        The first character is a '#' when this returned field describes a
        compound key.  The second character is the separator for the field
        itself (not the separator for the fields described by this text
        field).  The remainder is a concatenation of the fields names which
        are used to construct this field.
      
        Currently compound keys are identified through the help_text.
        The help text isn't displayed to the user for primary since the value
        of the key for compound key's must be constructed by the cli, and then
        the user doesn't directly modify or search the compound value.
      
        When the field is itself a foreign key, and no text string exists to
        describe the construction of the compound key, its possible that the foreign
        key's value is itself a compound key.  Peek at the original foreign
        key to see if it has a field identifying the layout of the compound key.

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        if not obj_type in self.obj_type_info_dict:
            return None
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return None
        if not field in self.obj_type_info_dict[obj_type]['fields']:
            return None

        field_info = self.obj_type_info_dict[obj_type]['fields'][field]
        if 'help_text' in field_info:
            if field_info['help_text'][0] == '#':
                return field_info['help_text']
        if self.is_foreign_key(obj_type, field):
            (fk_obj_type, fk_name) = self.foreign_key_references(obj_type, field)
            field_info = self.obj_type_info_dict[fk_obj_type]['fields'][fk_name]
            if field_info.get('help_text', ' ')[0] == '#':
                return field_info['help_text']
        return None

    #
    # --------------------------------------------------------------------------------
    
    def is_compound_key(self, obj_type, field):
        """
        Return true if the obj_type/field is a compound key,
      
        The first character of the compound key's text '#', the
        second character identifies the separator characer for the
        fields value.  The fields are separated by '|' within the text.

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        text = self.compound_key_text(obj_type, field)
        if text:
            return True
        return False

    #
    # --------------------------------------------------------------------------------
    # is_primitive_compound_key
    #
    def is_primitive_compound_key(self, obj_type, field):
        """
        Returns True for a primitive compound key.

        Primitive means compound-keys which don't use CassandraSetting's
        COMPOUND_KEY_FIELDS, rather the help text describes the fields which
        are cobbled together to create a primary key.

        For the cassandraSetting's COMPOUND_KEY_FIELDS, searches for 
        rows can be done by setting values of the fields of the
        COMPOUND_KEY_FIELDS, for primitive_compound_keys, 


        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        if self.is_compound_key(obj_type, field):
            field_info = self.obj_type_info_dict[obj_type]['fields'][field]
            if 'type' in field_info:
                if field_info['type'] != 'compound-key':
                    return True
        return False

    #
    # --------------------------------------------------------------------------------
    # compound_key_separator
    #
    def compound_key_separator(self, obj_type, field):
        """
        Return the single character which is used to separate the values
        of the different field parts for a field which is a compound key.

        Return None when the

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        text = self.compound_key_text(obj_type, field)
        if text:
            return text[1]
        return None

    #
    # --------------------------------------------------------------------------------
    # compound_key_fields
    #
    def compound_key_fields(self, obj_type, field):
        """
        Return's a list of strings, where each is intended to be the
        name of a field within the obj_typ (this is not validated)

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        text = self.compound_key_text(obj_type, field)
        if text:
            return text[2:].split('|')
        return None

    #
    # --------------------------------------------------------------------------------
    
    def deep_compound_key_fields(self, obj_type, field):
        """
        Similar to compound_key_fields(), but when any field is also a foreign
        key, the references obj_type's field is checked, and if that field is
        also a compound key, it is also expanded.

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """

        def recurse_compound_key_fields(obj_type, field, parts):
            if self.is_foreign_key(obj_type, field):
                (fk_ot, fk_fn) = self.foreign_key_references(obj_type, field)
                if self.is_compound_key(fk_ot, fk_fn):
                    recurse_compound_key_fields(fk_ot, fk_fn, parts)
            elif self.is_compound_key(obj_type, field):
                for cf in self.compound_key_fields(obj_type, field):
                    if (self.obj_type_has_field(obj_type, cf) and
                        self.is_foreign_key(obj_type, cf)):

                        (fk_ot, fk_fn) = self.foreign_key_references(obj_type, cf)
                        if self.is_compound_key(fk_ot, fk_fn):
                            recurse_compound_key_fields(fk_ot, fk_fn, parts)
                        else:
                            parts.append(cf)
                    else:
                        parts.append(cf)
            return parts
        return recurse_compound_key_fields(obj_type, field, [])


    #
    # --------------------------------------------------------------------------------
    
    def split_compound_into_dict(self, obj_type, key, target_dict, is_prefix = False):
        """
        To be used to convert a compound key in a row intended for display,
        into separate component name:value pairs.

        The original dict is from a row of a table. the 'key' parameter
        identifies a compound key in the row, the procedure splits the
        value of that key/field, and uses the compound_key_fields() to
        determine what names ought to be associated with the field's
        values, and add's these fields into the original dict.
        """
        def add_to_dict(a, b):
            if a in target_dict and a != key:
                if str(target_dict[a]) != b:
                    if self.is_foreign_key(obj_type, a):
                        target_dict[a] = b
                    else:
                        print self.sdnsh.error_msg("compound split dict has different value: "
                                                   "%s found %s expected %s" %
                                                   (a, target_dict[a], b))
            else:
                target_dict[a] = b

        names = self.deep_compound_key_fields(obj_type, key)
        separator = self.compound_key_separator(obj_type, key)
        values = target_dict[key].split(separator)

        if len(names) != len(values):
            if not is_prefix:
                print self.sdnsh.error_msg("%s: %s: compound length mismatch: %s %s" %
                                           (obj_type, key, names, values))
            min_len = len(names)
            if len(values) < min_len:
                min_len = len(values)
            map(add_to_dict, names[:min_len], values[:min_len])
        else:
            map(add_to_dict, names, values)

    #
    # --------------------------------------------------------------------------------
    
    def foreign_key_references(self, obj_type, field):
        """
        For a field which is a foreign key, return the pair of
        [obj_type, field] describing where the foreign key references

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """
        if not obj_type in self.obj_type_info_dict:
            return None
        if not 'fields' in self.obj_type_info_dict[obj_type]:
            return None
        if not field in self.obj_type_info_dict[obj_type]['fields']:
            return None

        field_info = self.obj_type_info_dict[obj_type]['fields'][field]
        if 'type' in field_info:
            if field_info['type'] == 'ForeignKey':
                return [field_info['rel_obj_type'],
                        field_info['rel_field_name']]
        return False

    #
    # --------------------------------------------------------------------------------
    
    def obj_type_foreign_keys(self, obj_type):
        """
        Return a list of foreign keys for this obj_type

        @param field string, field within the object-type
        """
        if not obj_type in self.obj_type_info_dict:
            return []
        return [x for x in self.obj_type_info_dict[obj_type]['fields']
                if self.is_foreign_key(obj_type, x)]

    #
    # --------------------------------------------------------------------------------
    
    def obj_type_show_title(self, obj_type):
        """
        Return a string, the display title for this table,
        never return None, only displayable values
        """
        if not obj_type in self.obj_type_info_dict:
            return ''
        if 'title' in self.obj_type_info_dict[obj_type]:
            return self.obj_type_info_dict[obj_type]['title']
        return obj_type

    #
    # --------------------------------------------------------------------------------

    def obj_type_set_title(self, obj_type, title):
        if not obj_type in self.obj_type_info_dict:
            self.obj_type_info_dict[obj_type] = {}
        self.obj_type_info_dict[obj_type]['title'] = title
        
    #
    # --------------------------------------------------------------------------------
    
    def obj_type_set_show_this(self, obj_type, this_list):
        if not obj_type in self.obj_type_info_dict:
            self.obj_type_info_dict[obj_type] = {}
        self.obj_type_info_dict[obj_type]['show-this'] = this_list
        
    #
    # --------------------------------------------------------------------------------
    
    def field_default_value(self, obj_type, field):
        """
        Return non null value of the default value of a field if its configured

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """
        if not obj_type in self.obj_type_info_dict:
            return None
        if not field in self.obj_type_info_dict[obj_type]['fields']:
            return None

        field_info = self.obj_type_info_dict[obj_type]['fields'][field]
        if 'default' in field_info:
            return field_info['default']
        return None

    #
    # --------------------------------------------------------------------------------
    
    def field_current_obj_type_default_value(self, field):
        """
        Return non null value of the default value of a field if its configured

        @param field string, field within the object-type
        """
        current_obj_type = self.sdnsh.get_current_mode_obj_type()

        if current_obj_type:
            if self.obj_type_has_field(current_obj_type, field):
                default = self.field_default_value(current_obj_type, field)
                if default == '':
                    return None
                return default
        return None

    #
    # --------------------------------------------------------------------------------
    
    def field_validation(self, obj_type, field):
        """
        Return the field validation function

        @param obj_type string, name of the object-type
        @param field string, field within the object-type
        """
        if 'validate' in self.obj_type_info_dict[obj_type]['fields'][field]:
            validate = self.obj_type_info_dict[obj_type]['fields'][field]['validate']
            return getattr(self, validate, None)
        return None

    #
    # --------------------------------------------------------------------------------
    
    def obj_type_prepare_row_update(self, obj_type):
        """
        Return the row update function is one is described in climodelinfo
        These callouts are intended to do fixup for the primary key's
        in a table where the field members are used to build the primary key

        @param field string, field within the object-type
        """
        if not obj_type in self.obj_type_info_dict:
            return None

        if 'update' in self.obj_type_info_dict[obj_type]:
            update = self.obj_type_info_dict[obj_type]['update']
            return getattr(self, update, None)
        return None

    
    #
    # --------------------------------------------------------------------------------

    def obj_type_show_sort(self, obj_type):
        """
        Return a sort-type for the obj-type during show.  The value is extracted
        from the obj_type_info_dict, and configured for the primary key for an
        obj-type, for example vns-access-list-entry's 'id' field shows
        'sort' : 'integer' to describe that the table's items
        are sorted by integer.
     
        Currently the sort-by field is not described in the
        cassandra model description

        @param field string, field within the object-type
        """

        if not obj_type in self.obj_keys:
            return None

        key = self.obj_keys[obj_type]
        if 'sort' in self.obj_type_info_dict[obj_type].get('fields', [])[key]:
            return self.obj_type_info_dict[obj_type]['fields'][key]['sort']
        return None

    #
    # --------------------------------------------------------------------------------
    
    def alias_obj_type_field(self, alias_obj_type):
        """
        Return a single field name for an obj_type, usually a foreign key
        in the model, which is the field associated with an alias.
        """
        foreign_keys = self.obj_type_foreign_keys(alias_obj_type)
        if len(foreign_keys) == 1:
            return foreign_keys[0]
        return None


    #
    # --------------------------------------------------------------------------------

    def not_default_value(self, obj_type, field, value):
        """
        Return True when the value passed in is not the default value.
        """
        default_value = self.field_default_value(obj_type, field)
    
        if (self.is_null_allowed(obj_type, field) and value != '') or \
          (not self.is_null_allowed(obj_type, field) and default_value != None
          and (default_value != value)):
            return True
        return False

    #
    # --------------------------------------------------------------------------------

    def obj_type_related_config_obj_type(self, obj_type):
        """
        If an obj-type doesn't have a rest model, for example - host, the obj_type
        may have a related config-table in the database, where additional configured
        data for the discovered data can be found.  Return the name of that table,
        for host, its host-condig
        """
        if not obj_type in self.obj_type_info_dict:
            return None

        if self.obj_type_has_model(obj_type):
            return obj_type

        if 'config-obj-type' in self.obj_type_info_dict[obj_type]:
            return self.obj_type_info_dict[obj_type]['config-obj-type']
        return None

    #
    # --------------------------------------------------------------------------------
    
    def obj_type_in_use_as_related_config_type(self, config_obj_type):
        """
        Return the obj_type is in use by the pased in config_obj_type
        or None otherwise.    Inverse of obj_type_related_config_obj_type
        """
        if config_obj_type == None:
            return None

        if not config_obj_type in self.obj_type_info_dict:
            return None

        for (ot, ov) in self.obj_type_info_dict.items():
            if ov.get('config-obj-type') == config_obj_type:
                return ot
        return None