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