def __init__(self, *args, **kwargs):
     print 'init protocol'
     self._stop = False
     # callback on authenticated
     self._auth_succ = Deferred()
     # callback on read_channel opened
     self._read_opened = Deferred()
     # callback on write_channel opened
     self._write_opened = Deferred()
     # callback on read_loop started
     self._read_loop_started = Deferred()
     # callback on shutdown read loop
     self._read_loop_down = Deferred()
     # read queue timeout
     self.q_timeout = 1
     # read loop call
     self._rloop_call = None
     self._sloop_call = None
     self.read_queue = None
     self.read_chan = None
     kwargs['heartbeat'] = kwargs.get('heartbeat', 10)
     # failure traps
     #self.log.warning('AUTO SHUTDOWN 15 sec')
     #reactor.callLater(15, lambda _: self.shutdown_protocol(), (None,))
     self.__messages = set()
     AMQClient.__init__(self, *args, **kwargs)

    def connectionMade(self):
        """
        Hook called when the connection is made; we'll use this to perform
        exchange setup, etc.
        """
        try:
            connectionInfo = self.factory.connectionInfo
            set_keepalive(self.transport.socket, connectionInfo.amqpconnectionheartbeat)
            AMQClient.connectionMade(self)
            log.debug('Made initial connection to message broker')
            self._connected = False
            # Authenticate
            try:
                yield self.start({'LOGIN':connectionInfo.user, 'PASSWORD':connectionInfo.password})
                self.factory.onAuthenticated(True)
                log.debug('Successfully authenticated as %s' % connectionInfo.user)
            except Exception as e:
                log.warn("Error authenticating to %s as %s" % (connectionInfo.host, connectionInfo.user))
                self.factory.onAuthenticated(e.args[0])
                return
            # Get a channel
            self.chan = yield self.get_channel()
            self._connected = True
            # Initialize the queues
            yield self.begin_listening()

            # Call back our deferred
            self.factory.onConnectionMade(self)
            # Flush any messages that have been sent before now
            yield self.send()
            returnValue(None)
        except Exception:
            log.exception("Unable to connect")

 def __init__(self, *args, **kwargs):
     self.log.debug('init protocol')
     self._stop = False
     # callback on authenticated
     self._auth_succ = Deferred()
     # callback on read_channel opened
     self._read_opened = Deferred()
     # callback on write_channel opened
     self._write_opened = Deferred()
     # callback on read_loop started
     self._read_loop_started = Deferred()
     # callback on shutdown read loop
     self._read_loop_down = Deferred()
     # read queue timeout
     self.q_timeout = 1
     # read loop call
     self._rloop_call = None
     self._sloop_call = None
     # ensure that we start read loop only once
     self._read_loop_enabled = False
     self.read_queue = None
     self.read_chan = None
     kwargs['heartbeat'] = kwargs.get('heartbeat', 10)
     self.__messages = set()
     AMQClient.__init__(self, *args, **kwargs)

 def connectionMade(self):
     AMQClient.connectionMade(self)
     # Authenticate.
     assert self.factory is not None
     deferred = self.start({"LOGIN": self.factory.user,
                            "PASSWORD": self.factory.password})
     deferred.addCallbacks(self._authenticated, self._authentication_failed)

