コード例 #1
0
 def testNotifyFinishConnectionLost(self):
     d = DummyChannel()
     d.transport = DummyChannel.TCP()
     request = server.Request(d, 1)
     finished = request.notifyFinish()
     request.connectionLost(error.ConnectionDone("Connection done"))
     return self.assertFailure(finished, error.ConnectionDone)
コード例 #2
0
 def connectionLost(self, reason=failure.Failure(error.ConnectionDone())):
     if self.request_handler is not None:
         self.request_handler.stopProducing()
     self.factory.rate_limiter.unregister_protocol(self)
     if not reason.check(error.ConnectionDone):
         log.warning("Closing a connection. Reason: %s",
                     reason.getErrorMessage())
コード例 #3
0
ファイル: listener.py プロジェクト: pingli-study/maas
    def loseConnection(self, reason=Failure(error.ConnectionDone())):
        """Request that the connection be dropped."""
        if self.disconnecting is None:
            self.registeredChannels.clear()
            d = self.disconnecting = Deferred()
            d.addBoth(callOut, self.stopReading)
            d.addBoth(callOut, self.cancelChannelRegistrar)
            d.addBoth(callOut, self.cancelHandleNotify)
            d.addBoth(callOut, deferToThread, self.stopConnection)
            d.addBoth(callOut, self.connectionLost, reason)

            def done():
                self.disconnecting = None

            d.addBoth(callOut, done)

            if self.connecting is None:
                # Already/never connected: begin shutdown now.
                self.disconnecting.callback(None)
            else:
                # Still connecting: cancel before disconnect.
                self.connecting.addErrback(suppress, CancelledError)
                self.connecting.chainDeferred(self.disconnecting)
                self.connecting.cancel()

        return self.disconnecting
コード例 #4
0
def _get(path, dn):
    path = to_unicode(path)
    dn = distinguishedname.DistinguishedName(dn)
    l = list(dn.split())
    assert len(l) >= 1
    l.reverse()

    parser = StoreParsedLDIF()

    entry = os.path.join(path, *[u'%s.dir' % rdn.getText() for rdn in l[:-1]])
    entry = os.path.join(entry, u'%s.ldif' % l[-1].getText())
    f = open(entry, 'rb')
    while 1:
        data = f.read(8192)
        if not data:
            break
        parser.dataReceived(data)
    parser.connectionLost(failure.Failure(error.ConnectionDone()))

    assert parser.done
    entries = parser.seen
    if len(entries) == 0:
        raise LDIFTreeEntryContainsNoEntries()
    elif len(entries) > 1:
        raise LDIFTreeEntryContainsMultipleEntries(entries)
    else:
        return entries[0]
コード例 #5
0
ファイル: gtk2reactor.py プロジェクト: rosalin/stoq
    def _doReadOrWrite(self, source, condition, faildict=None):
        faildict = faildict or {
            error.ConnectionDone: failure.Failure(error.ConnectionDone()),
            error.ConnectionLost: failure.Failure(error.ConnectionLost()),
        }
        why = None
        inRead = False
        if condition & POLL_DISCONNECTED and not (condition & glib.IO_IN):
            if source in self._reads:
                why = main.CONNECTION_DONE
                inRead = True
            else:
                why = main.CONNECTION_LOST
        else:
            try:
                if condition & glib.IO_IN:
                    why = source.doRead()
                    inRead = True
                if not why and condition & glib.IO_OUT:
                    # if doRead caused connectionLost, don't call doWrite
                    # if doRead is doWrite, don't call it again.
                    if not source.disconnected:
                        why = source.doWrite()
            except:
                why = sys.exc_info()[1]
                log.msg('Error In %s' % source)
                log.deferr()

        if why:
            self._disconnectSelectable(source, why, inRead)
コード例 #6
0
	def _doReadOrWrite(self, selectable, fd, event, POLLIN, POLLOUT, log,
		faildict={
			error.ConnectionDone: failure.Failure(error.ConnectionDone()),
			error.ConnectionLost: failure.Failure(error.ConnectionLost())
		}):
		why = None
		inRead = False
		if event & POLL_DISCONNECTED and not (event & POLLIN):
			why = main.CONNECTION_LOST
		else:
			try:
				if event & POLLIN:
					why = selectable.doRead()
					inRead = True
				if not why and event & POLLOUT:
					why = selectable.doWrite()
					inRead = False
				if not selectable.fileno() == fd:
					why = error.ConnectionFdescWentAway('Filedescriptor went away')
					inRead = False
			except AttributeError, ae:
				if "'NoneType' object has no attribute 'writeHeaders'" not in ae.message:
					log.deferr()
					why = sys.exc_info()[1]
				else:
					why = None
			except:
