def _check_snapshot(self, old_agent, old_protocols):
# check that the state so far matches the snapshop
# if old_agent is None, it means that the snapshot is first entry
# we are replaynig - hence we have no state to compare to
if old_agent is not None:
try:
if self.agent != old_agent:
comp = deep_compare(self.agent._get_state(), old_agent._get_state())
info = " INFO: %s: %s\n" % comp if comp else ""
raise ReplayError(
"States of current agent mismatch the "
"old agent\nInfo: %s\nOld: %s\n"
"Loaded: %s." % (info, pformat(old_agent._get_state()), pformat(self.agent._get_state()))
)
if len(self.protocols) != len(old_protocols):
raise ReplayError(
"The number of protocols mismatch. " "\nOld: %r\nLoaded: %r" % (old_protocols, self.protocols)
)
else:
for protocol in self.protocols:
if protocol not in old_protocols:
raise ReplayError(
"One of the protocols was not "
"found.\nOld: %s\nLoaded: %s" % (pformat(old_protocols), pformat(self.protocols))
)
except RuntimeError, e:
exc_info = sys.exc_info()
raise ReplayError(
"Runtime error during replay of %s: %s" % (self.agent.type_name, error.get_exception_message(e))
), None, exc_info[2]
def _load_module(option, opt, value, parser):
try:
reflect.named_module(value)
except ImportError, e:
from feat.common import error
raise OptionError("Cannot import module %s: %s" % (
value, error.get_exception_message(e))), None, sys.exc_info()[2]
def initiate(self):
self.debug('Initiating %s', self.log_ident)
assert not self.initiated, "Already initiated"
self.initiated = True
try:
self.onInitiate()
except HTTPError, e:
self.warning("Error during initiation: %s",
error.get_exception_message(e))
self._make_error(e.status_code, e.status_message)
def allContentReceived(self):
self.debug('All content received on %s', self.log_ident)
assert not self.received, "Already been notified"
if self.finished:
return
self.received = True
try:
self.onAllContentReceived()
except HTTPError, e:
self.warning("Error during finalization: %s",
error.get_exception_message(e))
self._make_error(e.status_code, e.status_message)
return
def dataReceived(self, data):
self.received_bytes += len(data)
if self.finished:
return
try:
self.onDataReceived(data)
except HTTPError, e:
self.warning("Error during data processing: %s",
error.get_exception_message(e))
self._make_error(e.status_code, e.status_message)
return
def link_log_file(self, filename):
if not self.config.agency.daemonize:
# if haven't demonized the log is just at the users console
return
logfile, _ = log.FluLogKeeper.get_filenames()
linkname = os.path.join(self.config.agency.logdir, filename)
try:
os.unlink(linkname)
except OSError:
pass
try:
os.symlink(logfile, linkname)
except OSError as e:
self.warning("Failed to link log file %s to %s: %s", logfile, linkname, error.get_exception_message(e))
def _link_log_file(self, filename):
if not self.config['agency']['daemonize']:
return
logfile, _ = log.FluLogKeeper.get_filenames()
basedir = os.path.dirname(logfile)
linkname = os.path.join(basedir, filename)
try:
os.unlink(linkname)
except OSError:
pass
try:
os.symlink(logfile, linkname)
except OSError as e:
self.warning("Failed to link log file %s to %s: %s",
logfile, linkname, error.get_exception_message(e))
def activate(self):
self.debug('Activating %s', self.log_ident)
assert not self.activated, "request already active"
self.activated = True
self._activate_transport()
if self.finished:
# The request was finished before being activated
time.call_later(0, self._cleanup)
return
try:
self.onActivate()
except HTTPError, e:
self.warning("Error during activation: %s",
error.get_exception_message(e))
self._make_error(e.status_code, e.status_message)
def from_exception(cls, ex):
if isinstance(ex, http.HTTPError):
code = ex.status_code
elif isinstance(ex, error.FeatError):
code = ex.eror_code
else:
code = None
if isinstance(ex, error.FeatError):
message = ex.error_name
else:
message = str(ex)
if not message:
message = type(ex).__name__
debug = error.get_exception_message(ex)
trace = error.get_exception_traceback(ex)
return cls(code=code, message=message, debug=debug, trace=trace)
def from_exception(cls, ex):
error_type = ErrorTypes.generic
status_code = None
error_code = None
message = None
subjects = None
reasons = None
debug = None
trace = None
if isinstance(ex, error.FeatError):
error_code = ex.error_code
message = ex.error_name
if isinstance(ex, http.HTTPError):
error_type = ErrorTypes.http
status_code = ex.status_code
if error_code is None:
error_code = int(status_code)
if isinstance(ex, ParameterError):
error_type = ex.error_type
status_code = http.Status.BAD_REQUEST
subjects = ex.parameters
if isinstance(ex, InvalidParameters):
reasons = ex.reasons
if not message:
message = str(ex) or type(ex).__name__
if not isinstance(ex, http.HTTPError):
debug = error.get_exception_message(ex)
trace = error.get_exception_traceback(ex)
return cls(error_type=error_type, error_code=error_code,
status_code=status_code, message=message,
subjects=subjects, reasons=reasons,
debug=debug, trace=trace)
self._activate_transport()
if self.finished:
# The request was finished before being activated
time.call_later(0, self._cleanup)
return
try:
self.onActivate()
except HTTPError, e:
self.warning("Error during activation: %s",
error.get_exception_message(e))
self._make_error(e.status_code, e.status_message)
except Exception, e:
self.warning("Error during activation: %s",
error.get_exception_message(e))
self._make_error(http.Status.INTERNAL_SERVER_ERROR)
raise
def dataReceived(self, data):
self.received_bytes += len(data)
if self.finished:
return
try:
self.onDataReceived(data)
except HTTPError, e:
self.warning("Error during data processing: %s",
error.get_exception_message(e))
self._make_error(e.status_code, e.status_message)