def execute(self, request):
data = request.get_data().read_all()
if not data:
raise MpxException('XML-RPC request has no POST data.')
## process xmlrpc, getting the name of the method
## and parameters
params, method = xmlrpclib.loads(data)
if request.user_object() is None and len(params):
session_id = params[0]
user = self.session_manager.get_user_from_sid(session_id)
request.user_object(user)
## get the name of the object
## and the name of method
## They are delimited by a colon.
if '.' in method:
tokens = string.split(method, '.')
elif ':' in method:
tokens = string.split(method, ':')
else:
raise MpxException('Invalid XMLRPC Request: %r' % data)
object_alias = tokens[0]
method_name = tokens[1]
# Call the requested object
# and return response
self.debugout("Calling %s.%s" % (object_alias, method_name))
return self.call(object_alias, method_name, params)
def encode(self, orig, encode_type='base64'):
try:
newval = None
if encode_type == 'base64':
newval = base64.encodestring(orig)
else:
raise MpxException('Unsupported encoding type "%s"' %
encode_type)
return '<encode type="%s">%s</encode>' % (encode_type, newval)
except Exception, e:
raise MpxException('Error while encoding value "%s"' % str(e))
def decode(self, encoded_value):
try:
self._encoded_val = ''
self._encode_type = ''
self._encode_parser.Parse(encoded_value)
decoded_val = ''
if self._encode_type == 'base64':
decoded_val = base64.decodestring(self._encoded_val)
else:
raise MpxException('Unknown encode type "%s"' %
self._encode_type)
return decoded_val
except Exception, e:
raise MpxException('Error decoding string: %s' % str(e))
def export(self, alarm):
entry = {}
entry['alarm'] = alarm.source.name
self._timestamp = alarm.timestamp
entry['timestamp'] = alarm.timestamp
entry['critical_value'] = alarm.critical
values = alarm.values
for key in values.keys():
entry[key] = values[key]
entry['message'] = alarm.message
if hasattr(alarm, 'subject'):
entry['subject'] = alarm.subject
data = self.formatter.format([entry])
tries = alarm.source.send_retries + 1
while tries:
tries -= 1
try:
if self.connection.acquire(self.timeout):
try:
self.transporter.transport(data)
return
finally:
self.connection.release()
except:
msglog.log('broadway', msglog.types.WARN,
'Failed attempt to send alarm %s' % alarm)
msglog.exception()
else:
raise MpxException('Export failed.')
def read_nodedef_db(self, compression_algorithm=NONE):
f = None
try:
if compression_algorithm == self.NONE:
try:
f = open(
os.path.join(self.BROADWAY_ROOT,
self.NODEDEF_DBFILE_EN))
except IOError:
f = self._open_nodedef_db()
self._copy_encoded(
f,
os.path.join(self.BROADWAY_ROOT,
self.NODEDEF_DBFILE_EN))
f.close()
f = None
f = open(
os.path.join(self.BROADWAY_ROOT,
self.NODEDEF_DBFILE_EN))
elif compression_algorithm == self.ZIP:
f = open(os.path.join(self.BROADWAY_ROOT,
self.NODEDEF_ZIPFILE))
else:
raise EInvalidValue('compression_algorithm',
compression_algorithm)
return BinaryString(f.read())
except IOError, ie:
if f: f.close()
raise MpxException('Could not read nodedef database: %s' % str(e))
def export(self, alarm, attempt=0):
self._lock.acquire()
try:
if (not self._started):
self._alarm.append(alarm)
# No need to set scheduler here; start() will call
# export_waiting_alarm()...
return
# Even if this node is already started, do not attempt to
# export alarm unless the linked log node and its collector
# object are extant and started:
if (self.log.collector is None):
self._alarm.append(alarm)
if (self._waiting_alarm_sid is
None): # if we're not already scheduled, do it:
# Need to wait long enough for log.start() to finish creating
# and starting collector. ***GUESS*** 10.0 sec. Symptom of not
# waiting long enough: ENotStarted error raised below:
self._waiting_alarm_sid = scheduler.after(
10.0, self.export_waiting_alarm, ())
return
finally:
self._lock.release()
self.log.collector.pause()
try:
try:
if not self.log.collector.running:
raise ENotStarted('Collector not started yet.')
entry = self.log.collector.get_entry()
entry[self.ts_position] = time.time()
# Stamp source, if target log columns support it:
if isinstance(self.trigger_node_url_posn, int):
entry[self.trigger_node_url_posn] = as_node_url(
alarm.source)
if isinstance(self.trigger_node_msg_posn, int):
entry[self.trigger_node_msg_posn] = str(alarm)
self.log.add_entry(entry)
t = time.time()
for child in self.log.get_child('exporters').children_nodes():
child.go(t) # starts threads for long ops
except:
msglog.exception()
if attempt > alarm.source.send_retries:
msglog.log('broadway', msglog.types.WARN,
'Export of alarm failed, aborting send.')
raise MpxException('Log and export failed.')
else:
msglog.log('broadway', msglog.types.WARN,
'Log on alarm failed, delaying 1.0 sec.')
self._lock.acquire()
try:
if self._scheduled != None:
scheduler.cancel(self._scheduled)
self._scheduled = scheduler.after(
1, self.export, (alarm, attempt + 1))
finally:
self._lock.release()
finally:
self.log.collector.play()
return
def handle_request(self, request):
print 'handle_request'
if not self.running:
return request.error(503) #service unavailable
try:
self.data = data = request.get_data().read_all()
if not data:
raise EProtocol(
'could not get DATA parameter from posted data')
## process xmlrpc, getting the name of the method
## and parameters
params, method = xmlrpclib.loads(data)
return
object_alias = ''
method_name = ''
## get the name of the object
## and the name of method
## They are delimited by a colon.
except:
msglog.exception()
raise MpxException(
'Error occurred while processing Brivo XMLRPC command')
# XML-RPC Call was successful.
# Send back the XML result to client
reply = Response(request)
reply.set_header('Content-Length', len(response))
reply.set_header('Content-Type', 'text/xml')
reply.send(response)
return
def get_xml(self, url=None):
try:
node = as_node(url)
xml = interrogate_nodes(node)
return xml
except Exception, e:
msglog.exception()
raise MpxException(
e, 'Error getting node xml configuration: %s' % str(e))
def __str__(self):
if not len(self.keywords):
return MpxException.__str__(self)
keys = self.keywords.keys()
keys.sort()
key = keys.pop(0)
result = key + "=" + str(self.keywords[key])
for key in keys:
result += ", " + key + "=" + str(self.keywords[key])
return result
def __str__(self):
if not len(self.keywords):
return MpxException.__str__(self)
keys = self.keywords.keys()
keys.sort()
key = keys.pop(0)
result = key + "=" + str(self.keywords[key])
for key in keys:
result += ", " + key + "=" + str(self.keywords[key])
return result
def _find_deployed_object_method(self, alias_name, method_name):
for o in self.deployed_objects:
if o['alias'] == alias_name:
self.debugout("Found Alias -> %s" % alias_name)
# get the module name
object_name = o['class']
lifetime = o['lifetime']
if lifetime == 'Runtime':
instance = self._create_or_reuse_object(object_name)
elif lifetime == 'Session':
raise MpxException("Lifetime per session not supported.")
else:
instance = self._create_instance(object_name)
if self.debug:
self.debugout("Instance created -> %s" % alias_name)
attrib = getattr(instance, method_name)
self.debugout("Attribute found -> %s.%s" %
(alias_name, method_name))
return attrib
raise MpxException('No deployed object named "%s".' % alias_name)
def export(self, stateevent):
attempts = 0
transported = False
formatter = self.get_formatter()
transporter = self.get_transporter()
if not (formatter.is_setup() and transporter.is_setup()):
print 'Exporter not fully configured for transport.'
return
data = self.get_formatter().format(stateevent)
while not transported and (attempts <= self.retries):
try:
if self.connection.acquire(self.timeout):
try:
self.get_transporter().transport(data)
finally:
self.connection.release()
transported = True
except:
msglog.exception(prefix="handled")
attempts += 1
if not transported:
raise MpxException('Export %s failed.' % data)
return transported
def get_nodedef_md5(self):
f = None
try:
f = open(os.path.join(self.BROADWAY_ROOT, self.NODEDEF_MD5FILE))
t = f.readline().split()[0]
f.close()
f = None
if len(t) != 32: raise Exception('Invalid MD5.')
return t
except:
if f: f.close()
f = None
try:
n = md5.new()
f = self._open_nodedef_db()
for l in f.xreadlines():
n.update(l)
f.close()
try:
f = open(
os.path.join(self.BROADWAY_ROOT, self.NODEDEF_MD5FILE),
'w+')
f.write(n.hexdigest())
f.write(' %s\n' % self.NODEDEF_DBFILE)
f.close()
except:
if f: f.close()
f = None
return n.hexdigest()
except Exception, e:
if f: f.close()
msglog.exception()
raise MpxException('Error reading Configuration MD5: %s' % str(e))
def _discoverChildrenNodes(self):
try:
countKids = 21
i = 1
while i < countKids:
childDict = {}
name = ""
if i < 10:
name = '11-0%d' % i
else:
name = '11-%d' % i
childDict['name'] = name
number = random.randint(50, 99) + random.random()
childDict['value'] = '%.1f' % float(number)
childDict['parent'] = self
child = _DynamicChildPoint()
child.configure(childDict)
child.set('%.1f' % float(number))
i = i + 1
except Exception, e:
raise MpxException(
'Error while discovering DynamicChildren points: ' + str(e))
def _get_data(self, request):
data = request.get_data().read_all()
if not data:
raise MpxException('could not get DATA parameter from posted data')
return data
def _decode(self, orig):
try:
result = self._encoder_mgr.decode(orig) ## get value from XML
except Exception, e:
raise MpxException('Error while decoding value "%s"' % str(e))
def __init__(self,*args):
self.errstr = pam_error_tostr(self.errcode)
MpxException.__init__(self, self.errstr)
return
