def executeTransactions(logger, transactions):
for transaction in transactions:
transaction.prepare()
try:
for transaction in transactions:
transaction.save()
try:
for transaction in transactions:
try:
transaction.apply()
except Exception, err:
# Log the error
logger.writeError(err,
"Transaction (%s) apply error" % humanRepr(transaction),
log_level=CRITICAL)
raise
except Exception, err:
# Keep the original error
err_type, err_value, traceback = exc_info()
# Rollback (catch rollback errors)
logger.warning("Rollback transactions")
for transaction in transactions:
try:
transaction.rollback()
except Exception, err:
logger.writeError(err,
"Transaction (%s) rollback error" % humanRepr(transaction),
log_level=CRITICAL)
# Raise the original error
raise err_type, err_value, traceback
def logApplyError(self, err, name, callback):
err_msg = formatError(err)
message = "Apply error in %s - %s:\n %s" % (name, humanRepr(callback), err_msg)
self.journal.log_apply_error(err_msg)
self.manager.writeError(err, message, log_level=CRITICAL)
def emit(self, sender, event, **extra):
"""
Emit an event: call callbacks connected to this event.
Return a deferred object.
Extra arguments can be set using keywords, they will be available as
context attributes:
notify.emit('nupki', 'updateCRL', pki_name='test')
=> context.pki_name == 'test'
"""
message = "%s emitted signal %s" % (sender, event)
if extra:
message += " (%s)" % humanRepr(extra)
self.warning(message)
specific_cb = self.events.get((sender, event), [])
generic_cb = self.generic_events.get(event, [])
callbacks = chain(specific_cb, generic_cb)
context = CallbackContext(sender, event, extra)
for callback in callbacks:
self.debug("Event %s.%s: call %s" % (sender, event, callback))
try:
yield callback(context)
except Exception, err:
self.writeError(err, "Error on callback %s" % callback)
def datagramReceived(self, data, host_port):
(host, port) = host_port
if data == ACK:
self.ack(host, port)
else:
hello = humanRepr(data, 50)
self.critical("Connection from %s:%s: hello=%s" % (host, port, hello))
self.transport.write(HELLO, (host, port))
def serializeElement(value, extensions=()):
"""
extensions is an iterable of duples, this way:
(
(type, method_name),
(type, method),
...
)
If a method is supplied, it will receive value.
If a method_name is supplied, the method value.method_name will be used
Note: an ordered iterable is a good idea.
"""
if extensions:
for _type, _serializer in extensions:
if isinstance(value, _type):
if isinstance(_serializer, (str, unicode)):
_serializer = getattr(value, _serializer)
return _serializer()
return _serializer(value)
if isinstance(value, dict):
value = value.copy()
value["__type__"] = "dict"
for key, val in value.iteritems():
value[key] = serializeElement(val, extensions=extensions)
elif isinstance(value, (list, tuple)):
if isinstance(value, list):
type_name = "list"
else:
type_name = "tuple"
value = list2dict(value)
value["__type__"] = type_name
for key, val in value.iteritems():
value[key] = serializeElement(val, extensions=extensions)
elif isinstance(value, set):
value = list2dict(value)
value["__type__"] = "set"
for key, val in value.iteritems():
value[key] = serializeElement(val, extensions=extensions)
elif isinstance(value, IP):
element = unicode(value)
value = {}
value["__type__"] = "IP"
value["IP"] = element
elif value is None:
value = UNSET
elif not isinstance(value, (str, int, long, bool, float, unicode)):
raise UnserializableElement("Unserialisable value: %s" % humanRepr(value))
return value
def formatServiceArguments(self, service, arguments):
arg_len = 150
total_len = 400
text = u''
for argument in arguments:
if text:
text += u', '
space = max(total_len - len(text), 0)
space = min(space, arg_len)
argument = humanRepr(argument, space)
text += argument
if total_len <= len(text):
break
return text
def logRollbackError(self, failure, name, callback):
message = "Rollback error in %s - %s" % (name, humanRepr(callback))
self.manager.writeError(failure, message, log_level=CRITICAL)
self.journal.log_rollback_error(formatError(failure))
def __call(self, log_prefix, func, *args):
self.manager.debug("%s: call %s" % (log_prefix, humanRepr(func)))
return func(*args)
def __str__(self):
return humanRepr(self.func)
