Python twisted.internet.protocol.ReconnectingClientFactory() Examples

def test_stopTryingWhenConnected(self):
        """
        If a L{ReconnectingClientFactory} has C{stopTrying} called while it is
        connected, it does not subsequently attempt to reconnect if the
        connection is later lost.
        """
        class NoConnectConnector(object):
            def stopConnecting(self):
                raise RuntimeError("Shouldn't be called, we're connected.")
            def connect(self):
                raise RuntimeError("Shouldn't be reconnecting.")

        c = ReconnectingClientFactory()
        c.protocol = Protocol
        # Let's pretend we've connected:
        c.buildProtocol(None)
        # Now we stop trying, then disconnect:
        c.stopTrying()
        c.clientConnectionLost(NoConnectConnector(), None)
        self.assertFalse(c.continueTrying) 

def testStopTrying(self):
        f = Factory()
        f.protocol = In
        f.connections = 0
        f.allMessages = []
        f.goal = 2
        f.d = defer.Deferred()

        c = ReconnectingClientFactory()
        c.initialDelay = c.delay = 0.2
        c.protocol = Out
        c.howManyTimes = 2

        port = self.port = reactor.listenTCP(0, f)
        PORT = port.getHost().port
        reactor.connectTCP('127.0.0.1', PORT, c)

        f.d.addCallback(self._testStopTrying_1, f, c)
        return f.d 

def test_deserializationResetsParameters(self):
        """
        A L{ReconnectingClientFactory} which is unpickled does not have an
        L{IConnector} and has its reconnecting timing parameters reset to their
        initial values.
        """
        factory = ReconnectingClientFactory()
        factory.clientConnectionFailed(FakeConnector(), None)
        self.addCleanup(factory.stopTrying)

        serialized = pickle.dumps(factory)
        unserialized = pickle.loads(serialized)
        self.assertEqual(unserialized.connector, None)
        self.assertEqual(unserialized._callID, None)
        self.assertEqual(unserialized.retries, 0)
        self.assertEqual(unserialized.delay, factory.initialDelay)
        self.assertEqual(unserialized.continueTrying, True) 

def testStopTrying(self):
        f = Factory()
        f.protocol = In
        f.connections = 0
        f.allMessages = []
        f.goal = 2
        f.d = defer.Deferred()

        c = ReconnectingClientFactory()
        c.initialDelay = c.delay = 0.2
        c.protocol = Out
        c.howManyTimes = 2

        port = reactor.listenTCP(0, f)
        self.addCleanup(port.stopListening)
        PORT = port.getHost().port
        reactor.connectTCP('127.0.0.1', PORT, c)

        f.d.addCallback(self._testStopTrying_1, f, c)
        return f.d 

def test_stopTryingWhenConnected(self):
        """
        If a L{ReconnectingClientFactory} has C{stopTrying} called while it is
        connected, it does not subsequently attempt to reconnect if the
        connection is later lost.
        """
        class NoConnectConnector(object):
            def stopConnecting(self):
                raise RuntimeError("Shouldn't be called, we're connected.")
            def connect(self):
                raise RuntimeError("Shouldn't be reconnecting.")

        c = ReconnectingClientFactory()
        c.protocol = Protocol
        # Let's pretend we've connected:
        c.buildProtocol(None)
        # Now we stop trying, then disconnect:
        c.stopTrying()
        c.clientConnectionLost(NoConnectConnector(), None)
        self.assertFalse(c.continueTrying) 

def test_serializeWithClock(self):
        """
        The clock attribute of L{ReconnectingClientFactory} is not serialized,
        and the restored value sets it to the default value, the reactor.
        """
        clock = Clock()
        original = ReconnectingClientFactory()
        original.clock = clock
        reconstituted = pickle.loads(pickle.dumps(original))
        self.assertIdentical(reconstituted.clock, None) 

def test_parametrizedClock(self):
        """
        The clock used by L{ReconnectingClientFactory} can be parametrized, so
        that one can cleanly test reconnections.
        """
        clock = Clock()
        factory = ReconnectingClientFactory()
        factory.clock = clock

        factory.clientConnectionLost(FakeConnector(), None)
        self.assertEqual(len(clock.calls), 1) 

def clientConnectionLost(self, connector, reason):
        log.msg('Lost connection.  Reason:' + str(reason))
        self.proto = None

        self._do_failover(connector)

        log.msg('Reconnecting to Riemann on %s:%s' % (connector.host, connector.port))
        protocol.ReconnectingClientFactory.clientConnectionLost(
            self, connector, reason) 

def clientConnectionFailed(self, connector, reason):
        log.msg('Connection failed. Reason:' + str(reason))
        self.proto = None

        self._do_failover(connector)

        log.msg('Reconnecting to Riemann on %s:%s' % (connector.host, connector.port))
        protocol.ReconnectingClientFactory.clientConnectionFailed(
            self, connector, reason) 

def clientConnectionLost(self, connector, reason):
        LOG.info('Lost connection.  Reason: %s', reason.getErrorMessage())
        protocol.ReconnectingClientFactory.clientConnectionLost(self, connector, reason.getErrorMessage()) 

def clientConnectionFailed(self, connector, reason):
        LOG.info('Connection failed. Reason: %s', reason.getErrorMessage())
        protocol.ReconnectingClientFactory.clientConnectionFailed(self, connector, reason.getErrorMessage()) 

