root/tags/v1.0/object.py

#
# Configuration objects
#

import sys

class ConfigKlass:
    """
    A ConfigObject is an abstract representation of something
    that has configuration. We can perform common configuration
    operations on ConfigObjects, based on what their configuration
    is.
    """
    def __init__(self, name):
        # attributes that all configuration objects have

        # The generic class name of object, just a string
        self.name = name

        # A list of attributes that this object may have.
        # This is an attribute vocabulary.
        self.attrib = {}

        # A list of klasses I can contain
        self.can_contain = {}

        # A list of klasses I can connect to
        self.can_connect = {}

    def attribute(self, name, attrib_type):
        """
        Add an attribute to this config object
        """
        self.attrib[name] = Attribute(name, attrib_type)

    def contains(self, klassname, min=1, max=sys.maxint):
        """
        Add a containment relationship to the list
        """
        r = Contains(klassname, min, max)
        self.can_contain[klassname] = r

    def connects_to(self, klassname, min=1, max=sys.maxint):
        r = ConnectsTo(klassname, min, max)
        self.can_connect[klassname] = r

    def __str__(self):
        retstr = ['ConfigKlass: %s' % self.name, ]
        retstr += ['  Attributes:',] + [ '    %s' % a for a in self.attrib.values() ]
        retstr += ['  Contains:',] + [ '    %s' % a for a in self.can_contain.values() ]
        retstr += ['  Connects to:',] + [ '    %s' % a for a in self.can_connect.values() ]
        return '\n'.join(retstr)

class Attribute:
    """
    An Attribute is a description of a single attribute that
    a configuration object can have.

    Attributes are stored in a database in some method. This
    could be, in postgres, a set of tables, one for each type,
    so the table would be something like:

    attrib_int ( object_id FOREIGN_KEY, name VARCHAR, value INTEGER )
    attrib_ipaddr ( object_id FOREIGN_KEY, name VARCHAR, value IPADDR )

    which would key into the main object entity table:

    objects ( object_id PRIMARY_KEY, klass VARCHAR UNIQUE )

    Then, to get a particular object's information:

    select * from objects LEFT JOIN attrib_int,attrib_varchar,attrib_ipaddr... etc for all tables
    joining on the object_id
    
    """
    def __init__(self, name, type):

        # all attributes must have a name
        self.name = name

        # Type provides an indication of the database style
        # type that would be used for this attribute, eg:
        #    string 
        #    boolean
        #    int
        #    long
        #    float
        #    ipaddr
        #    
        self.type = type

    def __str__(self):
        return 'Attribute: %s [%s]' % (self.name, self.type)

class RelationshipType:
    """
    Objects are related to one another by a Relationship, which
    will be of a particular RelationshipType that constrains
    the nature of the relationship.

    Stored in a database thus:

    relationships = ( object_id FOREIGN_KEY, relation_type, related_obj
    """
    def __init__(self, klass, min, max):

        # The klass of object that this object can be related to
        self.related_klass = klass

        # The minimum number of other objects this object should
        # be related to.
        self.related_min = min

        # The maximum number of other objects this object should
        # be related to.
        self.related_max = max

    def __str__(self):
        return 'Relationship: %s [min: %d, max: %d]' % (self.related_klass, self.related_min, self.related_max)
        
class Contains(RelationshipType):
    """
    The contains relationship says that an object contains
    some number of other objects.
    """

class ConnectsTo(RelationshipType):
    """
    An object connects to another by some mechanism.
    """

class ConfigObject:
    """
    A ConfigObject is a specific instance of a ConfigKlass.

    The ConfigKlass governs the possible configuration parameters
    of this object.
    """
    def __init__(self, klass):
        self.klass = klass

        # name, value pairs for my attributes
        self.attrib = {}

        # name, value pairs for my relationships

    def __setitem__(self, name, value):
        """
        Set attribute named 'name' to value.
        Performs various constraint checks on the
        attribute first.
        """
        # attempt to fetch the attribute from my klass, raising exceptions as required
        try:
            self.klass.attrib[name]
        except KeyError, e:
            raise KeyError("ConfigObject klass type '%s' does not support attribute: %s" % (self.klass.name, e))

        print "attribute valid!"

        self.attrib[name] = value

    def __getitem__(self, name):
        """
        Try fetching an attribute value
        """
        try:
            return self.attrib[name]
        except KeyError:
            # check to see if this attribute is available on this object's klass
            if not self.klass.attrib.has_key(name):
                raise KeyError("Attribute %s is not available on objects of type %s" % (name, self.klass.name))

if __name__ == '__main__':

    klasslist = {}

    # set up a switch object class
    switch = ConfigKlass('switch')

    switch.attribute('name', 'varchar')

    switch.contains('port', 24, 24)
    switch.contains('cpu', 1)
    switch.connects_to('switch')
    
    # Doing this when loading, I'll have to temporarily store objects
    # if they can contain or connect to ones that haven't been loaded yet
    # and then fix all the relationships at the end.

    klasslist['switch'] = switch
    
    port = ConfigKlass('switchport')

    klasslist['port'] = port

    obj = ConfigObject(klasslist['switch'])

    for klass in klasslist.values():
        print '%s' % klass

    obj['name'] = 'fred'
    obj['port'] = 'fred'