Exemplo n.º 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)
Exemplo n.º 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())
Exemplo n.º 3
0
    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
Exemplo n.º 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]
Exemplo n.º 5
0
    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)
Exemplo n.º 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:
Exemplo n.º 7
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
        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)
Exemplo n.º 8
0
 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()
Exemplo n.º 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 )
Exemplo n.º 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'))
Exemplo n.º 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'))
Exemplo n.º 12
0
    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))
Exemplo n.º 13
0
    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))
Exemplo n.º 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)
Exemplo n.º 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))
Exemplo n.º 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
Exemplo n.º 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)
Exemplo n.º 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)
Exemplo n.º 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')
Exemplo 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)
Exemplo n.º 21
0
 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[:]
Exemplo n.º 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)
Exemplo n.º 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())
Exemplo n.º 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())
Exemplo n.º 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())
Exemplo n.º 26
0
    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
Exemplo n.º 27
0
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
Exemplo n.º 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())
Exemplo n.º 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()
Exemplo n.º 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())