class SelectorField(broom.BroomObject):
__tablename__ = 'selector_field'
__table_args__ = (broom.UniqueConstraint("name"), )
selector_field_id = broom.Serial(__tablename__, primary_key=True)
name = broom.Column(broom.String, nullable=False)
weight = broom.Column(broom.Integer, nullable=False)
ID = broom.stored('selector_field_id')
Name = broom.stored('name')
Weight = broom.stored('weight')
class SelectorNode(broom.BroomObject):
__tablename__ = 'selector_node'
selector_node_id = broom.Serial(__tablename__, primary_key=True)
selector_node_type = broom.Column(
broom.String,
broom.ForeignKey("val_selector_node_type.selector_node_type"),
nullable=False)
parent_selector_node_id = broom.Column(
broom.Integer, broom.ForeignKey("selector_node.selector_node_id"))
selector = broom.relationship("Selector", back_populates="root_node")
parent_node = broom.relationship("SelectorNode",
back_populates="child_nodes",
remote_side=[selector_node_id])
child_nodes = broom.relationship("SelectorNode",
back_populates="parent_node")
node_type = broom.relationship("SelectorNodeType")
__mapper_args__ = {
'polymorphic_on': selector_node_type,
'with_polymorphic': '*'
}
ID = broom.stored('selector_node_id')
Type = broom.stored('selector_node_type')
_Children = broom.stored('child_nodes')
@broom.field
def Children(self):
return [
c.RootNode() if isinstance(c, broom.types.Selector) else c
for c in self._Children()
]
@broom.field
def IsExpression(self):
return self.Type() == 'expression'
@broom.field
def IsLeafNode(self):
return not self.Children()
def evaluate(self, selector, objs):
raise NotImplementedError()
def __repr__(self):
return '%s(Children=%s)' % (self.__class__.__name__, self.Children())
class SelectorNodeType(broom.BroomObject):
__tablename__ = 'selector_node_type'
__table_args__ = (
broom.CheckConstraint("max_children IS NULL or min_children <= max_children"),
)
selector_node_type = broom.Column(broom.String, primary_key=True)
min_children = broom.Column(broom.Integer, broom.CheckConstraint("min_children >= 0"), nullable=False, server_default=broom.text("0"))
max_children = broom.Column(broom.Integer)
Type = broom.stored('selector_node_type')
MinChildren = broom.stored('min_children')
MaxChildren = broom.stored('max_children')
class SelectorEquals(SelectorNode):
# TODO: All expressions are equals, so we should update the table
# name to reflect this.
__tablename__ = 'selector_node_expression'
selector_node_id = broom.Column(
broom.Integer,
broom.ForeignKey("selector_node.selector_node_id"),
primary_key=True)
selector_field_id = broom.Column(
broom.Integer, broom.ForeignKey("selector_field.selector_field_id"))
value = broom.Column(broom.String)
selector_field = broom.relationship("SelectorField", uselist=False)
# TODO: The node type value (and thus identity value set in
# __mapper_args__) should be 'equals'.
__mapper_args__ = {'polymorphic_identity': 'expression'}
Field = broom.stored('selector_field')
Value = broom.stored('value')
@broom.field
def Key(self):
if self.Field():
return self.Field().Name()
def evaluate(self, selector, objs):
ret = set()
for obj in objs:
if getattr(obj, self.Key()) != self.Value():
continue
# TODO: Consider using descriptors to allow for update-
# by-reference while still invalidating the graph.
attractions = selector.AttractionByObject()
attractions[obj].update(self.Field())
selector.AttractionByObject = attractions
ret.add(obj)
return ret
def __repr__(self):
return '%s(Key=%s, Value=%s)' % (self.__class__.__name__, self.Key(),
self.Value())
class Service(broom.BroomObject):
__tablename__ = 'service'
__table_args__ = (broom.UniqueConstraint("name"), )
service_id = broom.Serial(__tablename__, primary_key=True)
name = broom.Column(broom.String, nullable=False)
description = broom.Column(broom.String)
service_instantiations = broom.relationship("ServiceInstantiation",
back_populates="service")
ID = broom.stored('service_id')
Name = broom.stored('name')
Description = broom.stored('description')
ServiceInstantiations = broom.stored('service_instantiations')
@broom.field
def ServiceInstantiationNames(self):
return [si.Name() for si in self.ServiceInstantiations()]
class ServiceInstantiation(broom.BroomObject):
__tablename__ = 'service_instantiation'
__table_args__ = (broom.UniqueConstraint("name"),
broom.UniqueConstraint("domain_name", "port",
"transport_protocol"))
service_instantiation_id = broom.Serial(__tablename__, primary_key=True)
service_id = broom.Column('service_id',
broom.Integer,
broom.ForeignKey('service.service_id'),
nullable=False)
name = broom.Column('name', broom.String, nullable=False)
domain_name = broom.Column('domain_name', broom.String, nullable=False)
port = broom.Column('port', broom.Integer)
transport_protocol = broom.Column('transport_protocol',
broom.String,
nullable=False)
application_protocol = broom.Column('application_protocol', broom.String)
service = broom.relationship("Service",
back_populates="service_instantiations")
_selectors_by_role = broom.relationship(
"SelectorServiceInstantiation", back_populates="service_instantiation")
ID = broom.stored('service_instantiation_id')
Service = broom.stored('service')
Name = broom.stored('name')
DomainName = broom.stored('domain_name')
Port = broom.stored('port')
TransportProtocol = broom.stored('transport_protocol')
ApplicationProtocol = broom.stored('application_protocol')
_SelectorsByRole = broom.stored('_selectors_by_role')
@broom.field
def SelectorsByRole(self):
return dict((a.Role(), a.Selector()) for a in self._SelectorsByRole())
class Selector(broom.BroomObject):
__tablename__ = 'selector'
__table_args__ = (broom.UniqueConstraint("name"), )
selector_id = broom.Serial(__tablename__, primary_key=True)
name = broom.Column(broom.String, nullable=False)
root_node_id = broom.Column(
broom.Integer,
broom.ForeignKey("selector_node.selector_node_id"),
nullable=False)
root_node = broom.relationship("SelectorNode", back_populates="selector")
selector_service_instantiations = broom.relationship(
"SelectorServiceInstantiation", back_populates="selector")
class _HashableDict(object):
"""Wrapper for normally unhashable dictionaries.
"""
def __init__(self, unhashable):
self._unhashable = unhashable
get = dict.get
@property
def unhashable(self):
return self._unhashable
def __getattr__(self, n):
return self.unhashable.get(n)
ID = broom.stored('selector_id')
Name = broom.stored('name')
RootNode = broom.stored('root_node')
SelectorServiceInstantiations = broom.stored(
'selector_service_instantiations')
@broom.field
def Children(self):
return [self.RootNode()]
@broom.field(broom.Settable)
def AttractionByObject(self):
return collections.defaultdict(
lambda: SelectorAttraction(SelectorObject=self))
def hashable(self, o):
if isinstance(o, dict):
return self._HashableDict(o)
return o
def evaluate(self, objs):
if not objs:
return []
objs = self.RootNode().evaluate(self,
set([self.hashabl(o) for o in objs]))
return [
(obj.unhashable if isinstance(obj, self._HashableDict) else obj,
self.AttractionByObject()[obj]) for obj in objs
]
def evaluateOne(self, obj):
res = self.evaluate([obj])
if not res:
return None
obj, attraction = res[0]
return attraction
@broom.field
def ServiceInstantiationsByRole(self):
return dict(
(obj.Role(), obj) for obj in self.SelectorServiceInstantiations())