Python源码示例：twisted.python.failure.trap()
示例1
def ftp_PORT(self, address):
addr = tuple(map(int, address.split(',')))
ip = '%d.%d.%d.%d' % tuple(addr[:4])
port = addr[4] << 8 | addr[5]
# if we have a DTP port set up, lose it.
if self.dtpFactory is not None:
self.cleanupDTP()
self.dtpFactory = DTPFactory(pi=self, peerHost=self.transport.getPeer().host)
self.dtpFactory.setTimeout(self.dtpTimeout)
self.dtpPort = reactor.connectTCP(ip, port, self.dtpFactory)
def connected(ignored):
return ENTERING_PORT_MODE
def connFailed(err):
err.trap(PortConnectionError)
return CANT_OPEN_DATA_CNX
return self.dtpFactory.deferred.addCallbacks(connected, connFailed)
示例2
def testFailedStartTLS(self):
failures = []
def breakServerTLS(ign):
self.server.canStartTLS = False
self.connected.addCallback(breakServerTLS)
self.connected.addCallback(lambda ign: self.client.startTLS())
self.connected.addErrback(
lambda err: failures.append(err.trap(imap4.IMAP4Exception)))
self.connected.addCallback(self._cbStopClient)
self.connected.addErrback(self._ebGeneral)
def check(ignored):
self.assertTrue(failures)
self.assertIdentical(failures[0], imap4.IMAP4Exception)
return self.loopback().addCallback(check)
示例3
def test_serverTimeout(self):
"""
The *client* has a timeout mechanism which will close connections that
are inactive for a period.
"""
c = Clock()
self.server.timeoutTest = True
self.client.timeout = 5 #seconds
self.client.callLater = c.callLater
self.selectedArgs = None
def login():
d = self.client.login(b'testuser', b'password-test')
c.advance(5)
d.addErrback(timedOut)
return d
def timedOut(failure):
self._cbStopClient(None)
failure.trap(error.TimeoutError)
d = self.connected.addCallback(strip(login))
d.addErrback(self._ebGeneral)
return defer.gatherResults([d, self.loopback()])
示例4
def _ebRoundRobinBackoff(self, failure, fakeProto):
failure.trap(defer.TimeoutError)
# Assert that each server is tried with a particular timeout
# before the timeout is increased and the attempts are repeated.
for t in (1, 3, 11, 45):
tries = fakeProto.queries[:len(self.testServers)]
del fakeProto.queries[:len(self.testServers)]
tries.sort()
expected = list(self.testServers)
expected.sort()
for ((addr, query, timeout, id), expectedAddr) in zip(tries, expected):
self.assertEqual(addr, (expectedAddr, 53))
self.assertEqual(timeout, t)
self.assertFalse(fakeProto.queries)
示例5
def test_errbackAddedBeforeTimeoutSuppressesCancellation(self):
"""
An errback added before a timeout is added errbacks with a
L{defer.CancelledError} when the timeout fires. If the
errback suppresses the L{defer.CancelledError}, the deferred
successfully completes.
"""
clock = Clock()
d = defer.Deferred()
dErrbacked = [None]
def errback(f):
dErrbacked[0] = f
f.trap(defer.CancelledError)
d.addErrback(errback)
d.addTimeout(10, clock)
clock.advance(15)
self.assertIsInstance(dErrbacked[0], failure.Failure)
self.assertIsInstance(dErrbacked[0].value, defer.CancelledError)
self.successResultOf(d)
示例6
def ftp_PORT(self, address):
addr = tuple(map(int, address.split(',')))
ip = '%d.%d.%d.%d' % tuple(addr[:4])
port = addr[4] << 8 | addr[5]
# if we have a DTP port set up, lose it.
if self.dtpFactory is not None:
self.cleanupDTP()
self.dtpFactory = DTPFactory(pi=self, peerHost=self.transport.getPeer().host)
self.dtpFactory.setTimeout(self.dtpTimeout)
self.dtpPort = reactor.connectTCP(ip, port, self.dtpFactory)
def connected(ignored):
return ENTERING_PORT_MODE
def connFailed(err):
err.trap(PortConnectionError)
return CANT_OPEN_DATA_CNX
return self.dtpFactory.deferred.addCallbacks(connected, connFailed)
示例7
def test_waitUntilLockedWithTimeoutUnlocked(self):
"""
Test that a lock can be acquired while a lock is held
but the lock is unlocked before our timeout.
"""
def onTimeout(f):
f.trap(defer.TimeoutError)
self.fail("Should not have timed out")
self.assertTrue(self.lock.lock())
self.clock.callLater(1, self.lock.unlock)
d = self.lock.deferUntilLocked(timeout=10)
d.addErrback(onTimeout)
self.clock.pump([1] * 10)
return d
示例8
def test_errbackAddedBeforeTimeoutSuppressesCancellation(self):
"""
An errback added before a timeout is added errbacks with a
L{defer.CancelledError} when the timeout fires. If the
errback suppresses the L{defer.CancelledError}, the deferred
successfully completes.
"""
clock = Clock()
d = defer.Deferred()
dErrbacked = [None]
def errback(f):
dErrbacked[0] = f
f.trap(defer.CancelledError)
d.addErrback(errback)
d.addTimeout(10, clock)
clock.advance(15)
self.assertIsInstance(dErrbacked[0], failure.Failure)
self.assertIsInstance(dErrbacked[0].value, defer.CancelledError)
self.successResultOf(d)
示例9
def ftp_PORT(self, address):
addr = map(int, address.split(','))
ip = '%d.%d.%d.%d' % tuple(addr[:4])
port = addr[4] << 8 | addr[5]
# if we have a DTP port set up, lose it.
if self.dtpFactory is not None:
self.cleanupDTP()
self.dtpFactory = DTPFactory(pi=self, peerHost=self.transport.getPeer().host)
self.dtpFactory.setTimeout(self.dtpTimeout)
self.dtpPort = reactor.connectTCP(ip, port, self.dtpFactory)
def connected(ignored):
return ENTERING_PORT_MODE
def connFailed(err):
err.trap(PortConnectionError)
return CANT_OPEN_DATA_CNX
return self.dtpFactory.deferred.addCallbacks(connected, connFailed)
示例10
def test_serverTimeout(self):
"""
The *client* has a timeout mechanism which will close connections that
are inactive for a period.
"""
c = Clock()
self.server.timeoutTest = True
self.client.timeout = 5 #seconds
self.client.callLater = c.callLater
self.selectedArgs = None
def login():
d = self.client.login('testuser', 'password-test')
c.advance(5)
d.addErrback(timedOut)
return d
def timedOut(failure):
self._cbStopClient(None)
failure.trap(error.TimeoutError)
d = self.connected.addCallback(strip(login))
d.addErrback(self._ebGeneral)
return defer.gatherResults([d, self.loopback()])
示例11
def ftp_PORT(self, address):
addr = map(int, address.split(','))
ip = '%d.%d.%d.%d' % tuple(addr[:4])
port = addr[4] << 8 | addr[5]
# if we have a DTP port set up, lose it.
if self.dtpFactory is not None:
self.cleanupDTP()
self.dtpFactory = DTPFactory(pi=self, peerHost=self.transport.getPeer().host)
self.dtpFactory.setTimeout(self.dtpTimeout)
self.dtpPort = reactor.connectTCP(ip, port, self.dtpFactory)
def connected(ignored):
return ENTERING_PORT_MODE
def connFailed(err):
err.trap(PortConnectionError)
return CANT_OPEN_DATA_CNX
return self.dtpFactory.deferred.addCallbacks(connected, connFailed)
示例12
def testServerTimeout(self):
self.server.timeoutTest = True
self.client.timeout = 5 #seconds
self.selectedArgs = None
def login():
d = self.client.login('testuser', 'password-test')
d.addErrback(timedOut)
return d
def timedOut(failure):
self._cbStopClient(None)
failure.trap(error.TimeoutError)
d = self.connected.addCallback(strip(login))
d.addErrback(self._ebGeneral)
self.loopback()
示例13
def ftp_PASS(self, password):
"""
Second part of login. Get the password the peer wants to
authenticate with.
"""
if self.factory.allowAnonymous and self._user == self.factory.userAnonymous:
# anonymous login
creds = credentials.Anonymous()
reply = GUEST_LOGGED_IN_PROCEED
else:
# user login
creds = credentials.UsernamePassword(self._user, password)
reply = USR_LOGGED_IN_PROCEED
del self._user
def _cbLogin(result):
(interface, avatar, logout) = result
assert interface is IFTPShell, "The realm is busted, jerk."
self.shell = avatar
self.logout = logout
self.workingDirectory = []
self.state = self.AUTHED
return reply
def _ebLogin(failure):
failure.trap(cred_error.UnauthorizedLogin, cred_error.UnhandledCredentials)
self.state = self.UNAUTH
raise AuthorizationError
d = self.portal.login(creds, None, IFTPShell)
d.addCallbacks(_cbLogin, _ebLogin)
return d
示例14
def _unwrapFirstError(failure):
failure.trap(defer.FirstError)
return failure.value.subFailure
示例15
def _rcodeTest(self, rcode, exc):
m = dns.Message(rCode=rcode)
err = self.resolver.filterAnswers(m)
err.trap(exc)
示例16
def test_circularChainException(self):
"""
If the deprecation warning for circular deferred callbacks is
configured to be an error, the exception will become the failure
result of the Deferred.
"""
self.addCleanup(setattr, warnings, "filters", warnings.filters)
warnings.filterwarnings("error", category=DeprecationWarning)
d = defer.Deferred()
def circularCallback(result):
return d
d.addCallback(circularCallback)
d.callback("foo")
failure = self.failureResultOf(d)
failure.trap(DeprecationWarning)
示例17
def _check(self):
"""
Check the output of the log observer to see if the error is present.
"""
c2 = self._loggedErrors()
self.assertEqual(len(c2), 2)
c2[1]["failure"].trap(ZeroDivisionError)
self.flushLoggedErrors(ZeroDivisionError)
示例18
def test_chainedErrorCleanup(self):
"""
If one Deferred with an error result is returned from a callback on
another Deferred, when the first Deferred is garbage collected it does
not log its error.
"""
d = defer.Deferred()
d.addCallback(lambda ign: defer.fail(RuntimeError("zoop")))
d.callback(None)
# Sanity check - this isn't too interesting, but we do want the original
# Deferred to have gotten the failure.
results = []
errors = []
d.addCallbacks(results.append, errors.append)
self.assertEqual(results, [])
self.assertEqual(len(errors), 1)
errors[0].trap(Exception)
# Get rid of any references we might have to the inner Deferred (none of
# these should really refer to it, but we're just being safe).
del results, errors, d
# Force a collection cycle so that there's a chance for an error to be
# logged, if it's going to be logged.
gc.collect()
# And make sure it is not.
self.assertEqual(self._loggedErrors(), [])
示例19
def test_anonymousSTOR(self):
"""
Try to make an STOR as anonymous, and check that we got a permission
denied error.
"""
def eb(res):
res.trap(ftp.CommandFailed)
self.assertEqual(res.value.args[0][0],
'550 foo: Permission denied.')
d1, d2 = self.client.storeFile('foo')
d2.addErrback(eb)
return defer.gatherResults([d1, d2])
示例20
def test_STORtransferErrorIsReturned(self):
"""
Any FTP error raised by STOR while transferring the file is returned
to the client.
"""
# Make a failing file writer.
class FailingFileWriter(ftp._FileWriter):
def receive(self):
return defer.fail(ftp.IsADirectoryError("failing_file"))
def failingSTOR(a, b):
return defer.succeed(FailingFileWriter(None))
# Monkey patch the shell so it returns a file writer that will
# fail during transfer.
self.patch(ftp.FTPAnonymousShell, 'openForWriting', failingSTOR)
def eb(res):
res.trap(ftp.CommandFailed)
logs = self.flushLoggedErrors()
self.assertEqual(1, len(logs))
self.assertIsInstance(logs[0].value, ftp.IsADirectoryError)
self.assertEqual(
res.value.args[0][0],
"550 failing_file: is a directory")
d1, d2 = self.client.storeFile('failing_file')
d2.addErrback(eb)
return defer.gatherResults([d1, d2])
示例21
def test_STORunknownTransferErrorBecomesAbort(self):
"""
Any non FTP error raised by STOR while transferring the file is
converted into a critical error and transfer is closed.
The unknown error is logged.
"""
class FailingFileWriter(ftp._FileWriter):
def receive(self):
return defer.fail(AssertionError())
def failingSTOR(a, b):
return defer.succeed(FailingFileWriter(None))
# Monkey patch the shell so it returns a file writer that will
# fail during transfer.
self.patch(ftp.FTPAnonymousShell, 'openForWriting', failingSTOR)
def eb(res):
res.trap(ftp.CommandFailed)
logs = self.flushLoggedErrors()
self.assertEqual(1, len(logs))
self.assertIsInstance(logs[0].value, AssertionError)
self.assertEqual(
res.value.args[0][0],
"426 Transfer aborted. Data connection closed.")
d1, d2 = self.client.storeFile('failing_file')
d2.addErrback(eb)
return defer.gatherResults([d1, d2])
示例22
def test_RETRreadError(self):
"""
Any errors during reading a file inside a RETR should be returned to
the client.
"""
# Make a failing file reading.
class FailingFileReader(ftp._FileReader):
def send(self, consumer):
return defer.fail(ftp.IsADirectoryError("blah"))
def failingRETR(a, b):
return defer.succeed(FailingFileReader(None))
# Monkey patch the shell so it returns a file reader that will
# fail.
self.patch(ftp.FTPAnonymousShell, 'openForReading', failingRETR)
def check_response(failure):
self.flushLoggedErrors()
failure.trap(ftp.CommandFailed)
self.assertEqual(
failure.value.args[0][0],
"125 Data connection already open, starting transfer")
self.assertEqual(
failure.value.args[0][1],
"550 blah: is a directory")
proto = _BufferingProtocol()
d = self.client.retrieveFile('failing_file', proto)
d.addErrback(check_response)
return d
示例23
def trap_cancel(self, fail):
fail.trap(CancelledError)
示例24
def trap_connection_err(self, fail):
fail.trap(ConnectError, ConnectionClosed, ResponseFailed,
DNSLookupError)
示例25
def trap_boto3_err(self, fail):
# trap boto3 ConnectTimeoutError in retry
fail.trap(urllib3.exceptions.ConnectTimeoutError)
示例26
def _trap_uaid_not_found(self, fail):
# type: (failure.Failure) -> None
"""Traps UAID not found error"""
fail.trap(ItemNotFound)
示例27
def error_overload(self, failure, message_type, disconnect=True):
"""Handle database overloads and errors
If ``disconnect`` is False, the an overload error is returned and the
client is not disconnected.
Otherwise, pause producing to cease incoming notifications while we
wait a random interval up to 8 seconds before closing down the
connection. Most clients wait up to 10 seconds for a command,
but this is not a guarantee, so rather than never reply, we still
shut the connection down.
:param disconnect: Whether the client should be disconnected or not.
"""
failure.trap(ClientError)
if disconnect:
self.transport.pauseProducing()
d = self.deferToLater(self.randrange(4, 9),
self.error_finish_overload, message_type)
d.addErrback(self.trap_cancel)
else:
send = {"messageType": "error", "reason": "overloaded",
"status": 503}
self.sendJSON(send)
示例28
def error_message_overload(self, fail):
"""errBack for handling excessive messages per UAID"""
fail.trap(MessageOverloadException)
self.force_retry(self.db.router.drop_user, self.ps.uaid)
self.sendClose()
示例29
def error_monthly_rotation_overload(self, fail):
"""Capture overload on monthly table rotation attempt
If a provision exceeded error hits while attempting monthly table
rotation, schedule it all over and re-scan the messages. Normal
websocket client flow is returned in the meantime.
"""
fail.trap(ClientError)
if (fail.value.response['Error']['Code'] !=
"ProvisionedThroughputExceededException"):
return fail # pragma nocover
self.transport.resumeProducing()
d = self.deferToLater(randrange(1, 30*60), self.process_notifications)
d.addErrback(self.trap_cancel)
示例30
def finish_register(self, endpoint, chid):
"""callback for successful endpoint creation, sends register reply"""
message = self.db.message_table(self.ps.message_month)
d = self.deferToThread(message.register_channel, self.ps.uaid,
chid)
d.addCallback(self.send_register_finish, endpoint, chid)
# Note: No trap_cancel needed here since the deferred here is
# returned to process_register which will trap it
d.addErrback(self.error_overload, "register", disconnect=False)
return d