class AMQFactory(protocol.ReconnectingClientFactory):
    VHOST = '/'

    def __init__(self, creds):
        self.spec = txamqp.spec.load(SPECFILE)
        self.creds = creds
        self.client = None
        self.channel  = None

    def buildProtocol(self, addr):
        self.resetDelay()
        delegate = TwistedDelegate()
        self.client = AMQClient(delegate=delegate, vhost=self.VHOST, spec=self.spec)
        self.client.start(self.creds)
        return self.client

    @defer.inlineCallbacks
    def publish(self, exchange, msg, routing_key):
        if not self.client:
            raise NotImplementedError
        if not self.channel:
            yield self._createChannel()
        content = Content(msg)
        yield self.channel.basic_publish(exchange=exchange, content=content, routing_key=routing_key)

    @defer.inlineCallbacks
    def _createChannel(self):
        self.channel = yield self.client.channel(1)
        yield self.channel.channel_open()

 def connectionMade(self):
     AMQClient.connectionMade(self)
     yield self.authenticate(self.vumi_options['username'],
                             self.vumi_options['password'])
     # authentication was successful
     log.msg("Got an authenticated connection")
     yield self.connected_callback(self)

 def makeConnection(self, transport):
     '''
     This only for debug errors
     '''
     try:
         AMQClient.makeConnection(self, transport)
     except Exception, mess:
         self.log.error('During makeConnection: %r'%mess)

 def connectionLost(self, reason):
     """
     Remove this protocol as a consumer of log events.
     """
     self.chan = None
     self.dispatcher.unregister(self.producer.put)
     log.err(reason, "Connection lost")
     AMQClient.connectionLost(self, reason)

 def connectionMade(self):
     """Called when a connection has been made."""
     AMQClient.connectionMade(self)
     # Flag that this protocol is not connected yet.
     self.connected = False
     
     # Authenticate.
     deferred = self.authenticate(self.factory.user, self.factory.password)
     deferred.addCallback(self._authenticated)
     deferred.addErrback(self._authentication_failed)

 def connectionMade(self):
     AMQClient.connectionMade(self)
     # set that we are not connected
     # since we should authenticate and open channels
     self.connected = False
     self.log.debug('go authentication %r'%self.factory.user)
     d = self.authenticate(self.factory.user, self.factory.password)
     d.addCallback(self._authenticated)
     d.addErrback(self._error)
     return d

    def __init__(self, *args, **kwargs):
        AMQClient.__init__(self, *args, **kwargs)

        if self.check_0_8():
            self.replyToField = "reply to"
        else:
            self.replyToField = "reply-to"

        self.thriftBasicReturnQueueLock = defer.DeferredLock()
        self.thriftBasicReturnQueues = {}

 def connectionMade(self):
     """
     authenticate and start the Node 
     """
     AMQClient.connectionMade(self)
     username = self.factory.username
     password = self.factory.password
     # authentication should happen automatically, and fail asap
     # XXX need to know how it can fail still
     d = self.authenticate(username, password)
     d.addCallback(self._auth_result)
     d.addErrback(self._auth_fail)

    def connectionMade(self):
        """
        Add this protocol as a consumer of log events.
        """
        AMQClient.connectionMade(self)

        def eb(failure):
            log.err(failure)
            self.transport.loseConnection()

        d = self.gotConnection()
        d.addErrback(eb)

    def connectionMade(self):
        """Called when a connection has been made."""
        AMQClient.connectionMade(self)

        # Flag that this protocol is not connected yet.
        self.connected = False

        self.consumer_tags = {}

        # Authenticate.
        deferred = self.start({"LOGIN": self.factory.user, "PASSWORD": self.factory.password})
        deferred.addCallback(self._authenticated)
        deferred.addErrback(self._authentication_failed)

    def __init__(self, dispatcher, username='guest', password='guest',
                       vhost='/', exchange='logs', queueSize=None):
        self.dispatcher = dispatcher
        self.username = username
        self.password = password
        self.exchange = exchange
        self.queueSize = queueSize

        self.chan = None

        specDir = FilePath(__file__).parent()
        specFilePath = specDir.child('amqp0-9-1.extended.xml')
        spec = txamqp.spec.load(specFilePath.path)

        delegate = TwistedDelegate()
        AMQClient.__init__(self, delegate=delegate, vhost=vhost,
                                 spec=spec)

    def connectionMade(self):
        """Called when a connection has been made."""
        AMQClient.connectionMade(self)
        self.default_log_level = self.factory.log_level is not None and self.factory.log_level or self.default_log_level

        # Flag that this protocol is not connected yet.
        self.connected = False

        # Authenticate.
        try:
            yield self.start(self.factory.credentials)
        except Exception:
            logger.error("Authentication failed: {}".format(traceback.format_exc()))
            returnValue(None)

        # Authenticated!
        try:
            self.chan = yield self.channel(self.get_channel_number())
        except Exception:
            logger.error("Failed to get channel: {}".format(traceback.format_exc()))
            returnValue(None)

        # You now have a channel!
        try:
            yield self.chan.channel_open()
        except Exception:
            logger.error("Failed to open channel: {}".format(traceback.format_exc()))
            returnValue(None)

        # Mark the connection as open.
        self.connected = True
        logger.info('AMQP connection made.')

        # Now that the channel is open add any readers the user has specified.
        for consumer in self.factory.consumers:
            self.read(consumer)

        # Send any messages waiting to be sent.
        self.send()

        # Fire the factory's 'initial connect' deferred if it hasn't already
        if not self.factory.deferred.called:
            self.factory.deferred.callback(self)

 def sendHeartbeat(self):
     log.msg('sendHeartbeat')
     AMQClient.sendHeartbeat(self)

 def reschedule_checkHB(self):
     log.msg('Reschedule check heartbeat')
     AMQClient.reschedule_checkHB(self)

 def reschedule_sendHB(self):
     log.msg('Reschedule send heartbeat')
     AMQClient.reschedule_sendHB(self)

 def connectionMade(self):
     yield AMQClient.connectionMade(self)
     log.listener("New AMQP connection made")
     yield self.setup()
     yield self.receive_loop()