コード例 #7
0
ファイル: pb.py プロジェクト: pexip/os-foolscap
    def stopService(self):
        # note that once you stopService a Tub, I cannot be restarted. (at
        # least this code is not designed to make that possible.. it might be
        # doable in the future).
        assert self.running
        self.startService = self._tubsAreNotRestartable
        self.getReference = self._tubHasBeenShutDown
        self.connectTo = self._tubHasBeenShutDown
        dl = []
        for rc in self.reconnectors:
            rc.stopConnecting()
        del self.reconnectors
        for l in self.listeners:
            # TODO: rethink this, what I want is for stopService to cause all
            # Listeners to shut down, but I'm not sure this is the right way
            # to do it.
            d = l.removeTub(self)
            if isinstance(d, defer.Deferred):
                dl.append(d)
        dl.append(service.MultiService.stopService(self))

        if self._activeConnectors:
            dl.append(self._allConnectorsAreFinished.whenFired())
        for c in self._activeConnectors:
            c.shutdown()

        if self._allConnections:
            dl.append(self._allConnectionsAreDisconnected.whenFired())
        why = Failure(error.ConnectionDone("Tub.stopService was called"))
        for b in self.brokers.values():
            b.shutdown(why, fireDisconnectWatchers=False)
        for b in self.unauthenticatedBrokers:
            b.shutdown(why, fireDisconnectWatchers=False)

        return defer.DeferredList(dl)
コード例 #8
0
ファイル: HellaReactor.py プロジェクト: r0mdau/hellanzb
 def _doReadOrWrite(self, selectable, method, dict, faildict={
     error.ConnectionDone: failure.Failure(error.ConnectionDone()),
     error.ConnectionLost: failure.Failure(error.ConnectionLost())
     }):
     """ Handle IOErrors/out of disk space """
     try:
         why = getattr(selectable, method)()
         handfn = getattr(selectable, 'fileno', None)
         if not handfn:
             why = _NO_FILENO
         elif handfn() == -1:
             why = _NO_FILEDESC
     except IOError, ioe:
         # NOTE: Importing this in the module causes TimeoutMixin to not work. ???
         from twisted.protocols.policies import ThrottlingProtocol
         
         # Handle OutOfDiskSpace exceptions. Piggybacking this check into the reactor
         # here uses less CPU than try: excepting in NZBLeecher.dataReceived
         if selectable.protocol.__class__ is ThrottlingProtocol:
             from Hellanzb.Util import OutOfDiskSpace
             from Hellanzb.NZBLeecher.ArticleDecoder import handleIOError
             try:
                 handleIOError(ioe)
             except OutOfDiskSpace:
                 # handleIOError would have just paused the downloader for us
                 selectable.protocol.wrappedProtocol.transport.loseConnection()
                 selectable.protocol.wrappedProtocol.isLoggedIn = False
                 selectable.protocol.wrappedProtocol.deactivate()
                 return
             except:
                 pass
         why = sys.exc_info()[1]
         log.err()
コード例 #9
0
 def connectionLost( self, reason ):
     """Connection lost, clean up callbacks"""
     for key,callable in self.actionIDCallbacks.items():
         try:
             callable( tw_error.ConnectionDone( """FastAGI connection terminated""") )
         except Exception, err:
             log.error( """Failure during connectionLost for callable %s: %s""", callable, err )
コード例 #10
0
    def test_encode_task(self):
        self.protocol.handshakeSuccess('')
        self.protocol.startEncoding()

        self.assertTrue(hasattr(self.protocol, 'encoder_task'))
        self.protocol.connectionLost(error.ConnectionDone())
        self.assertFalse(hasattr(self.protocol, 'encoder_task'))
コード例 #11
0
    def test_stream(self):
        self.protocol.handshakeSuccess('')

        self.protocol.connectionLost(error.ConnectionDone())

        self.assertFalse(hasattr(self.protocol, 'decoder'))
        self.assertFalse(hasattr(self.protocol, 'encoder'))
