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)