def _process_attacks_queue(self) -> None:
conn = Connection(config.get_broker_url())
with conn.channel() as channel:
producer = Producer(channel)
by_label = defaultdict(list)
while not self._q.empty():
try:
ar: models.AttackResult = self._q.get_nowait()
except Empty:
continue
else:
by_label[ar.get_label_key()].append(ar)
for ar_list in by_label.values():
if not ar_list:
continue
monitor_message = {
'type': 'flag_submit',
'data': ar_list[0].get_label_values(),
'value': len(ar_list),
}
producer.publish(
monitor_message,
exchange='',
routing_key='forcad-monitoring',
)
def _send_dhcp_notification(self, context, data, methodname):
#self._dhcp_agent_notifier.notify(context, data, methodname)
task_exchange = Exchange('nspagent', type='topic')
create_result = {"oslo.message" :{
#'message_id': '5c329c20-d435-444c-8fa2-e1b54592219c',
#'publisher_id': 'compute.host1',
'method': 'network_create_end',
#'_context_user_id': None,
#'_context_project_id': None,
#'_context_is_admin': True,
"args" : {"payload": {"network": network
#{"id": "24783e1a-63fe-43d5-9989-e1515c24eecd"}
}
}
},
"oslo.version":'2.0',
}
create_result["oslo.message" ] = json.dumps(create_result["oslo.message"])
connection = Connection('amqp://*****:*****@192.168.49.22:5672//')
channel = connection.channel()
message=Message(channel,body= 'subenet_create_end')
# produce
producer = Producer(channel,serializer='json')
print message.body, task_exchange
producer.publish(create_result, routing_key='dhcp_agent')
class QueuePush(object):
def __init__(self,Queue_Server,Queue_Port,Queue_User,Queue_PassWord,Queue_Path):
self.usr=Queue_User
self.psw=Queue_PassWord
self.server=Queue_Server
self.port=Queue_Port
self.path=Queue_Path
self.connection=None
self.smsExchange=None
def _InitConnect(self):
if self.connection is None or self.connection.connected==False:
self.connection = Connection(hostname=self.server,port=self.port,userid=self.usr,password=self.psw,virtual_host=self.path)
self.channel = self.connection.channel()
self.producer=Producer(self.channel)
self.smsExchange=Exchange("sys.sms",type='topic',channel=self.channel,durable=True,delivery_mode=2)
self.smsCodeProduce=Producer(self.channel,self.smsExchange,routing_key='sms.code')
def Push(self,queueid,connectid,body):
self.rawPush(queueid,{'connid':connectid},body)
def Close(self,queueid,connectid):
self.rawPush(queueid,{'connid':connectid,'close_connect':'1'},'close')
def rawPush(self,routing_key,headers,body):
self._InitConnect()
self.producer.publish(body=body,delivery_mode=2,headers=headers,
routing_key=routing_key,retry=True,compression='gzip')
def sendCode(self,phone,code):
self._InitConnect()
json_str=json.dumps({'phone':str(phone),"content":u"您的莱信验证码为:%s，请在5分钟内输入完成验证。【莱福思】"%str(code)},ensure_ascii=False)
self.smsCodeProduce.publish(body=json_str,retry=True,compression='gzip')
class UdpService(os_service.Service):
"""Listener for the udpservice service."""
def start(self):
"""Bind the UDP socket and handle incoming data."""
# ensure dispatcher is configured before starting other services
super(UdpService, self).start()
if cfg.CONF.udpservice.udp_address:
self.tg.add_thread(self.start_udp)
def convert_sample_to_event_data(self,msg):
event_data = {'event_type': 'infra','message_id':six.text_type(uuid.uuid4()),'publisher_id': 'cpe_publisher_id','timestamp':datetime.datetime.now().isoformat(),'priority':'INFO','payload':msg}
return event_data
def setup_rabbit_mq_channel(self):
service_exchange = Exchange(cfg.CONF.udpservice.acord_control_exchange, "topic", durable=False)
rabbit_host = cfg.CONF.udpservice.rabbit_hosts
rabbit_user = cfg.CONF.udpservice.rabbit_userid
rabbit_password = cfg.CONF.udpservice.rabbit_password
# connections/channels
connection = BrokerConnection(rabbit_host, rabbit_user, rabbit_password)
print 'Connection to RabbitMQ server successful'
channel = connection.channel()
# produce
self.producer = Producer(channel, exchange=service_exchange, routing_key='notifications.info')
def start_udp(self):
address_family = socket.AF_INET
if netutils.is_valid_ipv6(cfg.CONF.udpservice.udp_address):
address_family = socket.AF_INET6
udp = socket.socket(address_family, socket.SOCK_DGRAM)
udp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
udp.bind((cfg.CONF.udpservice.udp_address,
cfg.CONF.udpservice.udp_port))
self.setup_rabbit_mq_channel()
self.udp_run = True
while self.udp_run:
# NOTE(jd) Arbitrary limit of 64K because that ought to be
# enough for anybody.
data, source = udp.recvfrom(64 * units.Ki)
try:
sample = msgpack.loads(data, encoding='utf-8')
except Exception:
LOG.warn(_("UDP: Cannot decode data sent by %s"), source)
else:
try:
if sample.has_key("event_type"):
LOG.debug(_("recevied event :%s"),sample)
self.producer.publish(sample)
else:
LOG.debug(_("recevied Sample :%s"),sample)
msg = self.convert_sample_to_event_data(sample)
self.producer.publish(msg)
except Exception:
LOG.exception(_("UDP: Unable to store meter"))
def stop(self):
self.udp_run = False
super(UdpService, self).stop()
def test_publish__consume(self):
connection = BrokerConnection(transport=Transport)
channel = connection.channel()
producer = Producer(channel, self.exchange, routing_key="test_Redis")
consumer = Consumer(channel, self.queue)
producer.publish({"hello2": "world2"})
_received = []
def callback(message_data, message):
_received.append(message_data)
message.ack()
consumer.register_callback(callback)
consumer.consume()
self.assertIn(channel, channel.connection.cycle._channels)
try:
connection.drain_events(timeout=1)
self.assertTrue(_received)
self.assertRaises(socket.timeout,
connection.drain_events,
timeout=0.01)
finally:
channel.close()
def test_publish__consume(self):
connection = BrokerConnection(transport=Transport)
channel = connection.channel()
producer = Producer(channel, self.exchange, routing_key="test_Redis")
consumer = Consumer(channel, self.queue)
producer.publish({"hello2": "world2"})
_received = []
def callback(message_data, message):
_received.append(message_data)
message.ack()
consumer.register_callback(callback)
consumer.consume()
self.assertTrue(channel._poller._can_start())
try:
connection.drain_events(timeout=1)
self.assertTrue(_received)
self.assertFalse(channel._poller._can_start())
self.assertRaises(socket.timeout,
connection.drain_events, timeout=0.01)
finally:
channel.close()
class QueuePush(object):
def __init__(self, Queue_Server, Queue_Port, Queue_User, Queue_PassWord,
Queue_Path):
self.usr = Queue_User
self.psw = Queue_PassWord
self.server = Queue_Server
self.port = Queue_Port
self.path = Queue_Path
self.connection = None
self.smsExchange = None
def _InitConnect(self):
if self.connection is None or self.connection.connected == False:
self.connection = Connection(hostname=self.server,
port=self.port,
userid=self.usr,
password=self.psw,
virtual_host=self.path)
self.channel = self.connection.channel()
self.producer = Producer(self.channel)
self.smsExchange = Exchange("sys.sms",
type='topic',
channel=self.channel,
durable=True,
delivery_mode=2)
self.smsCodeProduce = Producer(self.channel,
self.smsExchange,
routing_key='sms.code')
def Push(self, queueid, connectid, body):
self.rawPush(queueid, {'connid': connectid}, body)
def Close(self, queueid, connectid):
self.rawPush(queueid, {
'connid': connectid,
'close_connect': '1'
}, 'close')
def rawPush(self, routing_key, headers, body):
self._InitConnect()
self.producer.publish(body=body,
delivery_mode=2,
headers=headers,
routing_key=routing_key,
retry=True,
compression='gzip')
def sendCode(self, phone, code):
self._InitConnect()
json_str = json.dumps(
{
'phone': str(phone),
"content": u"您的莱信验证码为:%s，请在5分钟内输入完成验证。【莱福思】" % str(code)
},
ensure_ascii=False)
self.smsCodeProduce.publish(body=json_str,
retry=True,
compression='gzip')
def test_produce_consume(self):
channel = self.c.channel()
producer = Producer(channel, self.e)
consumer1 = Consumer(channel, self.q)
consumer2 = Consumer(channel, self.q2)
self.q2(channel).declare()
for i in range(10):
producer.publish({"foo": i}, routing_key="test_transport_memory")
for i in range(10):
producer.publish({"foo": i}, routing_key="test_transport_memory2")
_received1 = []
_received2 = []
def callback1(message_data, message):
_received1.append(message)
message.ack()
def callback2(message_data, message):
_received2.append(message)
message.ack()
consumer1.register_callback(callback1)
consumer2.register_callback(callback2)
consumer1.consume()
consumer2.consume()
while 1:
if len(_received1) + len(_received2) == 20:
break
self.c.drain_events()
self.assertEqual(len(_received1) + len(_received2), 20)
# compression
producer.publish({"compressed": True},
routing_key="test_transport_memory",
compression="zlib")
m = self.q(channel).get()
self.assertDictEqual(m.payload, {"compressed": True})
# queue.delete
for i in range(10):
producer.publish({"foo": i}, routing_key="test_transport_memory")
self.assertTrue(self.q(channel).get())
self.q(channel).delete()
self.q(channel).declare()
self.assertIsNone(self.q(channel).get())
# queue.purge
for i in range(10):
producer.publish({"foo": i}, routing_key="test_transport_memory2")
self.assertTrue(self.q2(channel).get())
self.q2(channel).purge()
self.assertIsNone(self.q2(channel).get())
def main():
connection = Connection('amqp://*****:*****@localhost:5672//')
_channel = connection.channel()
_exchange = Exchange('neutron', type='topic')
pro = Producer(channel=_channel,
exchange=_exchange,
routing_key='q-plugin')
pro.publish(MSG)
def publish(self, data, timeout=None):
p = Producer(channel=self.channel,
exchange=Exchange(self.target.exchange_name, type=self.EXCHANGE_TYPE,
durable=self.options['durable'],
auto_delete=self.options['auto_delete']),
routing_key=self.target.routing_key)
if timeout:
p.publish(data, headers={'ttl': (timeout * 1000)})
else:
p.publish(data)
def _publish(self, type, arguments, destination=None, reply_ticket=None, channel=None):
message = {"method": type, "arguments": arguments, "destination": destination}
if reply_ticket:
message["reply_to"] = {"exchange": self.reply_exchange.name, "routing_key": reply_ticket}
chan = channel or self.connection.channel()
producer = Producer(chan, exchange=self.exchange)
try:
producer.publish(message)
finally:
channel or chan.close()
def _publish_reply(self, reply, exchange, routing_key, channel=None):
chan = channel or self.connection.channel()
try:
exchange = Exchange(
exchange, exchange_type="direct", delivery_mode="transient", durable=False, auto_delete=True
)
producer = Producer(chan, exchange=exchange)
producer.publish(reply, routing_key=routing_key)
finally:
channel or chan.close()
def test_publish__get(self):
channel = self.connection.channel()
producer = Producer(channel, self.exchange, routing_key="test_Redis")
self.queue(channel).declare()
producer.publish({"hello": "world"})
self.assertDictEqual(self.queue(channel).get().payload, {"hello": "world"})
self.assertIsNone(self.queue(channel).get())
self.assertIsNone(self.queue(channel).get())
self.assertIsNone(self.queue(channel).get())
def test_purge(self):
channel = self.connection.channel()
producer = Producer(channel, self.exchange, routing_key="test_Redis")
self.queue(channel).declare()
for i in range(10):
producer.publish({"hello": "world-%s" % (i, )})
self.assertEqual(channel._size("test_Redis"), 10)
self.assertEqual(self.queue(channel).purge(), 10)
channel.close()
def test_purge(self):
channel = self.connection.channel()
producer = Producer(channel, self.exchange, routing_key="test_Redis")
self.queue(channel).declare()
for i in range(10):
producer.publish({"hello": "world-%s" % (i, )})
self.assertEqual(channel._size("test_Redis"), 10)
self.assertEqual(self.queue(channel).purge(), 10)
channel.close()
def test_publish__get(self):
channel = self.connection.channel()
producer = Producer(channel, self.exchange, routing_key="test_Redis")
self.queue(channel).declare()
producer.publish({"hello": "world"})
self.assertDictEqual(
self.queue(channel).get().payload, {"hello": "world"})
self.assertIsNone(self.queue(channel).get())
self.assertIsNone(self.queue(channel).get())
self.assertIsNone(self.queue(channel).get())
def _publish_reply(self, reply, exchange, routing_key, channel=None):
chan = channel or self.connection.channel()
try:
exchange = Exchange(exchange, exchange_type="direct",
delivery_mode="transient",
durable=False,
auto_delete=True)
producer = Producer(chan, exchange=exchange,
auto_declare=True)
producer.publish(reply, routing_key=routing_key)
finally:
channel or chan.close()
def producer(self):
self.connection = BrokerConnection(hostname=AMQP_IP, port=AMQP_PORT,
userid=AMQP_USER, password=AMQP_PASSWORD,
virtual_host="/",
transport=AMQP_TRANSPORT)
self.channel = self.connection.channel()
# produce
self.media_exchange = Exchange("media", "direct", durable=True)
producer = Producer(self.channel, exchange=self.media_exchange, serializer="json")
producer.publish({"name": "/tmp/lolcat1.avi", "size": 1301013})
print self.connection.get_transport_cls()
def _publish(self, type, arguments, destination=None, reply_ticket=None,
channel=None):
message = {"method": type,
"arguments": arguments,
"destination": destination}
if reply_ticket:
message["reply_to"] = {"exchange": self.reply_exchange.name,
"routing_key": reply_ticket}
chan = channel or self.connection.channel()
producer = Producer(chan, exchange=self.exchange)
try:
producer.publish(message)
finally:
channel or chan.close()
def test_produce_consume_noack(self):
channel = self.c.channel()
producer = Producer(channel, self.e)
consumer = Consumer(channel, self.q, no_ack=True)
for i in range(10):
producer.publish({"foo": i}, routing_key="test_transport_memory")
_received = []
def callback(message_data, message):
_received.append(message)
consumer.register_callback(callback)
consumer.consume()
while 1:
if len(_received) == 10:
break
self.c.drain_events()
self.assertEqual(len(_received), 10)
def run(self):
amqhost = self.config_parser.get(self.section,'amqhost')
amqport = int(self.config_parser.get(self.section,'amqport'))
amquser = self.config_parser.get(self.section,'amquser')
amqpass = self.config_parser.get(self.section,'amqpass')
amqvhost = self.config_parser.get(self.section,'amqvhost')
amqexchange = self.config_parser.get(self.section,'amqexchange')
routing_key = self.config_parser.get(self.section,'routing_key')
connection = BrokerConnection(hostname=amqhost, port=amqport,
userid=amquser, password=amqpass,
virtual_host=amqvhost)
channel = connection.channel()
exchange = Exchange(amqexchange,'topic',turable=True)
producer = Producer(channel,exchange=exchange,
routing_key=routing_key)
global entire_history
entire_history = self.config_parser.get(self.section,'entire_history')
for job in jobs():
if job['type']=='start':
job['completion_time']+=job['walltime']
producer.revive(channel)
producer.publish(job)
logging.debug(`job`)
def test_publish__consume(self):
connection = Connection(transport=Transport)
channel = connection.channel()
producer = Producer(channel, self.exchange, routing_key='test_Redis')
consumer = Consumer(channel, self.queue)
producer.publish({'hello2': 'world2'})
_received = []
def callback(message_data, message):
_received.append(message_data)
message.ack()
consumer.register_callback(callback)
consumer.consume()
self.assertIn(channel, channel.connection.cycle._channels)
try:
connection.drain_events(timeout=1)
self.assertTrue(_received)
with self.assertRaises(socket.timeout):
connection.drain_events(timeout=0.01)
finally:
channel.close()
def handle(self, *args, **options):
routing_key = options["routing_key"]
connection_url = options["connection_url"]
userid = urlparse(connection_url).username
payload_file = options["payload_file"]
exchange_name = "exchange/{}/jobs".format(userid)
connection = Connection(connection_url)
exchange = Exchange(exchange_name, type="topic")
producer = Producer(connection,
exchange,
routing_key=routing_key,
auto_declare=True)
self.stdout.write("Published to exchange: {}".format(exchange_name))
with open(payload_file) as f:
body = f.read()
try:
producer.publish(body)
finally:
connection.release()
def handle(self, *args, **options):
routing_key = options["routing_key"]
connection_url = options["connection_url"]
userid = urlparse(connection_url).username
payload_file = options["payload_file"]
exchange_name = "exchange/{}/jobs".format(userid)
connection = Connection(connection_url)
exchange = Exchange(exchange_name, type="topic")
producer = Producer(connection,
exchange,
routing_key=routing_key,
auto_declare=True)
self.stdout.write("Published to exchange: {}".format(exchange_name))
with open(payload_file) as f:
body = f.read()
try:
producer.publish(body)
finally:
connection.release()
def test_publish(self):
channel = self.connection.channel()
p = Producer(channel, self.exchange, serializer="json")
message = {u"the quick brown fox": u"jumps over the lazy dog"}
ret = p.publish(message, routing_key="process")
self.assertIn("prepare_message", channel)
self.assertIn("basic_publish", channel)
m, exc, rkey = ret
self.assertDictEqual(message, anyjson.loads(m["body"]))
self.assertDictContainsSubset({"content_type": "application/json",
"content_encoding": "utf-8",
"priority": 0}, m)
self.assertDictContainsSubset({"delivery_mode": 2}, m["properties"])
self.assertEqual(exc, p.exchange.name)
self.assertEqual(rkey, "process")
def test_publish(self):
channel = self.connection.channel()
p = Producer(channel, self.exchange, serializer='json')
message = {u'the quick brown fox': u'jumps over the lazy dog'}
ret = p.publish(message, routing_key='process')
self.assertIn('prepare_message', channel)
self.assertIn('basic_publish', channel)
m, exc, rkey = ret
self.assertDictEqual(message, anyjson.loads(m['body']))
self.assertDictContainsSubset({'content_type': 'application/json',
'content_encoding': 'utf-8',
'priority': 0}, m)
self.assertDictContainsSubset({'delivery_mode': 2}, m['properties'])
self.assertEqual(exc, p.exchange.name)
self.assertEqual(rkey, 'process')
def test_publish(self):
channel = self.connection.channel()
p = Producer(channel, self.exchange, serializer="json")
message = {u"the quick brown fox": u"jumps over the lazy dog"}
ret = p.publish(message, routing_key="process")
self.assertIn("prepare_message", channel)
self.assertIn("basic_publish", channel)
m, exc, rkey = ret
self.assertDictEqual(message, anyjson.loads(m["body"]))
self.assertDictContainsSubset(
{
"content_type": "application/json",
"content_encoding": "utf-8",
"priority": 0
}, m)
self.assertDictContainsSubset({"delivery_mode": 2}, m["properties"])
self.assertEqual(exc, p.exchange.name)
self.assertEqual(rkey, "process")
def run(self):
print 'pypo Pusher'
if self.action == 'update_schedule':
print 'update_schedule!!'
credentials = pika.PlainCredentials(MQ_USER, MQ_PASS)
connection = pika.BlockingConnection(pika.ConnectionParameters(MQ_HOST,
5672,
'/airtime',
credentials))
channel = connection.channel()
channel.queue_declare(queue='pypo-fetch', durable=True)
message = {
'schedule': {
'media': {}
},
'event_type': 'update_schedule'
}
import json
message = json.dumps(message)
message = 'hallo'
channel.basic_publish(exchange='airtime-pypo',
routing_key='pypo-fetch',
body=message)
channel.close()
connection.close()
if self.action == 'update_schedule_kombu':
print 'update_schedule!!'
exchange = Exchange("airtime-pypo", "direct", durable=True, auto_delete=True)
queue = Queue("pypo-fetch", exchange=exchange, key="foo", durable=True)
connection = BrokerConnection(MQ_HOST, MQ_USER, MQ_PASS, MQ_VHOST)
channel = connection.channel()
simple_queue = SimpleQueue(channel, queue)
message = {
'schedule': {
'media': {}
},
'event_type': 'update_schedule'
}
print simple_queue.qsize()
print 'do:'
producer = Producer(channel, exchange=exchange, routing_key=None, serializer="json")
producer.publish(message, routing_key='pypo-fetch')
print simple_queue.qsize()
channel.close()
class UdpService():
def __init__(self):
config = ConfigParser.ConfigParser()
config.read('udpagent.conf')
self.udp_address = config.get('udpservice','udp_address')
self.udp_port = int(config.get('udpservice','udp_port'))
self.rabbit_user = config.get('udpservice','rabbit_userid')
self.rabbit_password = config.get('udpservice','rabbit_password')
self.rabbit_host = config.get('udpservice','rabbit_hosts')
self.acord_control_exchange = config.get('udpservice','acord_control_exchange')
logging.config.fileConfig('udpagent.conf', disable_existing_loggers=False)
def printconfig(self):
logging.debug("udp_address:%s",self.udp_address)
logging.debug("udp_port:%s",self.udp_port)
logging.debug("rabbit_user:%s",self.rabbit_user)
logging.debug("rabbit_password:%s",self.rabbit_password)
logging.debug("rabbit_hosts:%s",self.rabbit_host)
logging.debug("cord_control_exchange:%s",self.acord_control_exchange)
def convert_sample_to_event_data(self,msg):
event_data = {'event_type': 'infra','message_id':six.text_type(uuid.uuid4()),'publisher_id': 'cpe_publisher_id','timestamp':datetime.datetime.now().isoformat(),'priority':'INFO','payload':msg}
return event_data
def setup_rabbit_mq_channel(self):
service_exchange = Exchange(self.acord_control_exchange, "topic", durable=False)
# connections/channels
connection = BrokerConnection(self.rabbit_host, self.rabbit_user, self.rabbit_password)
logging.info("Connection to RabbitMQ server successful")
channel = connection.channel()
# produce
self.producer = Producer(channel, exchange=service_exchange, routing_key='notifications.info')
def start_udp(self):
address_family = socket.AF_INET
if netutils.is_valid_ipv6(self.udp_address):
address_family = socket.AF_INET6
udp = socket.socket(address_family, socket.SOCK_DGRAM)
udp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
udp.bind((self.udp_address,
self.udp_port))
self.setup_rabbit_mq_channel()
self.udp_run = True
while self.udp_run:
# NOTE(jd) Arbitrary limit of 64K because that ought to be
# enough for anybody.
data, source = udp.recvfrom(64 * units.Ki)
try:
sample = msgpack.loads(data, encoding='utf-8')
except Exception:
logging.warning("UDP: Cannot decode data sent by %s", source)
else:
try:
if sample.has_key("event_type"):
logging.debug("recevied event :%s",sample)
self.producer.publish(sample)
else:
logging.debug("recevied Sample :%s",sample)
msg = self.convert_sample_to_event_data(sample)
self.producer.publish(msg)
except Exception:
logging.exception("UDP: Unable to publish msg")
#coding:utf-8
import time
import random
import json
from kombu import Connection
from kombu.messaging import Producer
from kombu import Exchange
connection = Connection(hostname="192.168.10.201",virtual_host='/websocketserver')
channel = connection.channel()
publish_exchange = Producer(channel,routing_key='sys.sendweixin')
publish_exchange.publish(json.dumps({
'weixin_users':['o8Td4joS0bB4fMekczcIoH1id7Qc'],
'body':{
"msgtype":"text",
"text":
{
"content":"完整测试"
}
}
}))
def producer(self):
producer = Producer(self.channel, exchange=self.media_exchange, serializer="json")
#producer.exchange.delete()
producer.publish({"name": "/tmp/lolcat1.avi", "size": 1301013})
pass
__author__ = 'amen'
import time
import random
from kombu import Connection
from kombu.messaging import Producer
from kombu import Exchange
connection = Connection(hostname="192.173.1.213",
virtual_host='/websocketserver')
channel = connection.channel()
exchange = Exchange("sys.apn",
type='topic',
channel=channel,
durable=True,
delivery_mode=2)
publish_exchange = Producer(channel, exchange, routing_key='msg.debug')
while True:
publish_exchange.publish(
"body",
headers={
"message":
"you id code:%d" % random.randint(100, 100000),
"uhid":
"d8009e6c8e074d1bbcb592f321367feaef5674a82fc4cf3b78b066b7c8ad59bd"
})
time.sleep(5)
'''
Created on May 19, 2014
@author: xiaoxubeii
'''
from kombu import Connection
from kombu.messaging import Producer
from entity1 import exchange
#from kombu.transport.base import Message
connection = Connection("amqp://*****:*****@xiaoxubeii")
channel = connection.channel()
#message = Message(channel, body='hi, i am a test')
producer = Producer(channel, exchange=exchange)
producer.publish('hi, i am a test', route_key='test')
'''
Created on May 13, 2014
@author: xiaoxubeii
'''
from kombu import Connection
from kombu.messaging import Producer
from entity import task_exchange
from kombu.transport.base import Message
connection = Connection('amqp://*****:*****@localhost:5672//')
channel = connection.channel()
message = Message(channel, body='Hello Kombu')
# produce
producer = Producer(channel, exchange=task_exchange)
producer.publish(message.body, routing_key='suo_piao')
from kombu.entity import Exchange
from kombu.messaging import Producer
from kombu.connection import Connection
from time import sleep
connection = Connection('amqp://*****:*****@192.168.8.108:5672//')
channel = connection.channel()
_exchange = Exchange('media', 'direct', channel)
producer = Producer(channel, exchange=_exchange, routing_key='video')
for i in range(10):
producer.publish({'name': 'fuckyou.avi', 'size': 13131})
print 'published!'
sleep(1)
def produce_msg():
producer = Producer(channel1, exchange=_exchange, routing_key='c9')
for _ in range(5):
producer.publish({'name': 'xjtu', 'status': 'c9'})
sleep(1)
# send.py
from kombu import Connection
from kombu.messaging import Producer
from entity import task_exchange
from kombu.transport.base import Message
connection = Connection('amqp://*****:*****@10.120.120.11:5672//')
channel = connection.channel()
message=Message(channel,body='Hello Kombu')
# produce
producer = Producer(channel,exchange=task_exchange)
producer.publish(message.body,routing_key='suo_piao')
import ipdb; ipdb.set_trace() ### XXX BREAKPOINT
def send_message(msg):
exchange = Exchange(name=exchange_name, type='topic',
exclusive=False, durable=False, auto_delete=False)
p = Producer(conn.channel(), exchange, routing_key=routing_key)
p.publish(msg)
import json
__author__ = 'amen'
import time
import random
from kombu import Connection
from kombu.messaging import Producer
from kombu import Exchange
connection = Connection(hostname="192.173.1.213",virtual_host='/websocketserver')
channel = connection.channel()
exchange=Exchange("sys.sms",type='topic',channel=channel,durable=True,delivery_mode=2)
publish_exchange = Producer(channel,exchange,routing_key='sms.code')
while True:
publish_exchange.publish(json.dumps({'content':"code %d"%random.randint(100,500),'phone':"15034445667"}))
time.sleep(5)
def produce_msg_image(channel, image_name, image, queue_name):
private_exchange = Exchange(queue_name, "direct", durable=True)
producer = Producer(channel, exchange=private_exchange, serializer="pickle")
producer.publish(document, routing_key=queue_name)
logger.debug("message produced")
class EventDispatcher(object):
"""Send events as messages.
:param connection: Connection to the broker.
:keyword hostname: Hostname to identify ourselves as,
by default uses the hostname returned by :func:`socket.gethostname`.
:keyword enabled: Set to :const:`False` to not actually publish any events,
making :meth:`send` a noop operation.
:keyword channel: Can be used instead of `connection` to specify
an exact channel to use when sending events.
:keyword buffer_while_offline: If enabled events will be buffered
while the connection is down. :meth:`flush` must be called
as soon as the connection is re-established.
You need to :meth:`close` this after use.
"""
def __init__(self, connection=None, hostname=None, enabled=True,
channel=None, buffer_while_offline=True, app=None):
self.app = app_or_default(app)
self.connection = connection
self.channel = channel
self.hostname = hostname or socket.gethostname()
self.enabled = enabled
self.buffer_while_offline = buffer_while_offline
self._lock = threading.Lock()
self.publisher = None
self._outbound_buffer = deque()
if self.enabled:
self.enable()
def enable(self):
conf = self.app.conf
self.enabled = True
channel = self.channel or self.connection.channel()
self.publisher = Producer(channel,
exchange=event_exchange,
serializer=conf.CELERY_EVENT_SERIALIZER)
def disable(self):
self.enabled = False
if self.publisher is not None:
if not self.channel: # close auto channel.
self.publisher.channel.close()
self.publisher = None
def send(self, type, **fields):
"""Send event.
:param type: Kind of event.
:keyword \*\*fields: Event arguments.
"""
if not self.enabled:
return
self._lock.acquire()
event = Event(type, hostname=self.hostname, **fields)
try:
try:
self.publisher.publish(event,
routing_key=type.replace("-", "."))
except Exception, exc:
if not self.buffer_while_offline:
raise
self._outbound_buffer.append((type, fields, exc))
finally:
self._lock.release()
def flush(self):
while self._outbound_buffer:
type, fields, _ = self._outbound_buffer.popleft()
self.send(type, **fields)
def close(self):
"""Close the event dispatcher."""
self._lock.locked() and self._lock.release()
self.publisher and self.publisher.channel.close()
with Connection(
'amqp://*****:*****@10.46.0.39:5672/rapid_alpha_dev') as connection:
with connection.channel() as channel:
for i in range(1, 10):
science_news = Queue(
name='kombu_queue',
exchange=Exchange('kombu_queue', type='direct'),
routing_key='kombu_queue',
channel=channel,
durable=False,
)
science_news.declare()
producer = Producer(channel,
serializer='json',
routing_key='kombu_queue')
producer.publish({'name': 'kombu_queue', 'size': i})
science_news = Queue(
name='kombu_queue_1',
exchange=Exchange('kombu_queue_1', type='direct'),
routing_key='kombu_queue_1',
channel=channel,
max_priority=10, # 优先级
durable=False,
)
science_news.declare()
producer = Producer(channel,
serializer='json',
routing_key='kombu_queue_1')
producer.publish({'name': 'kombu_queue_1', 'size': i}, priority=i)
class EventDispatcher(object):
"""Send events as messages.
:param connection: Connection to the broker.
:keyword hostname: Hostname to identify ourselves as,
by default uses the hostname returned by :func:`socket.gethostname`.
:keyword enabled: Set to :const:`False` to not actually publish any events,
making :meth:`send` a noop operation.
:keyword channel: Can be used instead of `connection` to specify
an exact channel to use when sending events.
:keyword buffer_while_offline: If enabled events will be buffered
while the connection is down. :meth:`flush` must be called
as soon as the connection is re-established.
You need to :meth:`close` this after use.
"""
def __init__(self,
connection=None,
hostname=None,
enabled=True,
channel=None,
buffer_while_offline=True,
app=None):
self.app = app_or_default(app)
self.connection = connection
self.channel = channel
self.hostname = hostname or socket.gethostname()
self.enabled = enabled
self.buffer_while_offline = buffer_while_offline
self._lock = threading.Lock()
self.publisher = None
self._outbound_buffer = deque()
if self.enabled:
self.enable()
def enable(self):
conf = self.app.conf
self.enabled = True
channel = self.channel or self.connection.channel()
self.publisher = Producer(channel,
exchange=event_exchange,
serializer=conf.CELERY_EVENT_SERIALIZER)
def disable(self):
self.enabled = False
if self.publisher is not None:
if not self.channel: # close auto channel.
self.publisher.channel.close()
self.publisher = None
def send(self, type, **fields):
"""Send event.
:param type: Kind of event.
:keyword \*\*fields: Event arguments.
"""
if not self.enabled:
return
self._lock.acquire()
event = Event(type, hostname=self.hostname, **fields)
try:
try:
self.publisher.publish(event,
routing_key=type.replace("-", "."))
except Exception, exc:
if not self.buffer_while_offline:
raise
self._outbound_buffer.append((type, fields, exc))
finally:
self._lock.release()
def flush(self):
while self._outbound_buffer:
type, fields, _ = self._outbound_buffer.popleft()
self.send(type, **fields)
def copy_buffer(self, other):
self._outbound_buffer = other._outbound_buffer
def close(self):
"""Close the event dispatcher."""
self._lock.locked() and self._lock.release()
self.publisher and self.publisher.channel.close()
from kombu import Connection
from kombu.messaging import Producer
from kombu.transport.base import Message
from kombu_queues import task_exchange
from kombu_tasks import echo_task
rabbitmq_url = 'amqp://*****:*****@localhost:5672//'
message_num = 400
if __name__ == '__main__':
connection = Connection(rabbitmq_url)
channel = connection.channel()
body_json = {'url': 'http://127.0.0.1',
'delay': 5}
message_json = Message(channel, body=body_json)
body_pickle = {'func': echo_task,
'args': ('Hello Rabbit', 5),
'kwargs': {}}
message_pickle = Message(channel, body=body_pickle)
producer_json = Producer(channel, exchange=task_exchange)
producer_pickle = Producer(channel, exchange=task_exchange, serializer='pickle')
for i in xrange(message_num):
producer_json.publish(message_json.body, routing_key='json_queue')
producer_pickle.publish(message_pickle.body, routing_key='pickle_queue')
class EventDispatcher(object):
"""Send events as messages.
:param connection: Connection to the broker.
:keyword hostname: Hostname to identify ourselves as,
by default uses the hostname returned by :func:`socket.gethostname`.
:keyword enabled: Set to :const:`False` to not actually publish any events,
making :meth:`send` a noop operation.
:keyword channel: Can be used instead of `connection` to specify
an exact channel to use when sending events.
:keyword buffer_while_offline: If enabled events will be buffered
while the connection is down. :meth:`flush` must be called
as soon as the connection is re-established.
You need to :meth:`close` this after use.
"""
def __init__(self,
connection=None,
hostname=None,
enabled=True,
channel=None,
buffer_while_offline=True,
app=None,
serializer=None):
self.app = app_or_default(app)
self.connection = connection
self.channel = channel
self.hostname = hostname or socket.gethostname()
self.buffer_while_offline = buffer_while_offline
self.mutex = threading.Lock()
self.publisher = None
self._outbound_buffer = deque()
self.serializer = serializer or self.app.conf.CELERY_EVENT_SERIALIZER
self.on_enabled = set()
self.on_disabled = set()
self.enabled = enabled
if self.enabled:
self.enable()
def __enter__(self):
return self
def __exit__(self, *exc_info):
self.close()
def enable(self):
self.publisher = Producer(self.channel or self.connection.channel(),
exchange=event_exchange,
serializer=self.serializer)
self.enabled = True
for callback in self.on_enabled:
callback()
def disable(self):
if self.enabled:
self.enabled = False
self.close()
for callback in self.on_disabled:
callback()
def send(self, type, **fields):
"""Send event.
:param type: Kind of event.
:keyword \*\*fields: Event arguments.
"""
if self.enabled:
with self.mutex:
event = Event(type,
hostname=self.hostname,
clock=self.app.clock.forward(),
**fields)
try:
self.publisher.publish(event,
routing_key=type.replace("-", "."))
except Exception, exc:
if not self.buffer_while_offline:
raise
self._outbound_buffer.append((type, fields, exc))
def queue_publish(self, routing_key,
exchange_name, exchange_type='topic', body=None):
exchange = Exchange(name=exchange_name, type=exchange_type,
exclusive=False, durable=False, auto_delete=False)
p = Producer(self._channel(), exchange, routing_key=routing_key)
return p.publish(body)
self.consumer.consume()
def mq_callback(message_data, message):
print("%s: %r: %r" % (key, message.delivery_info, message_data,))
#message.ack()
self.consumer.register_callback(mq_callback)
c1 = AConsumer("test_1","test.1")
c2 = AConsumer("testing","test.ing")
# consumers can use simple pattern matching when defining a queue
c3 = AConsumer("test_all","test.*")
# 3. publish something to consume
# publishers always send to a specific route, the mq will route to the queues
producer = Producer(pub_chan, exchange=pub_exch, serializer=message_serializer)
producer.publish({"name": "Shane Caraveo", "username": "******"}, routing_key="test.1")
producer.publish({"name": "Micky Mouse", "username": "******"}, routing_key="test.ing")
producer.publish({"name": "Anonymous", "username": "******"}, routing_key="test.foobar")
def have_messages():
return sum([q.qsize() for q in cons_chan.queues.values()])
# 5. run the event loop
while have_messages():
try:
cons_conn.drain_events()
except KeyboardInterrupt:
print
print "quitting"
break
except Exception, e:
__author__ = 'amen'
import time
import random
from kombu import Connection
from kombu.messaging import Producer
from kombu import Exchange
connection = Connection(hostname="192.173.1.213",virtual_host='/testDemo')
channel = connection.channel()
exchange=Exchange("exchange1",type='topic',channel=channel,durable=True,delivery_mode=2)
publish_exchange = Producer(channel,exchange,routing_key='all')
while True:
publish_exchange.publish("body",headers={"message":"you id code:%d"%random.randint(100,100000),
"uhid":"d8009e6c8e074d1bbcb592f321367feaef5674a82fc4cf3b78b066b7c8ad59bd","badge":5})
time.sleep(5)
class EventDispatcher(object):
"""Send events as messages.
:param connection: Connection to the broker.
:keyword hostname: Hostname to identify ourselves as,
by default uses the hostname returned by :func:`socket.gethostname`.
:keyword enabled: Set to :const:`False` to not actually publish any events,
making :meth:`send` a noop operation.
:keyword channel: Can be used instead of `connection` to specify
an exact channel to use when sending events.
:keyword buffer_while_offline: If enabled events will be buffered
while the connection is down. :meth:`flush` must be called
as soon as the connection is re-established.
You need to :meth:`close` this after use.
"""
def __init__(self, connection=None, hostname=None, enabled=True,
channel=None, buffer_while_offline=True, app=None,
serializer=None):
self.app = app_or_default(app)
self.connection = connection
self.channel = channel
self.hostname = hostname or socket.gethostname()
self.buffer_while_offline = buffer_while_offline
self.mutex = threading.Lock()
self.publisher = None
self._outbound_buffer = deque()
self.serializer = serializer or self.app.conf.CELERY_EVENT_SERIALIZER
self.on_enabled = set()
self.on_disabled = set()
self.enabled = enabled
if not connection and channel:
self.connection = channel.connection.client
if self.enabled:
self.enable()
def __enter__(self):
return self
def __exit__(self, *exc_info):
self.close()
def get_exchange(self):
if self.connection:
return get_exchange(self.connection)
else:
return get_exchange(self.channel.connection.client)
def enable(self):
self.publisher = Producer(self.channel or self.connection,
exchange=self.get_exchange(),
serializer=self.serializer)
self.enabled = True
for callback in self.on_enabled:
callback()
def disable(self):
if self.enabled:
self.enabled = False
self.close()
for callback in self.on_disabled:
callback()
def send(self, type, **fields):
"""Send event.
:param type: Kind of event.
:keyword \*\*fields: Event arguments.
"""
if self.enabled:
with self.mutex:
event = Event(type, hostname=self.hostname,
clock=self.app.clock.forward(), **fields)
try:
self.publisher.publish(event,
routing_key=type.replace("-", "."))
except Exception, exc:
if not self.buffer_while_offline:
raise
self._outbound_buffer.append((type, fields, exc))
from kombu.messaging import Producer
from kombu.transport.base import Message
from kombu_queues import task_exchange
from kombu_tasks import echo_task
rabbitmq_url = 'amqp://*****:*****@localhost:5672//'
message_num = 400
if __name__ == '__main__':
connection = Connection(rabbitmq_url)
channel = connection.channel()
body_json = {'url': 'http://127.0.0.1', 'delay': 5}
message_json = Message(channel, body=body_json)
body_pickle = {
'func': echo_task,
'args': ('Hello Rabbit', 5),
'kwargs': {}
}
message_pickle = Message(channel, body=body_pickle)
producer_json = Producer(channel, exchange=task_exchange)
producer_pickle = Producer(channel,
exchange=task_exchange,
serializer='pickle')
for i in xrange(message_num):
producer_json.publish(message_json.body, routing_key='json_queue')
producer_pickle.publish(message_pickle.body,
routing_key='pickle_queue')
