class ExtendedInspectableAdapter(object): implements(IExtendedInspectable) adapts(IInspectable) def __init__(self, inspectable): self.context = inspectable def getattr(self, name): return self.context.getattr(name) def hasattr(self, name): return self.context.has_attr(name) def has_method(self, name): return self.context.has_method(name) def get_method(self, name): return self.context.get_method(name) def getattrs(self, names, conversions=[]): if not conversions: conversions = [None] * len(names) return map(self.getattr, names, conversions) def hasattrs(self, names): return map(self.hasattr, names) def has_methods(self, names): return map(self.has_method, names) def get_methods(self, names): return map(self.get_method, names)
class RSS2AlarmEventItem(object): implements(IRSS2ItemElement) adapts(IAlarmEvent) def __init__(self, alarmevent): self.alarmevent = alarmevent super(RSS2AlarmEventItem, self).__init__() def as_item(self): event = self.alarmevent item = rss.Item() alarm = event.source priority = alarm.priority if not priority: priority = 'Normal' title = "%s (%s): %s" % (alarm.name, priority, event.state.upper()) link = "http://%s/syndication?guid=%s" % (event.origin, event.GUID) item.title = rss.Title(title) item.link = rss.Link(link) item.guid = rss.Guid(event.GUID) item.pub_date = rss.PubDate(event.created()) description = alarm.description for change in event.get_audit(): description += '<br />\n%s. ' % change.tostring() item.description = rss.Description(tools.escape_html(description)) item.source = rss.Source(event.origin, "http://%s/syndication" % event.origin) eventcategory = rss.Category('Event') alarmcategory = rss.Category('Alarm') item.categories.append(eventcategory) item.categories.append(alarmcategory) return item def render(self): return str(self.as_item())
class OGConfigurableNeodeAdapter(object): implements(IConfigurableNode) adapts(IOGConfigurableNode) nodespace = None def __init__(self, node): directly_provides(self, *tuple(provided_by(node))) self.__dict__['node'] = node def get_nodespace(self): return OGConfigurableNeodeAdapter.nodespace def get_url(self): return as_node_url(self.node) url = property(get_url) absolute_url = url def __get_parent(self): parent = self.node.parent if parent is not None: parent = IConfigurableNode(parent) return parent parent = property(__get_parent) def __getattr__(self, name): return getattr(self.node, name) def __setattr__(self, name, value): if name == '__provides__': return super(OGConfigurableNeodeAdapter, self).__setattr__(name, value) return setattr(self.node, name, value)
class Adapts(object): implements(IA) adapts(INoA) def __init__(self, context): self.context = context def show(self, name = 'shane'): self.context.say(name)
class RSS2FaultEventItem(object): implements(IRSS2ItemElement) adapts(IFaultEvent) def __init__(self, faultevent): self.faultevent = faultevent def as_item(self): event = self.faultevent item = rss.Item() title = event.title faulttype = event.faulttype #item.title = rss.Title('%s: %s' % (title, faulttype)) item.title = rss.Title('%s (%s): %s' % (title, 'P1', event.state.upper())) item.link = rss.Link('http://%s/syndication?guid=%s' % (event.origin, event.GUID)) item.pub_date = rss.PubDate(event.timestamp) description = event.description event_history = event.history + [event.current_event] for change in event_history: description += '<br />\n%s. ' % change.detail item.description = rss.Description(tools.escape_html(description)) item.guid = rss.Guid(event.GUID) item.source = rss.Source(event.LOCALORIGIN, 'http://%s/syndication' % event.LOCALORIGIN) for category in event.types: item.categories.append(rss.Category(category)) return item def render(self): return str(self.as_item())
class OGCompositeNeodeAdapter(OGConfigurableNeodeAdapter): implements(ICompositeNode) adapts(IOGCompositeNode) def add_child(self, child): self.node._add_child(child) return path.join(self.url, child.name) def remove_child(self, childname): if not isinstance(childname, str): childname = childname.name del (self.node._children[childname]) def children_nodes(self, *args, **kw): nodes = self.node.children_nodes(*args, **kw) nodes = map(IConfigurableNode, nodes) return nodes def get_child(self, name, *args, **kw): node = self.node.get_child(name, *args, **kw) return IConfigurableNode(node) def as_node(self, *args): node = self.node.as_node(*args) return IConfigurableNode(node)
class UniquelyIdentified(object): implements(IUniquelyIdentified) adapts(Interface) def get_identifier(obj, default=None, create=False): uuid = MetaDataProvider.get_subject_meta(obj, 'identifier', default) if uuid is None and create: uuid = UniquelyIdentified(obj).identifier return uuid get_identifier = staticmethod(get_identifier) def get_identified(uuid, default=None): return identifier_registry.get(uuid, default) get_identified = staticmethod(get_identified) def __new__(klass, context): adapter = super(UniquelyIdentified, klass).__new__(klass) meta_context = IMetaDataProvider(context) uuid = meta_context.setdefault_meta('identifier', UUID()) identifier_registry.setdefault(uuid, context) adapter.initialize(meta_context) return adapter def initialize(self, context): self.context = context def __get_id(self): return self.context['identifier'] def __set_id(self, id): self.context['identifier'] = id identifier = property(__get_id, __set_id)
class LeafNodeDOM(object): implements(IDOMish) adapts(ILeafNode) def __init__(self, tag): self.tag = tag return def getAttribute(self, name): if hasattr(self.tag,name): return getattr(self.tag,name) elif hasattr(self.tag,'attr_dict'): if self.tag.attr_dict.has_key(name): ugh = self.tag.attr_dict[name].split('"') if len(ugh) == 3: return ugh[1] return None def setAttribute(self, name, value): if hasattr(self.tag,name): return setattr(self.tag,name,value) elif hasattr(self.tag,'attr_dict'): self.tag.attr_dict[name] = ' %s="%s"' % (name, value) return None def getTagById(self, id): my_id = self.getAttribute('id') if my_id == id: return self.tag return None
class PickleableOGCompositeNode(PickleableOGConfigurableNode): adapts(IOGCompositeNode) privatevars = PickleableOGConfigurableNode.privatevars[:] privatevars += ['_children'] def __init__(self, context): super(PickleableOGCompositeNode, self).__init__(context) context._children = getattr(context, '_children', {})
class MultiAdapts(object): implements(IB) adapts(INoA, INoB) def __init__(self, a, b): self.contexts = [a, b] def show(self, name = 'shane'): for context in self.contexts: context.say(name)
class HTMLScheduleForm(object): implements(IWebContent) adapts(ISchedule) def __init__(self, schedule): self.schedule = schedule def render(self, request_path): attrs = KeyWordAssist() document = HTMLgen.Div(**attrs("class", "content")) encoded_schedule = urllib.quote_plus(self.schedule.url) config_form = HTMLgen.Form(request_path) nodeinput = HTMLgen.Input(name='node', value=encoded_schedule, type='hidden') actioninput = HTMLgen.Input(name="actionName", value="configure", type="hidden") config_form.append(nodeinput) config_form.append(actioninput) config_form.submit.value = 'save' config_form.submit.onClick = ('return utils.schedule.' 'validate_configuration(this.form);') config_section = HTMLgen.Div(**attrs('class', 'section')) config_table = HTMLgen.TableLite( **attrs('class', 'configuration-table')) config_header = HTMLgen.TR(**attrs('class', 'table-header')) for header in ['Attribute', 'Value']: headcell = HTMLgen.TH(header, scope="col", abbr=header, id="%sheader" % header) if header == "Action": setattr(headcell, "class", "control") config_header.append(headcell) config_table.append(config_header) configrows = [] classes = itertools.cycle(['light', 'dark']) config = Dictionary(self.schedule.configuration()) namerow = HTMLgen.TR(**attrs('class', classes.next())) namerow.append(HTMLgen.TH('Schedule Name')) sched_name = config.pop('name').split("RZSched_") namefield = HTMLgen.Input(value=sched_name[1], name='configure.name') namerow.append(HTMLgen.TD(namefield, **attrs('class', 'configuration'))) configrows.append(namerow) config_table.append(*configrows) config_form.append(config_table) config_section.append(config_form) config_section.append( navigation(request_path, "reload", self.schedule.url)) config_section.append( navigation(request_path, "back", self.schedule.parent.url)) document.append(config_section) return str(document)
class AnyAdapts(object): implements(IB) adapts(None, INoB) def __init__(self, a, b): self.contexts = [a, b] def show(self, name = 'shane'): for context in self.contexts: try: context.say(name) except AttributeError: print 'Context %s has no say!' % context
class DomDocument(DomElement): __doc__ = IDomDocument.__doc__ implements(IDomDocument) adapts(IRootNode) def __init__(self, node): super(DomDocument, self).__init__(node) self._type = dom.Node.DOCUMENT_NODE # See mpx.www.w3c.dom.interfaces.IDomDocument def __get_document_element(self): # Root is this object's node. return IDomNode(self.node) documentElement = property(__get_document_element) def __get_nodespace(self): return self.node.get_nodespace() nodespace = property(__get_nodespace) def getElementById(self, id): """ ID is the node URL. """ return IDomNode(self.nodespace.as_node(id)) def createElement(self, tagName): "See mpx.www.w3c.dom.interfaces.IDomDocument" raise Exception("Not implemented") def createElementNS(self, namespaceURI, tagName): "See mpx.www.w3c.dom.interfaces.IDomDocument" raise Exception("Not implemented") def createTextNode(self, data): "See mpx.www.w3c.dom.interfaces.IDomDocument" raise Exception("Not implemented") def createComment(self, data): "See mpx.www.w3c.dom.interfaces.IDomDocument" raise Exception("Not implemented") def createProcessingInstruction(self, target, data): "See mpx.www.w3c.dom.interfaces.IDomDocument" raise Exception("Not implemented") def createAttribute(self, name): "See mpx.www.w3c.dom.interfaces.IDomDocument" raise Exception("Not implemented") def createAttributeNS(self, namespaceURI, qualifiedName): "See mpx.www.w3c.dom.interfaces.IDomDocument" raise Exception("Not implemented")
class BroadwayConfigurableGenerator(object): implements(IBroadways) adapts(IConfigurableNode) nodeopen = "<node name='%s' node_id='%s' module='%s.%s' config_builder='' inherant='false' description=''>" nodeclose = "</node>" configopen = "\t<config>" configclose = "\t</config>" propertyopenclose = "\t\t<property name='%s' value='%s'/>" def __init__(self, node): self.node = node def _xml_lines(self, levels=None): realnode = self.node while isinstance(realnode, OGConfigurableNeodeAdapter): realnode = realnode.node classname = realnode.__class__.__name__ module = realnode.__class__.__module__ xmllines = [self.nodeopen % (self.node.name, 0, module, classname)] xmllines.append(self.configopen) configuration = self.node.configuration() if configuration.has_key('parent'): del (configuration['parent']) if configuration.has_key('name'): del (configuration['name']) for name, value in configuration.items(): if not isinstance(value, str): value = str(value) value = encode_xml(value) xmllines.append(self.propertyopenclose % (name, value)) xmllines.append(self.configclose) xmllines.append(self.nodeclose) return xmllines def dumps(self, levels=None): return string.join(self._xml_lines(levels), '\n') def loads(self, data): datastream = StringIO.StringIO(data) xmlroot = parse_xml(datastream) xmlroot.parent = self.node.url crawler = Iterator(xmlroot) nodecount = 0 while crawler.has_more(): xmlnode = crawler.get_next_node() config = xmlnode.get_config() print 'Loading node %d: %s' % (nodecount, config) node = load_node(config) node.configure(config) nodecount += 1 return nodecount def dump(self, datastream, levels=None): return datastream.write(self.dumps(levels))
class DataContainterDOM(LeafNodeDOM): implements(IDOMish) adapts(IDataContainer) def getTagById(self, id): result = super(DataContainterDOM,self).getTagById(id) if result is None: for tag in self.tag.data: result = domish(tag).getTagById(id) if result is not None: return result return result
class HTMLRoleManagerForm(HTMLSimpleManagerForm): adapts(IRoleManager) def add_child_form(self, content): popup = HTMLgen.Form("#") popup.submit.value = "+" popup.submit.name = "Add Role" popup.submit.onClick = "return popup_form(this, '%s', true)" % addform content.append(popup) def get_allowed_additions(self): return ['Role']
class PickleAdapter(object): implements(IPickles) adapts(Interface) def __init__(self, context): self.context = context def __getinitargs__(self): return self.context def __call__(self): return self.context
class HTMLRoleForm(object): implements(IWebContent) adapts(IRole) def __init__(self, role): self.role = role self.base_doc = HTMLgen.SimpleDocument(title='Role Editor') def render(self, request_path): attrs = KeyWordAssist() document = self.base_doc.copy() encoded = cgi.escape(self.role.parent.name) manager = HTMLgen.Input(name='manager', type='hidden', value=encoded) encoded = cgi.escape(self.role.name) node = HTMLgen.Input(name='node', type='hidden', value=encoded) config_form = HTMLgen.Form(request_path) config_form.append(manager) config_form.append(node) config_form.submit.value = 'commit' hidden = HTMLgen.Input(name="actionName", type='hidden', value="configure") config_form.append(hidden) config_section = HTMLgen.Div(**attrs('class', 'section')) config_table = HTMLgen.TableLite(**attrs('class', 'configuration')) headrow = HTMLgen.TR(**attrs('class', 'table-header')) for header in ['Attribute', 'Value']: headcell = HTMLgen.TH(header, scope="col", abbr=header, id="%sheader" % header) if header == "Value": setattr(headcell, "class", "control") headrow.append(headcell) config_table.append(headrow) configrows = [] rowclasses = ['light', 'dark'] config = Dictionary(self.role.configuration()) namerow = HTMLgen.TR(**attrs('class', rowclasses[len(configrows) % 2])) namerow.append(HTMLgen.TH('Role Name')) namefield = HTMLgen.Input(value=config.pop('name'), name='configure.name') namefield.onFocus = "this.readOnly=true;this.style.color='grey'" namerow.append(HTMLgen.TD(namefield, **attrs('class', 'control'))) configrows.append(namerow) config_table.append(*configrows) config_form.append(config_table) config_section.append(adorn(config_form, id="main")) document.append(config_section) return str(document)
class ListenerAdapter(object): implements(IMessageChannel) adapts(IMessageListener) def __init__(self, listener): self.listener = listener super(ListenerAdapter, self).__init__() def send(self, message): self.listener.handle_message(message) def __eq__(self, other): return self.listener == other.listener
class ChannelAdapter(object): """ Wrap Channel instance with message listener interface. """ implements(IMessageListener) adapts(IMessageChannel) def __init__(self, channel): self.channel = channel super(ChannelAdapter, self).__init__() def handle_message(self, message): self.channel.send(message) def __eq__(self, other): return self.channel == other.channel
class IOGRemoteNodeSecurityAdapter(object): implements(ISecure) adapts(IOGRemoteNode, IUser) def __init__(self, facade, user): directly_provides(self, *tuple(provided_by(facade))) self.__dict__['facade'] = facade self.__dict__['user'] = user def __getattr__(self, name): return getattr(self.facade, name) def __setattr__(self, name, value): if name == '__provides__': return super(IOGRemoteNodeSecurityAdapter, self).__setattr__(name, value) return setattr(self.facade, name, value)
class TriggerPickler(object): implements(IPickles) adapts(ITrigger) def __init__(self, trigger): self.trigger = trigger def __getstate__(self): trigger = self.trigger if not hasattr(trigger, '__picklestate'): state = { 'class': type(trigger), 'url': trigger.url, 'config': trigger.configuration() } trigger.__picklestate = state state = trigger.__picklestate state['targets'] = [] targets = trigger.get_targets(True) for target in targets: if not isinstance(target, str): target = target.url state['targets'].append(target) state['running'] = trigger.is_running() return state def __setstate__(self, state): self.trigger = None self.state = state def __call__(self): if self.trigger is None: try: self.trigger = as_node(self.state['url']) except KeyError: self.trigger = self.state.get('class')() config = self.state['config'] parent = as_node(config['parent']) config.setdefault('nodespace', parent.nodespace) self.trigger.configure(config) if self.state['running']: self.trigger.start() for target in self.state.get('targets', []): self.trigger.add_target(target) return self.trigger
class ExporterPickler(object): implements(IPickles) adapts(IAlarmExporter) def __init__(self, exporter): self.exporter = exporter def __getstate__(self): exporter = self.exporter if not hasattr(exporter, '__picklestate'): state = { 'class': type(exporter), 'url': exporter.url, 'config': exporter.configuration() } exporter.__picklestate = state state = exporter.__picklestate sources = self.exporter.get_sources() state['sources'] = {} for source in sources: state['sources'][source.url] = self.exporter.get_event_names( source) return state def __setstate__(self, state): self.exporter = None self.state = state def __call__(self): if self.exporter is None: try: self.exporter = as_node(self.state['url']) except KeyError: self.exporter = self.state.get('class')() config = self.state['config'] parent = as_node(config['parent']) config.setdefault('nodespace', parent.nodespace) self.exporter.configure(config) self.exporter.start() for source, args in self.state.get('sources', {}).items(): try: self.exporter.add_source(source, *args) except: msglog.exception() return self.exporter
class DomConfigurableNode(object): __doc__ = IDomNode.__doc__ implements(IDomNode) adapts(IConfigurableNode) def __init__(self, node): self.node = node self._type = dom.Node.ELEMENT_NODE super(DomConfigurableNode, self).__init__(node) # See mpx.www.w3c.dom.interfaces.IDomNode def __get_node_class(self): return type(self.node) nodeClass = property(__get_node_class) def __get_node_classname(self): klass = self.nodeClass return string.join((klass.__module__, klass.__name__), '.') nodeClassName = property(__get_node_classname) def __get_node_id(self): return self.node.url nodeID = property(__get_node_id) def __get_node_type(self): return self._type nodeType = property(__get_node_type) # See mpx.www.w3c.dom.interfaces.IDomNode def __get_parent_node(self): if self.node.parent is None: return None try: parent = IDomNode(self.node.parent) except TypeError, error: print 'IDomNode(node.parent) failed: ' + str(error) print '\treturning None for parent.' parent = None return parent
class Pickleable(object): implements(IPickleable) adapts(IPersistent) excludes = {'__dict__': None, '__weakref__': None} context = None def __init__(self, context): self.contexttype = type(context) self.contextstate = context.__dict__ self.context = context def __getstate__(self): names = filter(self.should_persist, self.contextstate.keys()) values = map(self.contextstate.get, names) return {'type': self.contexttype, 'state': dict(zip(names, values))} def __setstate__(self, state): print 'Pickleable.__setstate__' contexttype = state['type'] contextstate = state['state'] print '\tContext type: %s' % (contexttype, ) print '\tState: %s' % (contextstate, ) context = self.instantiate(contexttype) context.__dict__.update(contextstate) self.contexttype = contexttype self.contextstate = context.__dict__ self.context = context print 'Pickleable instantiated %s' % self.context.name def instantiate(self, contexttype): return contexttype.__new__(contexttype) def write_object(self): return self def read_object(self): print 'Pickleable %s read object %s' % (self, self.context) return self.context def should_persist(self, key): return not (self.excludes.has_key(key) or key.startswith('__persistence'))
class BroadwayCompositeGenerator(BroadwayConfigurableGenerator): implements(IBroadways) adapts(ICompositeNode) def dumps(self, levels=None): xmllines = super(BroadwayCompositeGenerator, self)._xml_lines(levels) nodeclose = xmllines.pop() if levels is not None: levels -= 1 childdumps = [] if levels != 0: children = self.node.children_nodes() generators = map(IBroadways, children) childdumps = [generator.dumps(levels) for generator in generators] xmllines.extend(childdumps) xmllines.append(nodeclose) return string.join(xmllines, '\n') def dump(self, datastream, levels=None): pass
class ExtendedModifiableAdapter(object): implements(IExtendedModifiable) adapts(IModifiable) def __init__(self, inspectable): self.context = inspectable def setattr(self, name, value, conversion=None): self.context.setattr(name, value, conversion) def delattr(self, name): self.context.delattr(name) def setattrs(self, names, values, conversions=[]): if not conversions: conversions = [None] * len(names) map(self.setattr, names, values, conversions) def delattrs(self, names): map(self.delattr, names)
class HTMLPolicyManagerForm(HTMLSimpleManagerForm): adapts(IPolicyManager) def add_child_form(self, content): popup = HTMLgen.Form("#") popup.submit.value = "+" popup.submit.name = "Add Policy" popup.submit.onClick = "return popup_form(this, '%s', true)" % addform content.append(popup) def get_row_actions(self, child): actions = [] if child.is_configurable(): actions.append('edit') actions.append('permissions') if child.is_removable(): actions.append('remove') return actions def get_allowed_additions(self): return ['Policy']
class ConfigurableNodePickler(object): implements(IPickles) adapts(IConfigurableNode) def __init__(self, node): self.node = node def __getstate__(self): node = self.node while isinstance(node, OGConfigurableNeodeAdapter): node = node.node state = { 'class': type(node), 'url': self.node.url, 'config': self.node.configuration() } return state def __setstate__(self, state): self.node = None self.state = state def __call__(self): if self.node is None: try: self.node = _node.rootspace.as_node(self.state['url']) except KeyError: self.node = self.state.get('class')() else: try: self.node.stop() except: pass config = self.state['config'] parent = _node.rootspace.as_node(config['parent']) config.setdefault('nodespace', parent.nodespace) self.node.configure(config) self.node.start() return self.node
class HTMLUserManagerForm(HTMLSimpleManagerForm): adapts(IUserManager) def render(self, *args): content = super(HTMLUserManagerForm, self).render(*args) popup = HTMLgen.Form("#") popup.submit.value = " + " popup.submit.name = "Add User" popup.submit.onClick = "return popup_form(this, '%s', true)" % addform return "\n".join([content, str(popup)]) def get_row_actions(self, child): actions = [] if not hasattr(child, 'is_configurable') or child.is_configurable(): actions.append('edit') actions.append("roles") if not hasattr(child, 'is_removable') or child.is_removable(): actions.append('remove') return actions def get_allowed_additions(self): """Special handling of User addition appended to form by render.""" return []