コード例 #12
0
ファイル: test_rabbitmq.py プロジェクト: containerz/udplog
    def test_connectionLost(self):
        """
        The producer is unregistered at the dispatcher on lost connection.
        """
        connectionLostCalls = []
        callbackCalls = []

        def connectionLost(self, reason):
            connectionLostCalls.append(reason)

        def cb(event):
            raise Exception("Unexpected callback")

        # Set up publisher as if connected
        clock = task.Clock()
        self.publisher.producer = twisted.QueueProducer(callback=cb,
                                                       clock=clock)
        self.publisher.producer.resumeProducing()
        self.publisher.dispatcher = twisted.Dispatcher()
        self.publisher.dispatcher.register(self.publisher.producer.put)

        # Patch parent class to test up-call
        self.patch(AMQClient, 'connectionLost', connectionLost)

        # Drop connection
        self.publisher.connectionLost(error.ConnectionDone())
        self.assertEqual(1, len(connectionLostCalls))
        self.assertEqual(1, len(self.flushLoggedErrors(error.ConnectionDone)))

        # Test that the producer was unregistered with the dispatcher
        event = {'message': 'test'}
        self.publisher.dispatcher.eventReceived(event)
        clock.advance(0)
        self.assertEqual(0, len(callbackCalls))
コード例 #13
0
ファイル: test_listener.py プロジェクト: th3architect/maas
    def test_connectionLost_does_not_log_reason_when_lost_cleanly(self):
        listener = PostgresListenerService()

        with TwistedLoggerFixture() as logger:
            listener.connectionLost(Failure(error.ConnectionDone()))

        self.assertThat(logger.errors, HasLength(0))
コード例 #14
0
    def _load(self):
        assert self.path.endswith(u'.dir')
        entryPath = u'%s.ldif' % self.path[:-len(u'.dir')]

        parser = StoreParsedLDIF()

        try:
            f = open(entryPath, 'rb')
        except IOError as e:
            if e.errno == errno.ENOENT:
                return
            else:
                raise
        while 1:
            data = f.read(8192)
            if not data:
                break
            parser.dataReceived(data)
        parser.connectionLost(failure.Failure(error.ConnectionDone()))
        assert parser.done

        entries = parser.seen
        if len(entries) == 0:
            raise LDIFTreeEntryContainsNoEntries()
        elif len(entries) > 1:
            raise LDIFTreeEntryContainsMultipleEntries(entries)
        else:
            for k, v in entries[0].items():
                self._attributes[k] = attributeset.LDAPAttributeSet(k, v)
コード例 #15
0
    def _disconnectSelectable(
        self,
        selectable,
        why,
        isRead,
        faildict={
            error.ConnectionDone: failure.Failure(error.ConnectionDone()),
            error.ConnectionLost: failure.Failure(error.ConnectionLost())
        }):
        """
        Utility function for disconnecting a selectable.

        Supports half-close notification, isRead should be boolean indicating
        whether error resulted from doRead().
        """
        self.removeReader(selectable)
        f = faildict.get(why.__class__)
        if f:
            if (isRead and why.__class__ == error.ConnectionDone
                    and IHalfCloseableDescriptor.providedBy(selectable)):
                selectable.readConnectionLost(f)
            else:
                self.removeWriter(selectable)
                selectable.connectionLost(f)
        else:
            self.removeWriter(selectable)
            selectable.connectionLost(failure.Failure(why))
コード例 #16
0
    def stopService(self):
        # note that once you stopService a Tub, I cannot be restarted. (at
        # least this code is not designed to make that possible.. it might be
        # doable in the future).
        assert self.running
        self.startService = self._tubsAreNotRestartable
        self.getReference = self._tubHasBeenShutDown
        self.connectTo = self._tubHasBeenShutDown

        # Tell everything to shut down now. We assume that it will stop
        # twitching by the next tick, so Trial unit tests won't complain
        # about a dirty reactor. We wait on a few things that might not
        # behave.
        dl = []
        for rc in list(self.reconnectors):
            rc.stopConnecting()
        del self.reconnectors
        for c in list(self._activeConnectors):
            c.shutdown()
        why = Failure(error.ConnectionDone("Tub.stopService was called"))
        for b in self.brokers.values():
            broker_disconnected = defer.Deferred()
            dl.append(broker_disconnected)
            b._notifyOnConnectionLost(
                lambda d=broker_disconnected: d.callback(None))
            b.shutdown(why, fireDisconnectWatchers=False)

        d = defer.DeferredList(dl)
        d.addCallback(lambda _: service.MultiService.stopService(self))
        d.addCallback(eventual.fireEventually)
        return d
