def test_hash(self):
self.assertEqual(hash(Exchange('a')), hash(Exchange('a')))
self.assertNotEqual(hash(Exchange('a')), hash(Exchange('b')))
def test_set_persistent_delivery_mode(self):
exc = Exchange("foo", "direct", delivery_mode="persistent")
self.assertEqual(exc.delivery_mode, Exchange.PERSISTENT_DELIVERY_MODE)
def test_create_message(self):
chan = get_conn().channel()
Exchange("foo", channel=chan).Message({"foo": "bar"})
self.assertIn("prepare_message", chan)
def setUp(self):
self.exchange = Exchange("foo", "direct")
def test_can_cache_declaration(self):
self.assertTrue(Exchange("a", durable=True).can_cache_declaration)
self.assertFalse(Exchange("a", durable=False).can_cache_declaration)
def setUp(self):
self.connection = BrokerConnection(transport=Transport)
self.connection.connect()
self.assertTrue(self.connection.connection.connected)
self.exchange = Exchange("foo", "direct")
# CELERYD_POOL_RESTARTS = True
# CELERY_ALWAYS_EAGER=False
CELERYD_LOG_LEVEL = "INFO"
#CELERY_REDIRECT_STDOUTS_LEVEL="DEBUG"
CELERYD_CONCURRENCY = 8
# CELERY_IGNORE_RESULT
# CELERY_TRACK_STARTED =True
#
CELERY_SEND_TASK_SENT_EVENT = True
CELERY_SEND_EVENTS = True
CELERY_RESULT_BACKEND = 'rpc'
# CELERY_ACCEPT_CONTENT = ['json']
# CELERY_TASK_SERIALIZER = 'json'
# CELERY_RESULT_SERIALIZER = 'json'
# from kombu import serialization
# serialization.registry._decoders.pop("application/x-python-serialize")
CELERY_IGNORE_RESULT = False # this is less important
CELERY_QUEUES = (Queue('celery', Exchange('celery'), routing_key='celery'), )
#
#
#
# #
# # CELERY_QUEUES = ( Queue('default', Exchange('default'), routing_key='default'),
# # )
# of such consortium member educational agencies.
'''
Created on Mar 27, 2014
@author: tosako
'''
from edmigrate.utils.utils import Singleton, get_broker_url
from edmigrate.tasks.player import Player
from kombu import Connection
from edmigrate.queues import conductor
from edmigrate.utils.constants import Constants
from edmigrate.utils import reply_to_conductor
import unittest
from kombu.entity import Exchange, Queue
exchange = Exchange('test', type='direct')
queue = Queue('test',
exchange=exchange,
routing_key='test.test',
durable=False)
class Unittest_with_player(unittest.TestCase):
@classmethod
def setUpClass(cls):
mock = MockPlayer()
Player._instances[Player] = mock
@classmethod
def tearDownClass(cls):
Player._instances.clear()
# @Email : [email protected] # @File : producer02.py # @Software: PyCharm import time from kombu.entity import Exchange, Queue from kombu.messaging import Producer from kombu.connection import Connection 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,
def test_publish(self):
chan = get_conn().channel()
Exchange('foo', channel=chan).publish('the quick brown fox')
self.assertIn('basic_publish', chan)
def test_delete(self):
chan = get_conn().channel()
Exchange('foo', channel=chan).delete()
self.assertIn('exchange_delete', chan)
def test_create_message(self):
chan = get_conn().channel()
Exchange('foo', channel=chan).Message({'foo': 'bar'})
self.assertIn('prepare_message', chan)
def test_set_persistent_delivery_mode(self):
exc = Exchange('foo', 'direct', delivery_mode='persistent')
self.assertEqual(exc.delivery_mode, Exchange.PERSISTENT_DELIVERY_MODE)
def test_set_transient_delivery_mode(self):
exc = Exchange('foo', 'direct', delivery_mode='transient')
self.assertEqual(exc.delivery_mode, Exchange.TRANSIENT_DELIVERY_MODE)
def initialize(self):
super(ActionTask, self).initialize()
self.exchange = Exchange('xaction', type='direct')
self._inner_logger = ProxyLogger(self.logger)
def delete_queue(name):
exchange = Exchange('agent', type='topic')
queue = Queue(name, exchange=exchange, routing_key='news')
q = queue(channel)
q.delete(nowait=True)
def test_publish_with_Exchange_instance(self):
p = self.connection.Producer()
p.exchange.publish = Mock()
p.publish("hello", exchange=Exchange("foo"))
self.assertEqual(p.exchange.publish.call_args[0][4], "foo")
def _get_reply_exchange(self, namespace):
return Exchange(self.reply_exchange_fmt % namespace,
type="direct",
durable=False,
auto_delete=True,
delivery_mode="transient")
# tasks.add will go with the queue: tasks_queue for both producer and consumer
CELERY_ROUTES = {
'tasks.add': {
'queue': 'tasks_queue',
'routing_key': 'tasks_routing'
},
'tasks.mul': {
'queue': 'tasks_queue',
'routing_key': 'tasks_routing'
},
#'tasks.add_1': {'queue': 'tasks_queue', 'routing_key': 'tasks_routing_1'},
#'tasks.add_2': {'queue': 'tasks_queue_2', 'routing_key': 'tasks_routing_2'},
}
# define exchanges explicitly, change type here requires reset queue/exchange: 'celery amqp queue.delete tasks_queue' and 'celery amqp exchange.delete tasks_exchange'
tasks_exchange = Exchange('tasks_exchange',
type='direct') # fanout/direct/topic
# For tasks.py to listen the queue: tasks_queue
CELERY_QUEUES = (
Queue('tasks_queue', tasks_exchange, routing_key='tasks_routing'),
# Queue('tasks_queue', tasks_exchange, routing_key='tasks_routing_1'),
# Queue('tasks_queue_2', tasks_exchange, routing_key='tasks_routing_2'),
# routing_key could be 'tasks.#', '*.tasks.*' if exchange type is 'topic'
)
# acknowledged after the task has been executed, False by default
CELERY_ACKS_LATE = True
# The worker will reserve at most one extra task for every active worker process.
# CELERYD_PREFETCH_MULTIPLIER = 1
#
def setUp(self):
self.connection = BrokerConnection(transport=Transport)
self.exchange = Exchange("test_Redis", type="direct")
self.queue = Queue("test_Redis", self.exchange, "test_Redis")
def test__repr__(self):
b = Exchange("foo", "topic")
self.assertIn("foo(topic)", repr(b))
self.assertIn("Exchange", repr(b))
# -*- encoding: utf-8 -*-
'''
Created on 2016年9月9日
@author: huawei
'''
from celery.app.base import Celery
from kombu.entity import Exchange,Queue
test ="amqp://*****:*****@172.16.4.134:5672/cabbage_vhost"
app = Celery('cabbage',backend="rpc://",broker=test)
CELERY_QUEUES = ( Queue('mac', Exchange('mac'), routing_key='mac'),)
#
#
CELERY_ROUTES ={ u'test_both_task.TestBoth': {'queue': 'both', 'routing_key': 'both'}, u'test_mac_task.TestMacTask': {'queue': 'mac', 'routing_key': 'mac'}, u'test_ubuntu_task.TestUbuntuTask': {'queue': 'ubuntu', 'routing_key': 'ubuntu'}}
#
app.conf.update(CELERY_QUEUES=CELERY_QUEUES)
app.conf.update(CELERY_ROUTES=CELERY_ROUTES)
app.conf.update(CELERY_SEND_TASK_SENT_EVENT=True,CELERY_SEND_EVENTS=True)
def my_monitor(app):
state = app.events.State()
def announce_failed_tasks(event):
print "monitor"
# print state.alive_workers()
state.event(event)
# task name is sent only with -received event, and state
# will keep track of this for us.
if 'uuid' in event:
def test_hash(self):
self.assertEqual(hash(Exchange("a")), hash(Exchange("a")))
self.assertNotEqual(hash(Exchange("a")), hash(Exchange("b")))
# -*- coding: utf-8 -*-
"""Worker name utilities."""
from __future__ import absolute_import, unicode_literals
import os
import socket
from functools import partial
from kombu.entity import Exchange, Queue
from .functional import memoize
from .text import simple_format
#: Exchange for worker direct queues.
WORKER_DIRECT_EXCHANGE = Exchange('C.dq2')
#: Format for worker direct queue names.
WORKER_DIRECT_QUEUE_FORMAT = '{hostname}.dq2'
#: Separator for worker node name and hostname.
NODENAME_SEP = '@'
NODENAME_DEFAULT = 'celery'
gethostname = memoize(1, Cache=dict)(socket.gethostname)
__all__ = [
'worker_direct',
'gethostname',
'nodename',
'anon_nodename',
'nodesplit',
'default_nodename',
'node_format',
def test_set_transient_delivery_mode(self):
exc = Exchange("foo", "direct", delivery_mode="transient")
self.assertEqual(exc.delivery_mode, Exchange.TRANSIENT_DELIVERY_MODE)
import time
import socket
import threading
from collections import deque
from contextlib import contextmanager
from itertools import count
from kombu.entity import Exchange, Queue
from kombu.messaging import Consumer, Producer
from ..app import app_or_default
from ..utils import uuid
event_exchange = Exchange("celeryev", type="topic")
def Event(type, _fields=None, **fields):
"""Create an event.
An event is a dictionary, the only required field is ``type``.
"""
event = dict(_fields or {}, type=type, **fields)
if "timestamp" not in event:
event["timestamp"] = time.time()
return event
class EventDispatcher(object):
def test_bind_at_instantiation(self):
self.assertTrue(Exchange("foo", channel=get_conn().channel()).is_bound)
def test_delete(self):
chan = get_conn().channel()
Exchange("foo", channel=chan).delete()
self.assertIn("exchange_delete", chan)
def test_publish(self):
chan = get_conn().channel()
Exchange("foo", channel=chan).publish("the quick brown fox")
self.assertIn("basic_publish", chan)
def setUp(self):
self.exchange = Exchange('foo', 'direct')
