def _amqp_conn_params(self):
vhost = self.def_amqp.virtual_host if 'virtual_host' in self.def_amqp else self.def_amqp.vhost
if 'credentials' in self.def_amqp:
username = self.def_amqp.credentials.username
password = self.def_amqp.credentials.password
else:
username = self.def_amqp.username
password = self.def_amqp.password
params = ConnectionParameters(self.def_amqp.host, int(self.def_amqp.port), vhost,
PlainCredentials(username, password),
frame_max=int(self.def_amqp.frame_max))
# heartbeat is an integer but ConnectionParameter.__init__ insists it
# be a boolean.
params.heartbeat = float(self.def_amqp.heartbeat)
return params
def main():
queue_name = "puccini_clean"
host = 'localhost'
conn = BlockingConnection(ConnectionParameters('localhost'))
channel = conn.channel()
channel.queue_declare(queue_name)
channel.basic_publish(exchange='',
routing_key=queue_name,
body=json.dumps({'clean': True}))
channel.close()
conn.close()
def main():
queue_name = "grq_clean"
host = 'localhost'
conn = BlockingConnection(ConnectionParameters('localhost'))
channel = conn.channel()
channel.queue_declare(queue_name, durable=True)
channel.basic_publish(exchange='',
routing_key=queue_name,
body=json.dumps({'clean': True}),
properties=BasicProperties(delivery_mode=2))
channel.close()
conn.close()
def connection_parameters(config):
args = {
'host': config.get('host', ConnectionParameters._DEFAULT),
'port': config.get('port', ConnectionParameters._DEFAULT),
'virtual_host': config.get('virtual_host',
ConnectionParameters._DEFAULT),
}
if 'username' in config:
args['credentials'] = pika.PlainCredentials(
config.get('username', Parameters.DEFAULT_USERNAME),
config.get('password', Parameters.DEFAULT_PASSWORD))
return ConnectionParameters(**args)
def _amqp_conn_params(self):
vhost = self.def_amqp.virtual_host if 'virtual_host' in self.def_amqp else self.def_amqp.vhost
if 'credentials' in self.def_amqp:
username = self.def_amqp.credentials.username
password = self.def_amqp.credentials.password
else:
username = self.def_amqp.username
password = self.def_amqp.password
params = ConnectionParameters(self.def_amqp.host,
int(self.def_amqp.port),
vhost,
PlainCredentials(username, password),
frame_max=int(self.def_amqp.frame_max))
# heartbeat is an integer but ConnectionParameter.__init__ insists it
# be a boolean.
params.heartbeat = float(self.def_amqp.heartbeat)
return params
def make_node(connection_params=None, name=None, timeout=None):
"""
Blocking construction and connection of node.
@param connection_params AMQP connection parameters. By default, uses CFG.server.amqp (most common use).
"""
log.debug("In make_node")
node = NodeB()
connection_params = connection_params or CFG.server.amqp
credentials = PlainCredentials(connection_params["username"], connection_params["password"])
conn_parameters = ConnectionParameters(host=connection_params["host"], virtual_host=connection_params["vhost"], port=connection_params["port"], credentials=credentials)
connection = PyonSelectConnection(conn_parameters , node.on_connection_open)
ioloop_process = gevent.spawn(ioloop, connection, name=name)
#ioloop_process = gevent.spawn(connection.ioloop.start)
node.ready.wait(timeout=timeout)
return node, ioloop_process
def startService(self):
params = {}
if self.settings.get("username", None, section='amqp') \
and self.settings.get("pass", None, section='amqp'):
params['credentials'] = pika_credentials.PlainCredentials(
self.settings.get("username", None, section='amqp'),
self.settings.get("pass", None, section='amqp'))
if self.settings.getdict("params", dict(), section='amqp'):
params.update(
self.settings.getdict("params", dict(), section='amqp'))
if self.settings.get("amqp_vhost", '/'):
params.update({
'virtual_host':
self.settings.get("vhost", '/', section='amqp')
})
parameters = ConnectionParameters(**params)
self._client = protocol.ClientCreator(
reactor, twisted_connection.TwistedProtocolConnection, parameters)
self.do_connect()
def make_node(connection_params=None, name=None, timeout=None):
"""
Blocking construction and connection of node.
@param connection_params AMQP connection parameters. By default, uses CFG.server.amqp (most common use).
@return tuple of node and ioloop greenlet
"""
log.debug("In make_node")
node = NodeB()
connection_params = connection_params or CFG.get_safe("server.amqp")
credentials = PlainCredentials(connection_params["username"],
connection_params["password"])
conn_parameters = ConnectionParameters(
host=connection_params["host"],
virtual_host=connection_params["vhost"],
port=connection_params["port"],
credentials=credentials)
connection = PyonSelectConnection(conn_parameters, node.on_connection_open)
ioloop_gl = gevent.spawn(ioloop, connection, name=name)
ioloop_gl._glname = "ScionCC AMQP ioloop"
node.ready.wait(timeout=timeout)
return node, ioloop_gl
# Setup empty ssl options
ssl_options = {}
# Uncomment this to test client certs, change to your cert paths
# Uses certs as generated from http://www.rabbitmq.com/ssl.html
ssl_options = {
"ca_certs": "/etc/rabbitmq/new/server/chain.pem",
"certfile": "/etc/rabbitmq/new/client/cert.pem",
"keyfile": "/etc/rabbitmq/new/client/key.pem",
"cert_reqs": CERT_REQUIRED
}
# Connect to RabbitMQ
host = (len(sys.argv) > 1) and sys.argv[1] or '127.0.0.1'
parameters = ConnectionParameters(host,
5671,
ssl=True,
ssl_options=ssl_options)
connection = SelectConnection(parameters, on_connected)
# Loop until CTRL-C
try:
# Start our blocking loop
connection.ioloop.start()
except KeyboardInterrupt:
# Close the connection
connection.close()
# Loop until the conneciton is closed
connection.ioloop.start()
def on_queue_declared(frame):
print "demo_receive: Queue Declared"
channel.basic_consume(handle_delivery, queue='test')
def handle_delivery(channel, method_frame, header_frame, body):
print "Basic.Deliver %s delivery-tag %i: %s" %\
(header_frame.content_type,
method_frame.delivery_tag,
body)
channel.basic_ack(delivery_tag=method_frame.delivery_tag)
if __name__ == '__main__':
# Connect to RabbitMQ
host = (len(sys.argv) > 1) and sys.argv[1] or '127.0.0.1'
connection = SelectConnection(ConnectionParameters(host), on_connected)
# Loop until CTRL-C
try:
# Start our blocking loop
connection.ioloop.start()
except KeyboardInterrupt:
# Close the connection
connection.close()
# Loop until the conneciton is closed
connection.ioloop.start()
env=os.environ)
try:
sts = pop.wait() #wait for child to terminate and get status
except Exception, e:
print str(e)
status = pop.returncode
#print "returncode is:",status
stdOut = pop.stdout.read()
stdErr = pop.stderr.read()
for line in stdOut.split('\n'):
if line.startswith("error_queue"):
COUNT = int(line.split()[1])
break
print "Total number of messages in error_queue:", COUNT
if COUNT == 0: sys.exit()
# Connect to RabbitMQ
host = (len(sys.argv) > 1) and sys.argv[1] or '127.0.0.1'
CONNECTION = BlockingConnection(ConnectionParameters(host))
# Open the channel
channel = CONNECTION.channel()
# loop
for method_frame, properties, body in channel.consume('error_queue'):
if handle_delivery(channel, method_frame, body): break
channel.stop_consuming()
channel.close()
CONNECTION.close()
import sys
from pika import BlockingConnection
from pika.credentials import PlainCredentials
from pika.connection import ConnectionParameters
if len(sys.argv) > 1:
rkey = sys.argv[1] or "error"
msg = " ".join(sys.argv[2:]) or "shit happen!"
else:
rkey = "error"
msg = "shit happen!"
connection = BlockingConnection(parameters=ConnectionParameters(
host="localhost",
credentials=PlainCredentials(username="******", password="******"),
))
ch = connection.channel()
exchange = ch.exchange_declare(exchange="topic_log", exchange_type="topic")
ch.basic_publish(exchange="topic_log", routing_key=rkey, body=msg)
connection.close()
self.lc.stop()
d = self.channel.queue_delete(queue=self.queue_name)
d.addCallbacks(self.stopped_consuming, twisted_log.err)
def stopped_consuming(self, _):
pika_log.info("demo_twisted: Consuming stopped, queue deleted")
if __name__ == '__main__':
if len(sys.argv) != 2:
print >> sys.stderr, ("usage: %s [p|t] (use Pika or Twisted "
"for connecting" % sys.argv[0])
sys.exit(1)
handler = TwistedHandler()
parameters = ConnectionParameters()
pika_log.setup(color=True)
if sys.argv[1] == 'p':
TwistedConnection(parameters, handler.on_connected)
elif sys.argv[1] == 't':
cc = protocol.ClientCreator(reactor, TwistedProtocolConnection,
parameters)
d = cc.connectTCP('localhost', 5672)
d.addCallback(lambda protocol: protocol.ready)
d.addCallback(handler.on_connected)
d.addErrback(twisted_log.err)
else:
print >> sys.stderr, ("usage: %s [p|t] (use Pika or Twisted "
"for connecting" % sys.argv[0])
sys.exit(1)
PORT = int(environ.get('RABBITMQ_PORT', 5672))
PLATFORM = uname()[0].lower()
# Import Warnings
import warnings
# Validate that we can connect to RabbitMQ
import socket
socket.setdefaulttimeout(1)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
sock.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, 1)
try:
sock.connect((HOST, PORT))
sock.close()
except socket.error:
warnings.warn("RabbitMQ is not running at %s:%i" % (HOST, PORT))
from nose import SkipTest
raise SkipTest("RabbitMQ is not running at %s:%i" % (HOST, PORT))
# Ignore the pika generated warnings
warnings.simplefilter('ignore', UserWarning)
# Set our connection parameters to be used by our tests
from pika.connection import ConnectionParameters
PARAMETERS = ConnectionParameters(HOST, PORT)
if __name__ == '__main__':
print "Platform: %s" % PLATFORM
print "Python Version: %s" % PYTHON_VERSION
print "RabbitMQ Broker: %s:%i" % (HOST, PORT)
def open(self) -> None:
self._connection = pika.BlockingConnection(ConnectionParameters(HOST))
def test_address_1(self):
p = ConnectionParameters(host="foobar", port=1234)
addr1 = AMQPAddress(p)
assert addr1.unparse(routing_key='123') == "amqp://*****:*****@foobar:1234/%2f?routing_key=123"
assert AMQPAddress(addr1.get_parameters()).unparse() == 'amqp://*****:*****@foobar:1234/%2f'
def __init__(self):
self._connection = BlockingConnection(ConnectionParameters(HOST))
"""
Example of the use of basic_get. NOT RECOMMENDED for fast consuming - use
basic_consume instead if at all possible!
"""
import sys
import time
from pika.adapters import BlockingConnection
from pika.connection import ConnectionParameters
if __name__ == '__main__':
# Connect to RabbitMQ
host = (len(sys.argv) > 1) and sys.argv[1] or '127.0.0.1'
connection = BlockingConnection(ConnectionParameters(host))
# Open the channel
channel = connection.channel()
# Declare the queue
channel.queue_declare(queue="test",
durable=True,
exclusive=False,
auto_delete=False)
# Initialize our timers and loop until external influence stops us
while connection.is_open:
# Call basic get which returns the 3 frame types
method, header, body = channel.basic_get(queue="test")
def __init__(self):
self._connection = pika.BlockingConnection(
ConnectionParameters(host=HOST))