コード例 #17
0
    def _doReadOrWrite(
        self,
        source,
        condition,
        faildict={
            error.ConnectionDone: failure.Failure(error.ConnectionDone()),
            error.ConnectionLost: failure.Failure(error.ConnectionLost()),
        }):
        why = None
        didRead = None
        if condition & POLL_DISCONNECTED and \
               not (condition & gobject.IO_IN):
            why = main.CONNECTION_LOST
        else:
            try:
                if condition & gobject.IO_IN:
                    why = source.doRead()
                    didRead = source.doRead
                if not why and condition & gobject.IO_OUT:
                    # if doRead caused connectionLost, don't call doWrite
                    # if doRead is doWrite, don't call it again.
                    if not source.disconnected and source.doWrite != didRead:
                        why = source.doWrite()
                        didRead = source.doWrite  # if failed it was in write
            except:
                why = sys.exc_info()[1]
                log.msg('Error In %s' % source)
                log.deferr()

        if why:
            self._disconnectSelectable(source, why, didRead == source.doRead)
コード例 #18
0
 def _doReadOrWrite(
     self,
     selectable,
     fd,
     event,
     POLLIN,
     POLLOUT,
     log,
     faildict={
         error.ConnectionDone: failure.Failure(error.ConnectionDone()),
         error.ConnectionLost: failure.Failure(error.ConnectionLost())
     }):
     why = None
     inRead = False
     if event & POLL_DISCONNECTED and not (event & POLLIN):
         why = main.CONNECTION_LOST
     else:
         try:
             if event & POLLIN:
                 why = selectable.doRead()
                 inRead = True
             if not why and event & POLLOUT:
                 why = selectable.doWrite()
                 inRead = False
             if not selectable.fileno() == fd:
                 why = error.ConnectionFdescWentAway(
                     'Filedescriptor went away')
                 inRead = False
         except:
             log.deferr()
             why = sys.exc_info()[1]
     if why:
         self._disconnectSelectable(selectable, why, inRead)
コード例 #19
0
    def test_incompleteUsername(self):
        """
        Test that a login attempt using a username without a domain part
        results in a customized authentication failure message which points
        out that a domain part should be included in the username.
        """
        mta = mail.MailTransferAgent(store=self.store)
        installOn(mta, self.store)
        factory = mta.getFactory()
        protocol = factory.buildProtocol(('192.168.1.1', 12345))
        transport = StringTransport()
        transport.getHost = lambda: IPv4Address('TCP', '192.168.1.1', 54321)
        transport.getPeer = lambda: IPv4Address('TCP', '192.168.1.1', 12345)
        protocol.makeConnection(transport)
        protocol.dataReceived('EHLO example.net\r\n')
        protocol.dataReceived('AUTH LOGIN\r\n')
        protocol.dataReceived('testuser'.encode('base64') + '\r\n')
        transport.clear()
        protocol.dataReceived('password'.encode('base64') + '\r\n')
        written = transport.value()
        protocol.connectionLost(failure.Failure(error.ConnectionDone()))

        self.assertEquals(
            written,
            '535 Authentication failure [Username without domain name (ie '
            '"yourname" instead of "yourname@yourdomain") not allowed; try '
            'with a domain name.]\r\n')
コード例 #20
0
 def test_connection_lost_connectiondone(self):
     # When the ConnectionDone is transmitted, consider it an expected
     # disconnection.
     self.conn._on_stream_terminated = mock.Mock()
     error = Failure(twisted_error.ConnectionDone())
     self.conn.connection_lost(error)
     self.assertEqual(self.conn._error, error.value)
     self.conn._on_stream_terminated.assert_called_with(None)
     self.assertIsNone(self.conn._transport)
コード例 #21
0
ファイル: fastagi.py プロジェクト: arjan/starpy
 def connectionLost( self, reason ):
     """(Internal) Handle loss of the connection (remote hangup)"""
     log.info( """Connection terminated""" )
     try:
         for df in self.pendingMessages:
             df.errback( tw_error.ConnectionDone( """FastAGI connection terminated""") )
     finally:
         if self.lostConnectionDeferred:
             self.lostConnectionDeferred.errback( reason )
         del self.pendingMessages[:]
コード例 #22
0
 def test_connectionLost(self):
     """
     L{server.Request.connectionLost} triggers all finish notification
     Deferreds and cleans up per-request state.
     """
     d = DummyChannel()
     request = server.Request(d, 1)
     finished = request.notifyFinish()
     request.connectionLost(error.ConnectionDone("Connection done"))
     self.assertIdentical(request.channel, None)
     return self.assertFailure(finished, error.ConnectionDone)
