row.append(actioncell)
exporter_table.append(row)
exporter_section.append(exporter_table)
add_form = HTMLgen.Form(request_path)
addinput = HTMLgen.Input(name='add', value='true', type='hidden')
add_form.append(addinput)
section = HTMLgen.Input(name='section', type='hidden', value="main")
add_form.append(section)
add_form = adorn(add_form, targetType="dialog")
add_form.submit.value = 'add'
exporter_section.append(add_form)
document.append(exporter_section)
return str(document)
register_adapter(HTMLExporterContainer)
class HTMLAlarmExporter(object):
implements(IWebContent)
adapts(IAlarmExporter)
def __init__(self, exporter):
self.exporter = exporter
self.base_doc = HTMLgen.SimpleDocument(title='Alarm Exporter')
def render(self):
"""
Configuration should be broken into three main topics.
Edit, associated with an 'edit' button on the manager
page, exposes name and other standard node configuration
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']
register_adapter(HTMLPolicyManagerForm, [IPolicyManager])
class IdentifiedInput(HTMLgen.Input):
def __init__(self, *args, **kw):
self.id = kw.get('id', '')
if kw.has_key('id'):
del (kw['id'])
HTMLgen.Input.__init__(self, *args, **kw)
def __str__(self):
output = HTMLgen.Input.__str__(self)
fragments = output.split(' ')
if self.id:
fragments.insert(1, 'ID="%s"' % self.id)
return string.join(fragments, ' ')
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']
register_adapter(HTMLRoleManagerForm, [IRoleManager])
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)
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)
register_adapter(UniquelyIdentified)
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())
register_adapter(RSS2AlarmManager)
register_adapter(RSS2AlarmEventItem)
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
register_adapter(ExporterPickler)
field = abnormal.get(aname)
else:
field = HTMLgen.Input(name=qname, value=qvalue)
row = HTMLgen.TR(**attrs('class', classes.next()))
row.append(
HTMLgen.TH(qname, **attrs("class", "attribute-name")))
row.append(
HTMLgen.TD(field, **attrs("class", "attribute-value")))
table.append(row)
form.append(table)
form.submit.value = form.submit.name = "save"
cancel = HTMLgen.Input(type="reset", value="cancel", name="cancel")
form.append(cancel)
# CSCte94385 (fix disabled for now) - validate invalid chars
dialogId = "edit"
#strScript = ("function " + dialogId + "_validate() { if(document.getElementById('" + dialogId + "').name.value.match('[^a-zA-Z0-9_]')) { " +
# "alert('Error: Name should have only alphanumeric and _ charaters.');" +
# "return false;}" +
# "return true;}")
#script = HTMLgen.Script(language="JavaScript", code=strScript)
#form.append(script)
form = adorn(form, id=dialogId)
form = adorn(
form, onsubmit="return false"
) #This will disable form submission when enter key is pressed (CSCtg05439)
return str(form)
register_adapter(HTMLAlarmManager)
register_adapter(HTMLAlarm)
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']
register_adapter(HTMLPolicyManagerForm, [IPolicyManager])
class IdentifiedInput(HTMLgen.Input):
def __init__(self, *args, **kw):
self.id = kw.get('id', '')
if kw.has_key('id'):
del(kw['id'])
HTMLgen.Input.__init__(self, *args, **kw)
def __str__(self):
output = HTMLgen.Input.__str__(self)
fragments = output.split(' ')
if self.id:
fragments.insert(1, 'ID="%s"' % self.id)
return string.join(fragments, ' ')
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
register_adapter(TriggerPickler)
from mpx.service.alarms2.interfaces import IActionEvent
from mpx.service.alarms2.interfaces import IFlatAlarmManager
from mpx.componentry.security.interfaces import ISecurityContext
class AlarmEventSecurityContext(object):
implements(ISecurityContext)
adapts(IAlarmEvent)
def __init__(self, event):
self.event = event
def get_context(self):
return self.event.source
def get_context_url(self):
return self.get_context().url
url = property(get_context_url)
register_adapter(AlarmEventSecurityContext)
class ActionEventPickler(object):
implements(IPickles)
adapts(IActionEvent)
def __init__(self, action):
self.action = action
self.state = None
def __getstate__(self):
if self.action is None:
return self.state
action = self.action
if not hasattr(action, '__picklestate'):
state = {'class': type(action),
'GUID': action.GUID,
'source': EventSource(action.source)}
</form>
"""
addform = urllib.quote(addform)
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']
register_adapter(HTMLRoleManagerForm, [IRoleManager])
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)
work to be covered by the GNU General Public License. However
the source code for this file must still be made available in
accordance with section (3) of the GNU General Public License.
This exception does not invalidate any other reasons why a work
based on this file might be covered by the GNU General Public
License.
"""
from mpx.componentry import Interface
from mpx.componentry import implements
from mpx.componentry import adapts
from mpx.componentry import register_adapter
from interfaces import IPickles
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
register_adapter(PickleAdapter)
class PickleableOGConfigurableNode(PickleableConfigurableNode):
adapts(IOGConfigurableNode)
privatevars = ['name', 'parent']
excludevars = ['name', 'parent']
class PickleableCompositeNode(PickleableConfigurableNode):
adapts(ICompositeNode)
privatevars = PickleableConfigurableNode.privatevars[:]
privatevars += ['_CompositeNode__children', '_CompositeNode__nameorder']
class PickleableOGCompositeNode(PickleableOGConfigurableNode):
adapts(IOGCompositeNode)
privatevars = PickleableOGConfigurableNode.privatevars[:]
privatevars += ['_children']
def __init__(self, context):
super(PickleableOGCompositeNode, self).__init__(context)
context._children = getattr(context, '_children', {})
register_adapter(Pickleable)
register_adapter(PersistentAdapter)
register_adapter(PickleableConfigurableNode, IConfigurableNode, IPickleable)
register_adapter(PickleableOGConfigurableNode, IOGConfigurableNode,
IPickleable)
register_adapter(PickleableCompositeNode, ICompositeNode, IPickleable)
register_adapter(PickleableOGCompositeNode, IOGCompositeNode, IPickleable)
register_adapter(PickleableAlarm, IAlarm, IPickleable)
class NoI(object):
def say(self, something):
print 'NoIB: ' + something
class AdaptsNone(object):
implements(IC)
adapts(None)
def __init__(self, context):
self.context = context
def show(self, name = 'shane'):
self.context.say(name)
register_adapter(AdaptsNone)
noi = NoI()
adaptednoi = IC(noi)
assert type(adaptednoi) is AdaptsNone, 'Got wrong Adapter!'
class Adapts(object):
implements(IA)
adapts(INoA)
def __init__(self, context):
self.context = context
def show(self, name = 'shane'):
self.context.say(name)
class AdaptsSubclass(Adapts):
"""
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
register_adapter(ChannelAdapter)
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 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)
register_adapter(IOGRemoteNodeSecurityAdapter)
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)
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))
register_adapter(BroadwayConfigurableGenerator)
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)
return False
def appendChild(self, newChild):
raise Exception("Invalid operation on ConfigurableNode.")
def insertBefore(self, newChild, refChild):
raise Exception("Invalid operation on ConfigurableNode.")
def removeChild(self, oldChild):
raise Exception("Invalid operation on ConfigurableNode.")
def replaceChild(self, newChild, oldChild):
raise Exception("Invalid operation on ConfigurableNode.")
register_adapter(DomConfigurableNode)
class DomCompositeNode(DomConfigurableNode):
__doc__ = IDomNode.__doc__
# implements(IDomNode)
adapts(ICompositeNode)
# See mpx.www.w3c.dom.interfaces.IDomNode
def __get_child_nodes(self):
children = self.node.children_nodes()
return map(IDomNode, children)
childNodes = property(__get_child_nodes)
)
confirm_form.submit.append(
CustomInput(type='submit', name='cancelupdate', value='Cancel')
)
return confirm_form
def render(self):
document = HTMLgen.SimpleDocument(
title="Confirm",
stylesheet='/omega/trendmanager/styles.css',
)
# Hack-around to set the class on the BODY for HTMLGen
document.append(
HTMLgen.Script(code="""
document.body.className = 'manager';
"""),
)
document.append(
HTMLgen.Heading(2, "Trend Confirm Changes",
id="editorlabel")
)
section = HTMLgen.Div(**{'class':'section'})
self.confirm_form = self.create_confirm_form()
self.hidden_point_div = self.create_hidden_point_div()
self.confirm_form.append(self.hidden_point_div)
self.point_confirmation_div = self.create_point_confirmation()
self.confirm_form.append(self.point_confirmation_div)
section.append(self.confirm_form)
document.append(section)
return str(document)
register_adapter(HTMLConfirmUpdateTrend)
from mpx.lib.messaging.channel.interfaces import IMessageChannel
from mpx.lib.messaging.channel.interfaces import IMessageListener
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
register_adapter(ChannelAdapter)
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
register_adapter(ListenerAdapter)
add_form = adorn(add_form,
targetHandling="content",
targetID="schedule-configuration")
addform = urllib.quote(str(add_form))
popup = HTMLgen.Form(request_path)
popup.submit.value = "+"
onclick = "return popup_form(this, '%s', true)"
popup.submit.onClick = onclick % addform
children_section.append(adorn(popup, ("class", "add")))
children_section.append(
navigation(request_path, "reload", self.parent.url))
document.append(children_section)
return str(document)
register_adapter(HTMLScheduleHolderParentForm)
class HTMLScheduleHolderForm(object):
implements(IWebContent)
adapts(IScheduleHolder)
def __init__(self, holder):
self.path = None
self.holder = holder
def get_request_path(self):
return self.path
def get_page_heading(self):
return self.holder.name
row.append(actioncell)
trigger_table.append(row)
trigger_section.append(trigger_table)
add_form = HTMLgen.Form(request_path)
addinput = HTMLgen.Input(name='add', value='true', type='hidden')
add_form.append(addinput)
section = HTMLgen.Input(
name='section', type='hidden', value="main")
add_form.append(section)
add_form = adorn(add_form, targetType="dialog")
add_form.submit.value = 'add'
trigger_section.append(add_form)
document.append(trigger_section)
return str(document)
register_adapter(HTMLTriggerManager)
class HTMLTrigger(object):
implements(IWebContent)
adapts(ITrigger)
def __init__(self, trigger):
self.trigger = trigger
self.base_doc = HTMLgen.SimpleDocument(
title='Trigger', stylesheet='/omega/eventmanager/styles.css')
def render(self):
attrs = KeyWordAssist()
document = self.base_doc.copy()
page_heading = HTMLgen.Heading(
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
register_adapter(ConfigurableNodePickler)
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)
else:
if abnormal.has_key(aname):
field = abnormal.get(aname)
else:
field = HTMLgen.Input(name=qname, value=qvalue)
row = HTMLgen.TR(**attrs('class', classes.next()))
row.append(
HTMLgen.TH(qname, **attrs("class", "attribute-name")))
row.append(
HTMLgen.TD(field, **attrs("class", "attribute-value")))
table.append(row)
form.append(table)
form.submit.value = form.submit.name = "save"
cancel = HTMLgen.Input(type="reset", value="cancel", name="cancel")
form.append(cancel)
# CSCte94385 (fix disabled for now) - validate invalid chars
dialogId = "edit"
#strScript = ("function " + dialogId + "_validate() { if(document.getElementById('" + dialogId + "').name.value.match('[^a-zA-Z0-9_]')) { " +
# "alert('Error: Name should have only alphanumeric and _ charaters.');" +
# "return false;}" +
# "return true;}")
#script = HTMLgen.Script(language="JavaScript", code=strScript)
#form.append(script)
form = adorn(form, id=dialogId)
form = adorn(form, onsubmit = "return false") #This will disable form submission when enter key is pressed (CSCtg05439)
return str(form)
register_adapter(HTMLAlarmManager)
register_adapter(HTMLAlarm)
def create_embedded_graph(self):
self.graph_element = HTMLgen.Script()
preferences = self.trend.get_preferences()
window_width = 800
window_height = 600
try:
window_width = int(float(preferences['width']))
except:
pass
try:
window_height = int(float(preferences['height']))
except:
pass
self.graph_element.append("""
var so = new SWFObject("/graphtool/EmbeddedGraph.swf", "trend_swf",
%(width)s, %(height)s, 8);
so.addParam("wmode", "opaque");
""" % {
"width": window_width,
"height": window_height
})
self.add_variable("CFG.log_uri", self.trend.log_url)
self.write_preferences(preferences)
self.graph_element.append("""so.write("trend_div");
""")
return
register_adapter(HTMLTrend)
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)
register_adapter(IOGRemoteNodeSecurityAdapter)
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):
def add_meta(self, predicate, value):
meta = self.__meta.setdefault(predicate, value)
if meta is not value:
raise TypeError('Context already has meta-data with predicate')
return meta
def update_meta(self, predicate, value):
self.__meta.update({predicate: value})
def setdefault_meta(self, predicate, default):
return self.__meta.setdefault(predicate, default)
def get_predicates(self):
return self.__meta.keys()
def get_values(self):
return self.__meta.values()
def get_items(self):
return self.__meta.items()
def get_triples(self):
predicates, values = self.__meta.keys(), self.__meta.values()
return zip([self.context] * len(predicates), predicates, values)
def get_meta_dictionary(self):
return self.__meta.copy()
register_adapter(MetaDataProvider)
add_form.submit.value = "continue"
add_form = adorn(add_form,
targetHandling="content",
targetID="schedule-configuration")
addform = urllib.quote(str(add_form))
popup = HTMLgen.Form(request_path)
popup.submit.value = "+"
onclick = "return popup_form(this, '%s', true)"
popup.submit.onClick = onclick % addform
children_section.append(adorn(popup, ("class", "add")))
children_section.append(
navigation(request_path, "reload", self.parent.url))
document.append(children_section)
return str(document)
register_adapter(HTMLScheduleHolderParentForm)
class HTMLScheduleHolderForm(object):
implements(IWebContent)
adapts(IScheduleHolder)
def __init__(self, holder):
self.path = None
self.holder = holder
def get_request_path(self):
return self.path
def get_page_heading(self):
return self.holder.name
def get_page_title(self):
return self.holder.name
def get_column_names(self):
return False
def appendChild(self, newChild):
raise Exception('Invalid operation on ConfigurableNode.')
def insertBefore(self, newChild, refChild):
raise Exception('Invalid operation on ConfigurableNode.')
def removeChild(self, oldChild):
raise Exception('Invalid operation on ConfigurableNode.')
def replaceChild(self, newChild, oldChild):
raise Exception('Invalid operation on ConfigurableNode.')
register_adapter(DomConfigurableNode)
class DomCompositeNode(DomConfigurableNode):
__doc__ = IDomNode.__doc__
# implements(IDomNode)
adapts(ICompositeNode)
# See mpx.www.w3c.dom.interfaces.IDomNode
def __get_child_nodes(self):
children = self.node.children_nodes()
return map(IDomNode, children)
childNodes = property(__get_child_nodes)
row.append(actioncell)
exporter_table.append(row)
exporter_section.append(exporter_table)
add_form = HTMLgen.Form(request_path)
addinput = HTMLgen.Input(name='add', value='true', type='hidden')
add_form.append(addinput)
section = HTMLgen.Input(
name='section', type='hidden', value="main")
add_form.append(section)
add_form = adorn(add_form, targetType="dialog")
add_form.submit.value = 'add'
exporter_section.append(add_form)
document.append(exporter_section)
return str(document)
register_adapter(HTMLExporterContainer)
class HTMLAlarmExporter(object):
implements(IWebContent)
adapts(IAlarmExporter)
def __init__(self, exporter):
self.exporter = exporter
self.base_doc = HTMLgen.SimpleDocument(title='Alarm Exporter')
def render(self):
"""
Configuration should be broken into three main topics.
Edit, associated with an 'edit' button on the manager
page, exposes name and other standard node configuration
def add_meta(self, predicate, value):
meta = self.__meta.setdefault(predicate, value)
if meta is not value:
raise TypeError('Context already has meta-data with predicate')
return meta
def update_meta(self, predicate, value):
self.__meta.update({predicate: value})
def setdefault_meta(self, predicate, default):
return self.__meta.setdefault(predicate, default)
def get_predicates(self):
return self.__meta.keys()
def get_values(self):
return self.__meta.values()
def get_items(self):
return self.__meta.items()
def get_triples(self):
predicates, values = self.__meta.keys(), self.__meta.values()
return zip([self.context] * len(predicates), predicates, values)
def get_meta_dictionary(self):
return self.__meta.copy()
register_adapter(MetaDataProvider)
'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
register_adapter(TriggerPickler)
if not self.__cov_registered:
self.__last_result = None
return
last_result = self.__last_result
if result is None:
result = self.get_result()
self.__last_result = result
if not result.equals(last_result):
self.__dispatch_cov(last_result, result)
return
def __dispatch_cov(self, last_result, result):
cov = ChangeOfValueEvent(self, last_result, result, result.timestamp)
return self.__dispatcher.dispatch(cov)
def __getattr__(self, name):
if name == 'event_handler' and self.__cov_registered:
return self.__event_handler
return getattr(self.node, name)
def __eq__(self, other):
return self.url == other.url
def __get_url(self):
return self.__urlbase + self.node.url
url = property(__get_url)
register_adapter(OverridablePoint)
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
register_adapter(ConfigurableNodePickler)
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)
except:
msglog.exception()
msg = ("Failed create row for: %s" %
display_name)
msglog.log('trendmanager', msglog.types.ERR, msg)
# Add + to the last actioncell (maybe the actionheader if no trends)
actionform = CustomForm(request_path)
actionform.submit.value = ' + '
actionform.submit.name = 'Add Trend'
trend_name = self.manager.generate_trend_name()
add_form = (addform) % (trend_name)
add_form = urllib.quote(add_form)
actionform.submit.onClick = "return popup_form(this, '%s', true); return false;" % add_form
trend_section.append(actionform)
return str(trend_section)
register_adapter(HTMLTrendManager)
class HTMLTrendPointConfiguration(object):
implements(IWebContent)
adapts(ITrendPointConfiguration)
def __init__(self, tpf):
self.tpf = tpf
self.trend = tpf.trend
self.encoded_name = urllib.quote_plus(self.trend.name)
self.globalsettingscontainer = None
self.trend_configuration = None
return
def add_global_settings(self):
if 'period' not in self.trend_configuration.keys():
# This is coming from /services/logger node - no point
# configuration from UI
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
register_adapter(LeafNodeDOM)
class ContentContainterDOM(LeafNodeDOM):
implements(IDOMish)
adapts(IContentContainter)
def getTagById(self, id):
result = super(ContentContainterDOM,self).getTagById(id)
if result is None:
for tag in self.tag.contents:
result = domish(tag).getTagById(id)
if result is not None:
return result
return result
register_adapter(ContentContainterDOM)
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 []
register_adapter(HTMLUserManagerForm, [IUserManager])
class IdentifiedInput(HTMLgen.Input):
def __init__(self, *args, **kw):
self.id = kw.get('id', '')
if kw.has_key('id'):
del (kw['id'])
HTMLgen.Input.__init__(self, *args, **kw)
def __str__(self):
output = HTMLgen.Input.__str__(self)
fragments = output.split(' ')
if self.id:
fragments.insert(1, 'ID="%s"' % self.id)
return string.join(fragments, ' ')
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))
register_adapter(BroadwayConfigurableGenerator)
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]
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)
register_adapter(UniquelyIdentified)
def get_method(self, name, default=Undefined):
if not self.has_method(name) and self.hasattr(name):
# TypeError if attribute exists but is not callable.
message = "'%s' object attribute '%s' not callable"
raise TypeError(message % (self._typename(), name))
return self.getattr(name, default)
def provides_interface(self, interface):
if isinstance(interface, str):
try:
eval(interface)
except NameError:
module, sep, datatype = interface.rpartition(".")
if not module:
raise
exect("import " + module)
interface = eval(interface)
return interface.providedBy(self.subject)
def get_interfaces(self, named=False):
interfaces = list(provided_by(self.subject))
if named:
items = []
for interface in interfaces:
items.append((interface.__module__, interface.__name__))
interfaces = [".".join(item) for item in items]
return interfaces
register_adapter(Inspector)
actionform.append(actioninput)
if action == "remove":
actionform.name = "Remove Host"
actionform = adorn(actionform,
targetID="cloud-config",
id=formId)
actionform.submit.value = ' - '
actionform.submit.onClick = ("return confirmDialog('" +
formId + "', 'Remove"
" peer from cloud?', false);")
actioncell.append(actionform)
if len(actions) > 1 and action != actions[-1]:
actioncell.append(' ')
row.append(actioncell)
formation_table.append(row)
formation_section.append(formation_table)
add_form = HTMLgen.Form(request_path)
#addinput = HTMLgen.Input(name='add', value='', type='text')
#add_form.append(addinput)
#add_form = adorn(add_form, targetID="cloud-config")
add_form.submit.value = ' + '
add_form.submit.name = "Add Host"
add_form.submit.onClick = "return popup_form(this, '%s', true)" % addform
formation_section.append(add_form)
document.append(formation_section)
return str(document)
register_adapter(HTMLCloudManager)
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())
register_adapter(RSS2FaultEventItem)
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
register_adapter(ExporterPickler)
row = HTMLgen.TR()
row.append(HTMLgen.TD(child.nodeName))
row.append(HTMLgen.TD(child.nodeID))
value = child.nodeValue
if value is None: value = 'N/A'
row.append(HTMLgen.TD(value))
rows.append(row)
child_table.append(*rows)
child_section.append(child_table)
document.append(config_section)
document.append(child_section)
return str(document)
register_adapter(HTMLDomDocument)
class HTMLDomNodeConfiguration(object):
implements(IWebContent)
adapts(IDomNode)
def __init__(self, domnode):
self.domnode = domnode
self.base_doc = HTMLgen.SimpleDocument(title='DomNode Browser',
style=read('node_style.css'))
def render(self):
attrs = KeyWordAssist()
document = self.base_doc.copy()
parent = self.domnode.parentNode
actionform = HTMLgen.Form(request_path)
actioninput = HTMLgen.Input(name=action,
value=encoded, type='hidden')
actionform.append(actioninput)
if action == "remove":
actionform.name = "Remove Host"
actionform = adorn(actionform, targetID="cloud-config", id=formId)
actionform.submit.value = ' - '
actionform.submit.onClick = ("return confirmDialog('" + formId + "', 'Remove"
" peer from cloud?', false);")
actioncell.append(actionform)
if len(actions) > 1 and action != actions[-1]:
actioncell.append(' ')
row.append(actioncell)
formation_table.append(row)
formation_section.append(formation_table)
add_form = HTMLgen.Form(request_path)
#addinput = HTMLgen.Input(name='add', value='', type='text')
#add_form.append(addinput)
#add_form = adorn(add_form, targetID="cloud-config")
add_form.submit.value = ' + '
add_form.submit.name = "Add Host"
add_form.submit.onClick = "return popup_form(this, '%s', true)" % addform
formation_section.append(add_form)
document.append(formation_section)
return str(document)
register_adapter(HTMLCloudManager)
state['targets'] = self.event.targets
state['topics'] = self.event.topics
state['event'] = self.event.event
state['guid'] = self.event.GUID
state['portal']=self.event.portal
return state
def __setstate__(self, state):
self.state = state
self.event = None
def __call__(self):
if self.event is None:
state = self.state
guid = state.get('guid')
try: cloudevent = Event.get_event(guid)
except KeyError:
source = state.get('source')()
topics = state.get('topics')
origin = state.get('origin')
targets = state.get('targets')
event = state.get('event')
portal=state.get('portal')
cloudevent = state.get('class')(source, origin, targets,portal,
topics, event, guid)
self.event = cloudevent
return self.event
def __str__(self):
return 'CloudEventPickler(%s)' % str(self.event)
register_adapter(CloudEventPickler)
children_table.append(row)
children_section.append(children_table)
for childtype in self.get_allowed_additions():
add_form = HTMLgen.Form(request_path)
add_form.append(context)
addinput = HTMLgen.Input(name='add',
value=childtype,
type='hidden')
add_form.append(addinput)
add_form.submit.value = 'Add ' + childtype
children_section.append(add_form)
document.append(children_section)
return str(document)
register_adapter(HTMLPeriodicDriverManagerForm)
closescript = """
function handle_close() {
if (window.opener) {
window.close();
return false;
} else {
return true;
}
}
"""
class HTMLPeriodicDriverForm(object):
implements(IWebContent)
self.graph_element = HTMLgen.Script()
preferences = self.trend.get_preferences()
window_width = 800
window_height = 600
try:
window_width = int(float(preferences["width"]))
except:
pass
try:
window_height = int(float(preferences["height"]))
except:
pass
self.graph_element.append(
"""
var so = new SWFObject("/graphtool/EmbeddedGraph.swf", "trend_swf",
%(width)s, %(height)s, 8);
so.addParam("wmode", "opaque");
"""
% {"width": window_width, "height": window_height}
)
self.add_variable("CFG.log_uri", self.trend.log_url)
self.write_preferences(preferences)
self.graph_element.append(
"""so.write("trend_div");
"""
)
return
register_adapter(HTMLTrend)
return setattr(self.subject, name, value)
def has_method(self, name):
return callable(self.getattr(name, None))
def get_method(self, name, default=Undefined):
if not self.has_method(name) and self.hasattr(name):
# TypeError if attribute exists but is not callable.
message = "'%s' object attribute '%s' not callable"
raise TypeError(message % (self._typename(), name))
return self.getattr(name, default)
def provides_interface(self, interface):
if isinstance(interface, str):
try:
eval(interface)
except NameError:
module,sep,datatype = interface.rpartition(".")
if not module:
raise
exect("import " + module)
interface = eval(interface)
return interface.providedBy(self.subject)
def get_interfaces(self, named=False):
interfaces = list(provided_by(self.subject))
if named:
items = []
for interface in interfaces:
items.append((interface.__module__, interface.__name__))
interfaces = [".".join(item) for item in items]
return interfaces
register_adapter(Inspector)
msglog.exception()
msg = ("Failed create row for: %s" % display_name)
msglog.log('trendmanager', msglog.types.ERR, msg)
# Add + to the last actioncell (maybe the actionheader if no trends)
actionform = CustomForm(request_path)
actionform.submit.value = ' + '
actionform.submit.name = 'Add Trend'
trend_name = self.manager.generate_trend_name()
add_form = (addform) % (trend_name)
add_form = urllib.quote(add_form)
actionform.submit.onClick = "return popup_form(this, '%s', true); return false;" % add_form
trend_section.append(actionform)
return str(trend_section)
register_adapter(HTMLTrendManager)
class HTMLTrendPointConfiguration(object):
implements(IWebContent)
adapts(ITrendPointConfiguration)
def __init__(self, tpf):
self.tpf = tpf
self.trend = tpf.trend
self.encoded_name = urllib.quote_plus(self.trend.name)
self.globalsettingscontainer = None
self.trend_configuration = None
return
def add_global_settings(self):
xmldoc.root_element = feed
return xmldoc
def setup_entries(self, request_path, cache_id):
entries = []
content = "Alarm %s switched to %s state at %s.\n\n"
content += "Please visit the Alarm Management link provided "
content += "in this entry to view details and make modifications."
t_update = time.time()
updated = atom.Updated(t_update)
for event in self.flattened:
if event.state == 'inactive':
continue
entry = atom.Entry()
entry.title = atom.Title(event.name)
entry.id = atom.Id(event.id)
entry.summary = atom.Summary('Alarm %s' % event.state)
entry.published = atom.Published(event.timestamp)
entry.updated = updated
entry_content = content % (event.name, event.state.upper(),
entry.published.text)
entry.content = atom.Content(entry_content)
entry.categories.insert(0, self.categories[event.state])
entry.link = atom.Link(
path.join(self.link_base, urllib.quote(event.name), event.id))
entries.append(entry)
return entries
register_adapter(AtomSyndicator)
class PickleableAlarm(PickleableConfigurableNode):
adapts(IAlarm)
privatevars = PickleableConfigurableNode.privatevars[:]
privatevars += ['events']
class PickleableOGConfigurableNode(PickleableConfigurableNode):
adapts(IOGConfigurableNode)
privatevars = ['name', 'parent']
excludevars = ['name', 'parent']
class PickleableCompositeNode(PickleableConfigurableNode):
adapts(ICompositeNode)
privatevars = PickleableConfigurableNode.privatevars[:]
privatevars += ['_CompositeNode__children', '_CompositeNode__nameorder']
class PickleableOGCompositeNode(PickleableOGConfigurableNode):
adapts(IOGCompositeNode)
privatevars = PickleableOGConfigurableNode.privatevars[:]
privatevars += ['_children']
def __init__(self, context):
super(PickleableOGCompositeNode, self).__init__(context)
context._children = getattr(context, '_children', {})
register_adapter(Pickleable)
register_adapter(PersistentAdapter)
register_adapter(PickleableConfigurableNode, IConfigurableNode, IPickleable)
register_adapter(PickleableOGConfigurableNode, IOGConfigurableNode, IPickleable)
register_adapter(PickleableCompositeNode, ICompositeNode, IPickleable)
register_adapter(PickleableOGCompositeNode, IOGCompositeNode, IPickleable)
register_adapter(PickleableAlarm, IAlarm, IPickleable)
for child in children:
row = HTMLgen.TR()
row.append(HTMLgen.TD(child.nodeName))
row.append(HTMLgen.TD(child.nodeID))
value = child.nodeValue
if value is None: value = 'N/A'
row.append(HTMLgen.TD(value))
rows.append(row)
child_table.append(*rows)
child_section.append(child_table)
document.append(config_section)
document.append(child_section)
return str(document)
register_adapter(HTMLDomDocument)
class HTMLDomNodeConfiguration(object):
implements(IWebContent)
adapts(IDomNode)
def __init__(self, domnode):
self.domnode = domnode
self.base_doc = HTMLgen.SimpleDocument(
title='DomNode Browser', style=read('node_style.css'))
def render(self):
attrs = KeyWordAssist()
document = self.base_doc.copy()
parent = self.domnode.parentNode
title = 'Edit DOM Node: <em>%s</em>'
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())
register_adapter(RSS2FaultEventItem)
informers.append(self.fallback_informer)
for informer in informers:
permission = informer.getting_permission(attribute)
if permission:
return permission
return None
def setting_permission(self, attribute):
informers = self._informers[:]
if not informers and self.fallback_informer is not None:
informers.append(self.fallback_informer)
for informer in informers:
permission = informer.setting_permission(attribute)
if permission:
return permission
return None
def deleting_permission(self, attribute):
informers = self._informers[:]
if not informers and self.fallback_informer is not None:
informers.append(self.fallback_informer)
for informer in informers:
permission = informer.deleting_permission(attribute)
if permission:
return permission
return None
register_adapter(SecuredAdapter)
register_adapter(PermissionChecker)
row.append(actioncell)
children_table.append(row)
children_section.append(children_table)
for childtype in self.get_allowed_additions():
add_form = HTMLgen.Form(request_path)
add_form.append(context)
addinput = HTMLgen.Input(name = 'add',
value = childtype,
type = 'hidden')
add_form.append(addinput)
add_form.submit.value = 'Add ' + childtype
children_section.append(add_form)
document.append(children_section)
return str(document)
register_adapter(HTMLPeriodicDriverManagerForm)
closescript = """
function handle_close() {
if (window.opener) {
window.close();
return false;
} else {
return true;
}
}
"""
class HTMLPeriodicDriverForm(object):
implements(IWebContent)
adapts(IPeriodicDriver)