def buildProtocol(self, addr):
        """
        Create a protocol instance.

        Overrides L{XmlStreamFactoryMixin.buildProtocol} to work with
        a L{ReconnectingClientFactory}. As this is called upon having an
        connection established, we are resetting the delay for reconnection
        attempts when the connection is lost again.
        """
        self.resetDelay()
        return XmlStreamFactoryMixin.buildProtocol(self, addr) 

def test_serializeUnused(self):
        """
        A L{ReconnectingClientFactory} which hasn't been used for anything
        can be pickled and unpickled and end up with the same state.
        """
        original = ReconnectingClientFactory()
        reconstituted = pickle.loads(pickle.dumps(original))
        self.assertEqual(original.__dict__, reconstituted.__dict__) 

def main():
    f = protocol.ReconnectingClientFactory()
    f.protocol = HighFiveBot

    reactor.connectTCP(serv_ip, serv_port, f)
    reactor.run() 

def buildProtocol(self, addr):
        prot = protocol.ReconnectingClientFactory.buildProtocol(self, addr)

        # decorate the protocol with a delay reset
        prot.connectionMade = decorate_func(self.resetDelay,
                                            prot.connectionMade)
        
        return prot 

def buildProtocol(self, addr):
        prot = protocol.ReconnectingClientFactory.buildProtocol(self, addr)

        # decorate the protocol with a delay reset
        prot.connectionMade = decorate_func(self.resetDelay,
                                            prot.connectionMade)
        
        return prot 

def clientConnectionLost(self, connector, reason):
        log.debug('IRC connection lost: ' + str(reason))
        if not self.wrapper.give_up:
            if reactor.running:
                log.info('Attempting to reconnect...')
                protocol.ReconnectingClientFactory.clientConnectionLost(self,
                                                                connector, reason) 

def clientConnectionFailed(self, connector, reason):
        log.info('IRC connection failed')
        if not self.wrapper.give_up:
            if reactor.running:
                log.info('Attempting to reconnect...')
                protocol.ReconnectingClientFactory.clientConnectionFailed(self,
                                                                connector, reason) 

def clientConnectionLost(self, connector, reason):
        print "WARNING: Redis Subscription Connection Lost. Probably dropping messages!"
        self.dispatch.redis = DisconnectedRedis()
        protocol.ReconnectingClientFactory.clientConnectionLost(self, connector, reason) 

def clientConnectionFailed(self, connector, reason):
        print "WARNING: Redis Subscription Failed to Reconnect. Probably still dropping messages!"
        protocol.ReconnectingClientFactory.clientConnectionFailed(self, connector, reason) 

def handleCmd_SERVER(self, prefix, args):
        if prefix:
            # Not from our connected server
            return

        if self.server_name:
            # Could be a dupe?  Ignore it.
            return

        # We got a reply from the our connected IRC server, so our password
        # was just accepted.  Send the Dtella state information into IRC.

        # Save server name
        CHECK(args[0])
        self.server_name = args[0]

        LOG.info("IRC Server Name: %s" % self.server_name)

        # Tell the ReconnectingClientFactory that we're cool
        self.factory.resetDelay()

        # This isn't very correct, because the Dtella nicks
        # haven't been sent yet, but it's the best we can practically do.
        scfg = getServiceConfig()
        cloak_checksum = scfg.hostmasker.getChecksum()
        self.sendLine("NETINFO 0 %d 0 %s 0 0 0 :%s" %
                      (time.time(), cloak_checksum, scfg.network_name))
        self.sendLine(":%s EOS" % scfg.my_host) 

def test_serializeUnused(self):
        """
        A L{ReconnectingClientFactory} which hasn't been used for anything
        can be pickled and unpickled and end up with the same state.
        """
        original = ReconnectingClientFactory()
        reconstituted = pickle.loads(pickle.dumps(original))
        self.assertEqual(original.__dict__, reconstituted.__dict__) 

def main():
    f = protocol.ReconnectingClientFactory()
    f.protocol = Doge

    reactor.connectTCP(serv_ip, serv_port, f)
    reactor.run() 

def main():
    f = protocol.ReconnectingClientFactory()
    f.protocol = ChiefExecBot

    reactor.connectTCP(serv_ip, serv_port, f)
    reactor.run() 

def main(self):
        f = protocol.ReconnectingClientFactory()
        f.protocol = burnBot
        serv_ip, serv_port = self.get_server_info()
        reactor.connectTCP(serv_ip, serv_port, f)
        reactor.run() 

def main():
    f = protocol.ReconnectingClientFactory()
    f.protocol = LurkBot

    reactor.connectTCP(serv_ip, serv_port, f)
    reactor.run() 

def main():
    serv_ip = 'coop.test.adtran.com'
    serv_port = 6667

    f = protocol.ReconnectingClientFactory()
    f.protocol = pointBot

    reactor.connectTCP(serv_ip, serv_port, f)
    reactor.run() 

def main():
    f = protocol.ReconnectingClientFactory()
    f.protocol = gooseBot

    reactor.connectTCP(serv_ip, serv_port, f)
    reactor.run() 

def main():
    f = protocol.ReconnectingClientFactory()
    f.protocol = complimentBot

    reactor.connectTCP(serv_ip, serv_port, f)
    reactor.run() 

def main():
    f = protocol.ReconnectingClientFactory()
    f.protocol = hangman
    
    reactor.connectTCP("coop.test.adtran.com", 6667, f)
    reactor.run()