コード例 #23
0
 def testESMTPGreetingExtended(self):
     """
     Test that the string "ESMTP" does appear in the ESMTP server's
     greeting since L{smtp.ESMTP} does support the SMTP extensions which
     that advertises to the client.
     """
     s = smtp.ESMTP()
     t = StringTransport()
     s.makeConnection(t)
     s.connectionLost(error.ConnectionDone())
     self.assertIn("ESMTP", t.value())
コード例 #24
0
 def testSMTPGreetingHost(self, serverClass=smtp.SMTP):
     """
     Test that the specified hostname shows up in the SMTP server's
     greeting.
     """
     s = serverClass()
     s.host = "example.com"
     t = StringTransport()
     s.makeConnection(t)
     s.connectionLost(error.ConnectionDone())
     self.assertIn("example.com", t.value())
コード例 #25
0
 def testSMTPGreetingNotExtended(self):
     """
     Test that the string "ESMTP" does not appear in the SMTP server's
     greeting since that string strongly suggests the presence of support
     for various SMTP extensions which are not supported by L{smtp.SMTP}.
     """
     s = smtp.SMTP()
     t = StringTransport()
     s.makeConnection(t)
     s.connectionLost(error.ConnectionDone())
     self.assertNotIn("ESMTP", t.value())
コード例 #26
0
ファイル: iosim.py プロジェクト: palfrey/epsilon
    def pump(self, debug=False):
        """Move data back and forth.

        Returns whether any data was moved.
        """
        if self.debug or debug:
            print '-- GLUG --'
        sData = readAndDestroy(self.serverIO)
        cData = readAndDestroy(self.clientIO)
        self.client.transport._checkProducer()
        self.server.transport._checkProducer()
        if self.debug or debug:
            print '.'
            # XXX slightly buggy in the face of incremental output
            if cData:
                for line in cData.split('\r\n'):
                    print 'C: '+line
            if sData:
                for line in sData.split('\r\n'):
                    print 'S: '+line
        if cData:
            self.server.dataReceived(cData)
        if sData:
            self.client.dataReceived(sData)
        if cData or sData:
            return True
        if self.server.transport.disconnecting and not self.server.transport.disconnected:
            if self.debug or debug:
                print '* C'
            self.server.transport.disconnected = True
            self.client.transport.disconnecting = True
            self.client.connectionLost(error.ConnectionDone("Connection done"))
            return True
        if self.client.transport.disconnecting and not self.client.transport.disconnected:
            if self.debug or debug:
                print '* S'
            self.client.transport.disconnected = True
            self.server.transport.disconnecting = True
            self.server.connectionLost(error.ConnectionDone("Connection done"))
            return True
        return False
コード例 #27
0
ファイル: inmemory.py プロジェクト: omit66/ldaptor
def fromLDIFFile(f):
    """Read LDIF data from a file."""

    p = InMemoryLDIFProtocol()
    while 1:
        data = f.read()
        if not data:
            break
        p.dataReceived(data)
    p.connectionLost(Failure(error.ConnectionDone()))

    return p.completed
コード例 #28
0
        def conn_setup(node: NeoNode):
            # at this point we should have a fully connected node, so lets try to simulate a connection lost by the other side
            with self.assertLogHandler('network', 10) as log:
                node.connectionLost(failure.Failure(error.ConnectionDone()))

            self.assertTrue(
                "disconnected normally with reason" in log.output[-1])
            self.assertNotIn(self.addr, self.leader.DEAD_ADDRS)
            self.assertIn(self.addr, self.leader.KNOWN_ADDRS)
            self.assertNotIn(self.addr, self.leader.Peers)

            self.assertFalse(node.has_tasks_running())
コード例 #29
0
 def eventReceived(self, e):
     opcode = e[0]
     if opcode == 'c':
         command, user, message = e[1:]
         messageLen = len(message) # how many elements in msg
         handler = getattr(self, 'e_%s' % command, None) or getattr(self, 'elen_%i' % messageLen, None) or self.eUnknown
         line = handler(command, user, message)
         if line:
             if not user:
                 line = line[2:]
             return line
     elif opcode == 'disconnect':
         raise error.ConnectionDone()
コード例 #30
0
    def testPASV(self):
        # Login
        self._anonymousLogin()

        # Issue a PASV command, and extract the host and port from the response
        responseLines = wait(self.client.queueStringCommand('PASV'))
        host, port = ftp.decodeHostPort(responseLines[-1][4:])

        # Make sure the server is listening on the port it claims to be
        self.assertEqual(port, self.serverProtocol.dtpPort.getHost().port)

        # Semi-reasonable way to force cleanup
        self.serverProtocol.connectionLost(error.ConnectionDone())