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 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 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)
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 connectionMade(self):
"""Called when a connection has been made."""
self.factory.log.info(
"Connection made to %s:%s" %
(self.factory.config.host, self.factory.config.port))
AMQClient.connectionMade(self)
self.factory.connectDeferred.callback(self)
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 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):
"""
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):
"""
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):
"""
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):
"""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 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.start({
"LOGIN": self.factory.user,
"PASSWORD": self.factory.password
})
deferred.addCallback(self._authenticated)
deferred.addErrback(self._authentication_failed)
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 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 connectionMade(self):
yield AMQClient.connectionMade(self)
log.listener("New AMQP connection made")
yield self.setup()
yield self.receive_loop()
def connectionMade(self):
"""Called when a connection has been made."""
self.factory.log.info("Connection made to %s:%s" % (self.factory.config.host, self.factory.config.port))
AMQClient.connectionMade(self)
self.factory.connectDeferred.callback(self)
def connectionMade(self):
AMQClient.connectionMade(self)
self.factory.gotConnection(self)
def connectionMade(self):
AMQClient.connectionMade(self)
self.connected_callback(self)
def connectionMade(self):
AMQClient.connectionMade(self)
log.listener("New AMQP connection made")
self.setup()
wfd = waitForDeferred(self.receive_loop())
yield wfd
def connectionMade(self, *args, **kwargs):
AMQClient.connectionMade(self, *args, **kwargs)
self.factory.onConnectionMade.callback(self)
def connectionMade(self):
AMQClient.connectionMade(self)
df = self.connect()
df.addCallback(self.connect_success)
def connectionMade(self):
AMQClient.connectionMade(self)
self.factory.gotConnection(self)
def connectionMade(self):
yield AMQClient.connectionMade(self)
log.listener("New AMQP connection made")
yield self.setup()
yield self.receive_loop()
def connectionMade(self):
AMQClient.connectionMade(self)
self.connected_callback(self)
def connectionMade(self):
self.closed = False
AMQClient.connectionMade(self)
def connectionMade(self):
"""
Here you can do something when the connection is made.
"""
AMQClient.connectionMade(self)
