Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

2819 lines (1882 sloc) 95.018 kB
================
Change history
================
.. contents::
:local:
2.1.0
=====
:release-date: TBA
:status: In development.
:roadmap: http://wiki.github.com/ask/celery/roadmap
Important notes
---------------
* Celery is now following the versioning semantics defined by `semver`_.
This means we are no longer allowed to use odd/even versioning semantics
(see http://github.com/mojombo/semver.org/issues#issue/8).
By our previous versioning scheme this stable release should have
been version 2.2.
The document describing our release cycle and versioning scheme
can be found at `Wiki: Release Cycle`_.
.. _`semver`: http://semver.org
.. _`Wiki: Release Cycle`: http://wiki.github.com/ask/celery/release-cycle.
News
----
* celeryev: Event Snapshots
If enabled, celeryd can send messages every time something
happens in the worker. These messages are called "events".
The events are used by real-time monitors to show what the
cluster is doing, but they are not very useful for monitoring
over time. That's where the snapshots comes in. Snapshots
lets you take "pictures" of the clusters state at regular intervals.
These can then be stored in the database to generate statistics
with, or even monitoring.
Django-celery now comes with a Celery monitor for the Django
Admin interface. To use this you need to run the django-celery
snapshot camera, which stores snapshots to the database at configurable
intervals.
To use the Django admin monitor you need to do the following:
1. Create the new database tables.
$ python manage.py syncdb
2. Start the django-celery snapshot camera::
$ python manage.py celerycam
3. Open up the django admin to monitor your cluster.
The admin interface shows tasks, worker nodes, and even
lets you perform some actions, like revoking and rate limiting tasks,
and shutting down worker nodes.
There's also a Debian init.d script for ``celeryev`` available,
see :doc:`cookbook/daemonizing` for more information.
New command line argments to celeryev:
* ``-c|--camera``: Snapshot camera class to use.
* ``--logfile|-f``: Logfile
* ``--loglevel|-l``: Loglevel
* ``--maxrate|-r``: Shutter rate limit.
* ``--freq|-F``: Shutter frequency
The ``--camera`` argument is the name of a class used to take
snapshots with. It must support the interface defined by
:class:`celery.events.snapshot.Polaroid`.
Shutter frequency controls how often the camera thread wakes up,
while the rate limit controls how often it will actually take
a snapshot.
The rate limit can be an integer (snapshots/s), or a rate limit string
which has the same syntax as the task rate limit strings (``"200/m"``,
``"10/s"``, ``"1/h",`` etc).
For the Django camera case, this rate limit can be used to control
how often the snapshots are written to the database, and the frequency
used to control how often the thread wakes up too check if there's
anything new.
The rate limit is off by default, which means it will take a snapshot
for every ``--frequency`` seconds.
The django-celery camera also automatically deletes old events.
It deletes successful tasks after 1 day, failed tasks after 3 days,
and tasks in other states after 5 days.
* Added the ability to set an expiry date and time for tasks.
Example::
>>> # Task expires after one minute from now.
>>> task.apply_async(args, kwargs, expires=60)
>>> # Also supports datetime
>>> task.apply_async(args, kwargs,
... expires=datetime.now() + timedelta(days=1)
When a worker receives a task that has been expired it will mark
the task as revoked (:exc:`celery.exceptions.TaskRevokedError`).
* Changed the way logging is configured.
We now configure the root logger instead of only configuring
our custom logger. In addition we don't hijack
the multiprocessing logger anymore, but instead use a custom logger name
(celeryd uses "celery", celerybeat uses "celery.beat", celeryev uses
"celery.ev").
This means that the ``loglevel`` and ``logfile`` arguments will
affect all registered loggers (even those from 3rd party libraries).
That is unless you configure the loggers manually as show below.
Users can choose to configure logging by subscribing to the
:data:`~celery.signals.setup_logging` signal:
.. code-block:: python
from logging.config import fileConfig
from celery import signals
def setup_logging(**kwargs):
fileConfig("logging.conf")
signals.setup_logging.connect(setup_logging)
If there are no receivers for this signal, the logging subsystem
will be configured using the ``--loglevel/--logfile argument``,
this will be used for *all defined loggers*.
Remember that celeryd also redirects stdout and stderr
to the celery logger, if you want to manually configure logging
ands redirect stdouts, you need to enable this manually:
.. code-block:: python
from logging.config import fileConfig
from celery import log
def setup_logging(**kwargs):
import logging
fileConfig("logging.conf")
stdouts = logging.getLogger("mystdoutslogger")
log.redirect_stdouts_to_logger(stdouts, loglevel=logging.WARNING)
* celeryd: Task results shown in logs are now truncated to 46 chars.
* ``Task.__name__`` is now an alias to ``self.__class__.__name__``.
This way it introspects more like a regular function.
* ``Task.retry``: Now raises :exc:`TypeError` if kwargs argument is empty.
See http://github.com/ask/celery/issues/issue/164
* timedelta_seconds: Use ``timedelta.total_seconds`` if running on Python 2.7
* :class:`~celery.datastructures.TokenBucket`: Generic Token Bucket algorithm
* :class:`celery.events.state.State`: Recording of cluster state can now
be paused.
* ``State.freeze(buffer=True)``
Pauses recording of the stream. If buffer is true, then events received
while being frozen will be kept, so it can be replayed later.
* ``State.thaw(replay=True)``
Resumes recording of the stream. If replay is true, then the buffer
will be applied.
* ``State.freeze_while(fun)``
Apply function. Freezes the stream before the function,
and replays the buffer when the function returns.
* :meth:`EventReceiver.capture <celery.events.EventReceiver.capture>`
Now supports a timeout keyword argument.
Fixes
-----
* Compat ``LoggerAdapter`` implementation: Now works for Python 2.4.
Also added support for several new methods:
``fatal``, ``makeRecord``, ``_log``, ``log``, ``isEnabledFor``,
``addHandler``, ``removeHandler``.
Documentation
-------------
* tutorials/external moved to new section: "community"
2.0.3
=====
:release-date: 2010-08-27 12:00 P.M CEST
Fixes
-----
* celeryd: Properly handle connection errors happening while
closing consumers.
* celeryd: Events are now buffered if the connection is down,
then sent when the connection is re-established.
* No longer depends on the ``mailer`` package.
This package had a namespace collision with ``django-mailer``,
so its functionality was replaced.
* Redis result backend: Documentation typos: Redis doesn't have
database names, but database numbers. The default database is now 0.
* :class:`~celery.task.control.inspect`:
``registered_tasks`` was requesting an invalid command because of a typo.
See http://github.com/ask/celery/issues/issue/170
* ``CELERY_ROUTES``: Values defined in the route should now have precedence
over values defined in ``CELERY_QUEUES`` when merging the two.
With the follow settings::
CELERY_QUEUES = {"cpubound": {"exchange": "cpubound",
"routing_key": "cpubound"}}
CELERY_ROUTES = {"tasks.add": {"queue": "cpubound",
"routing_key": "tasks.add",
"serializer": "json"}}
The final routing options for ``tasks.add`` will become::
{"exchange": "cpubound",
"routing_key": "tasks.add",
"serializer": "json"}
This was not the case before: the values
in ``CELERY_QUEUES`` would take precedence.
* Worker crashed if the value of ``CELERY_TASK_ERROR_WHITELIST`` was
not an iterable
* :func:`~celery.execute.apply`: Make sure ``kwargs["task_id"]`` is
always set.
* ``AsyncResult.traceback``: Now returns ``None``, instead of raising
:exc:`KeyError` if traceback is missing.
* :class:`~celery.task.control.inspect`: Replies did not work correctly
if no destination was specified.
* Can now store result/metadata for custom states.
* celeryd: A warning is now emitted if the sending of task error
e-mails fails.
* celeryev: Curses monitor no longer crashes if the terminal window
is resized.
See http://github.com/ask/celery/issues/issue/160
* celeryd: On OS X it is not possible to run ``os.exec*`` in a process
that is threaded.
This breaks the SIGHUP restart handler,
and is now disabled on OS X, emitting a warning instead.
See http://github.com/ask/celery/issues/issue/152
* :mod:`celery.execute.trace`: Properly handle ``raise(str)``,
which is still allowed in Python 2.4.
See http://github.com/ask/celery/issues/issue/175
* Using urllib2 in a periodic task on OS X crashed because
of the proxy autodetection used in OS X.
This is now fixed by using a workaround.
See http://github.com/ask/celery/issues/issue/143
* Debian init scripts: Commands should not run in a subshell
See http://github.com/ask/celery/issues/issue/163
* Debian init scripts: Use abspath for celeryd to allow stat
See http://github.com/ask/celery/issues/issue/162
Documentation
-------------
* getting-started/broker-installation: Fixed typo
``set_permissions ""`` -> ``set_permissions ".*"``.
* Tasks Userguide: Added section on database transactions.
See http://github.com/ask/celery/issues/issue/169
* Routing Userguide: Fixed typo ``"feed": -> {"queue": "feeds"}``.
See http://github.com/ask/celery/issues/issue/169
* Documented the default values for the ``CELERYD_CONCURRENCY``
and ``CELERYD_PREFETCH_MULTIPLIER`` settings.
* Tasks Userguide: Fixed typos in the subtask example
* celery.signals: Documented worker_process_init.
* Daemonization cookbook: Need to export DJANGO_SETTINGS_MODULE in
``/etc/default/celeryd``.
* Added some more FAQs from stack overflow
* Daemonization cookbook: Fixed typo ``CELERYD_LOGFILE/CELERYD_PIDFILE``
to ``CELERYD_LOG_FILE`` / ``CELERYD_PID_FILE``
Also added troubleshooting section for the init scripts.
2.0.2
=====
:release-date: 2010-07-22 11:31 A.M CEST
* Routes: When using the dict route syntax, the exchange for a task
could dissapear making the task unroutable.
See http://github.com/ask/celery/issues/issue/158
* Test suite now passing on Python 2.4
* No longer have to type PYTHONPATH=. to use celeryconfig in current dir.
This is accomplished by the default loader ensuring that the current
directory is in ``sys.path`` when loading the config module.
``sys.path`` is reset to its original state after loading.
Adding cwd to ``sys.path`` without the user knowing may be a security
issue, as this means someone can drop a Python module in the users
directory that executes arbitrary commands. This was the original reason
not to do this, but if done *only when loading the config module*, this
means that the behvavior will only apply to the modules imported in the
config module, which I think is a good compromise (certainly better than
just explictly setting PYTHONPATH=. anyway)
* Experimental Cassandra backend added.
* celeryd: SIGHUP handler accidentally propagated to worker pool processes.
In combination with 7a7c44e39344789f11b5346e9cc8340f5fe4846c
this would make each child process start a new celeryd when
the terminal window was closed :/
* celeryd: Do not install SIGHUP handler if running from a terminal.
This fixes the problem where celeryd is launched in the background
when closing the terminal.
* celeryd: Now joins threads at shutdown.
See http://github.com/ask/celery/issues/issue/152
* Test teardown: Don't use atexit but nose's ``teardown()`` functionality
instead.
See http://github.com/ask/celery/issues/issue/154
* Debian init script for celeryd: Stop now works correctly.
* Task logger: ``warn`` method added (synonym for ``warning``)
* Can now define a whitelist of errors to send error e-mails for.
Example::
CELERY_TASK_ERROR_WHITELIST = ('myapp.MalformedInputError')
See http://github.com/ask/celery/issues/issue/153
* celeryd: Now handles overflow exceptions in ``time.mktime`` while parsing
the ETA field.
* LoggerWrapper: Try to detect loggers logging back to stderr/stdout making
an infinite loop.
* Added :class:`celery.task.control.inspect`: Inspects a running worker.
Examples::
# Inspect a single worker
>>> i = inspect("myworker.example.com")
# Inspect several workers
>>> i = inspect(["myworker.example.com", "myworker2.example.com"])
# Inspect all workers consuming on this vhost.
>>> i = inspect()
### Methods
# Get currently executing tasks
>>> i.active()
# Get currently reserved tasks
>>> i.reserved()
# Get the current eta schedule
>>> i.scheduled()
# Worker statistics and info
>>> i.stats()
# List of currently revoked tasks
>>> i.revoked()
# List of registered tasks
>>> i.registered_tasks()
* Remote control commands ``dump_active``/``dump_reserved``/``dump_schedule``
now replies with detailed task requests.
Containing the original arguments and fields of the task requested.
In addition the remote control command ``set_loglevel`` has been added,
this only changes the loglevel for the main process.
* Worker control command execution now catches errors and returns their
string representation in the reply.
* Functional test suite added
:mod:`celery.tests.functional.case` contains utilities to start
and stop an embedded celeryd process, for use in functional testing.
2.0.1
=====
:release-date: 2010-07-09 03:02 P.M CEST
* multiprocessing.pool: Now handles encoding errors, so that pickling errors
doesn't crash the worker processes.
* The remote control command replies was not working with RabbitMQ 1.8.0's
stricter equivalence checks.
If you've already hit this problem you may have to delete the
declaration::
$ camqadm exchange.delete celerycrq
or::
$ python manage.py camqadm exchange.delete celerycrq
* A bug sneaked in the ETA scheduler that made it only able to execute
one task per second(!)
The scheduler sleeps between iterations so it doesn't consume too much CPU.
It keeps a list of the scheduled items sorted by time, at each iteration
it sleeps for the remaining time of the item with the nearest deadline.
If there are no eta tasks it will sleep for a minimum amount of time, one
second by default.
A bug sneaked in here, making it sleep for one second for every task
that was scheduled. This has been fixed, so now it should move
tasks like hot knife through butter.
In addition a new setting has been added to control the minimum sleep
interval; ``CELERYD_ETA_SCHEDULER_PRECISION``. A good
value for this would be a float between 0 and 1, depending
on the needed precision. A value of 0.8 means that when the ETA of a task
is met, it will take at most 0.8 seconds for the task to be moved to the
ready queue.
* Pool: Supervisor did not release the semaphore.
This would lead to a deadlock if all workers terminated prematurely.
* Added Python version trove classifiers: 2.4, 2.5, 2.6 and 2.7
* Tests now passing on Python 2.7.
* Task.__reduce__: Tasks created using the task decorator can now be pickled.
* setup.py: nose added to ``tests_require``.
* Pickle should now work with SQLAlchemy 0.5.x
* New homepage design by Jan Henrik Helmers: http://celeryproject.org
* New Sphinx theme by Armin Ronacher: http://celeryproject.org/docs
* Fixed "pending_xref" errors shown in the HTML rendering of the
documentation. Apparently this was caused by new changes in Sphinx 1.0b2.
* Router classes in ``CELERY_ROUTES`` are now imported lazily.
Importing a router class in a module that also loads the Celery
environment would cause a circular dependency. This is solved
by importing it when needed after the environment is set up.
* ``CELERY_ROUTES`` was broken if set to a single dict.
This example in the docs should now work again::
CELERY_ROUTES = {"feed.tasks.import_feed": "feeds"}
* ``CREATE_MISSING_QUEUES`` was not honored by apply_async.
* New remote control command: ``stats``
Dumps information about the worker, like pool process pids, and
total number of tasks executed by type.
Example reply::
[{'worker.local':
'total': {'tasks.sleeptask': 6},
'pool': {'timeouts': [None, None],
'processes': [60376, 60377],
'max-concurrency': 2,
'max-tasks-per-child': None,
'put-guarded-by-semaphore': True}}]
* New remote control command: ``dump_active``
Gives a list of tasks currently being executed by the worker.
By default arguments are passed through repr in case there
are arguments that is not JSON encodable. If you know
the arguments are JSON safe, you can pass the argument ``safe=True``.
Example reply::
>>> broadcast("dump_active", arguments={"safe": False}, reply=True)
[{'worker.local': [
{'args': '(1,)',
'time_start': 1278580542.6300001,
'name': 'tasks.sleeptask',
'delivery_info': {
'consumer_tag': '30',
'routing_key': 'celery',
'exchange': 'celery'},
'hostname': 'casper.local',
'acknowledged': True,
'kwargs': '{}',
'id': '802e93e9-e470-47ed-b913-06de8510aca2',
}
]}]
* Added experimental support for persistent revokes.
Use the ``-S|--statedb`` argument to celeryd to enable it::
$ celeryd --statedb=/var/run/celeryd
This will use the file: ``/var/run/celeryd.db``,
as the ``shelve`` module automatically adds the ``.db`` suffix.
2.0.0
=====
:release-date: 2010-07-02 02:30 P.M CEST
Foreword
--------
Celery 2.0 contains backward incompatible changes, the most important
being that the Django dependency has been removed so Celery no longer
supports Django out of the box, but instead as an add-on package
called `django-celery`_.
We're very sorry for breaking backwards compatibility, but there's
also many new and exciting features to make up for the time you lose
upgrading, so be sure to read the :ref:`News <120news>` section.
Quite a lot of potential users have been upset about the Django dependency,
so maybe this is a chance to get wider adoption by the Python community as
well.
Big thanks to all contributors, testers and users!
Upgrading for Django-users
--------------------------
Django integration has been moved to a separate package: `django-celery`_.
* To upgrade you need to install the `django-celery`_ module and change::
INSTALLED_APPS = "celery"
to::
INSTALLED_APPS = "djcelery"
* If you use ``mod_wsgi`` you need to add the following line to your ``.wsgi``
file::
import os
os.environ["CELERY_LOADER"] = "django"
* The following modules has been moved to `django-celery`_:
===================================== =====================================
**Module name** **Replace with**
===================================== =====================================
``celery.models`` ``djcelery.models``
``celery.managers`` ``djcelery.managers``
``celery.views`` ``djcelery.views``
``celery.urls`` ``djcelery.urls``
``celery.management`` ``djcelery.management``
``celery.loaders.djangoapp`` ``djcelery.loaders``
``celery.backends.database`` ``djcelery.backends.database``
``celery.backends.cache`` ``djcelery.backends.cache``
===================================== =====================================
Importing :mod:`djcelery` will automatically setup Celery to use Django loader.
loader. It does this by setting the :envvar:`CELERY_LOADER` environment variable to
``"django"`` (it won't change it if a loader is already set.)
When the Django loader is used, the "database" and "cache" result backend
aliases will point to the :mod:`djcelery` backends instead of the built-in backends,
and configuration will be read from the Django settings.
.. _`django-celery`: http://pypi.python.org/pypi/django-celery
Upgrading for others
--------------------
Database result backend
~~~~~~~~~~~~~~~~~~~~~~~
The database result backend is now using `SQLAlchemy`_ instead of the
Django ORM, see `Supported Databases`_ for a table of supported databases.
The ``DATABASE_*`` settings has been replaced by a single setting:
``CELERY_RESULT_DBURI``. The value here should be an
`SQLAlchemy Connection String`_, some examples include:
.. code-block:: python
# sqlite (filename)
CELERY_RESULT_DBURI = "sqlite:///celerydb.sqlite"
# mysql
CELERY_RESULT_DBURI = "mysql://scott:tiger@localhost/foo"
# postgresql
CELERY_RESULT_DBURI = "postgresql://scott:tiger@localhost/mydatabase"
# oracle
CELERY_RESULT_DBURI = "oracle://scott:tiger@127.0.0.1:1521/sidname"
See `SQLAlchemy Connection Strings`_ for more information about connection
strings.
To specify additional SQLAlchemy database engine options you can use
the ``CELERY_RESULT_ENGINE_OPTIONS`` setting::
# echo enables verbose logging from SQLAlchemy.
CELERY_RESULT_ENGINE_OPTIONS = {"echo": True}
.. _`SQLAlchemy`:
http://www.sqlalchemy.org
.. _`Supported Databases`:
http://www.sqlalchemy.org/docs/dbengine.html#supported-databases
.. _`SQLAlchemy Connection String`:
http://www.sqlalchemy.org/docs/dbengine.html#create-engine-url-arguments
.. _`SQLAlchemy Connection Strings`:
http://www.sqlalchemy.org/docs/dbengine.html#create-engine-url-arguments
Cache result backend
~~~~~~~~~~~~~~~~~~~~
The cache result backend is no longer using the Django cache framework,
but it supports mostly the same configuration syntax::
CELERY_CACHE_BACKEND = "memcached://A.example.com:11211;B.example.com"
To use the cache backend you must either have the `pylibmc`_ or
`python-memcached`_ library installed, of which the former is regarded
as the best choice.
.. _`pylibmc`: http://pypi.python.org/pypi/pylibmc
.. _`python-memcached`: http://pypi.python.org/pypi/python-memcached
The support backend types are ``memcached://`` and ``memory://``,
we haven't felt the need to support any of the other backends
provided by Django.
Backward incompatible changes
-----------------------------
* Default (python) loader now prints warning on missing ``celeryconfig.py``
instead of raising :exc:`ImportError`.
celeryd raises :exc:`~celery.exceptions.ImproperlyConfigured` if the configuration
is not set up. This makes it possible to use ``--help`` etc, without having a
working configuration.
Also this makes it possible to use the client side of celery without being
configured::
>>> from carrot.connection import BrokerConnection
>>> conn = BrokerConnection("localhost", "guest", "guest", "/")
>>> from celery.execute import send_task
>>> r = send_task("celery.ping", args=(), kwargs={}, connection=conn)
>>> from celery.backends.amqp import AMQPBackend
>>> r.backend = AMQPBackend(connection=conn)
>>> r.get()
'pong'
* The following deprecated settings has been removed (as scheduled by
the `deprecation timeline`_):
===================================== =====================================
**Setting name** **Replace with**
===================================== =====================================
``CELERY_AMQP_CONSUMER_QUEUES`` ``CELERY_QUEUES``
``CELERY_AMQP_EXCHANGE`` ``CELERY_DEFAULT_EXCHANGE``
``CELERY_AMQP_EXCHANGE_TYPE`` ``CELERY_DEFAULT_EXCHANGE_TYPE``
``CELERY_AMQP_CONSUMER_ROUTING_KEY`` ``CELERY_QUEUES``
``CELERY_AMQP_PUBLISHER_ROUTING_KEY`` ``CELERY_DEFAULT_ROUTING_KEY``
===================================== =====================================
.. _`deprecation timeline`:
http://ask.github.com/celery/internals/deprecation.html
* The ``celery.task.rest`` module has been removed, use :mod:`celery.task.http`
instead (as scheduled by the `deprecation timeline`_).
* It's no longer allowed to skip the class name in loader names.
(as scheduled by the `deprecation timeline`_):
Assuming the implicit ``Loader`` class name is no longer supported,
if you use e.g.::
CELERY_LOADER = "myapp.loaders"
You need to include the loader class name, like this::
CELERY_LOADER = "myapp.loaders.Loader"
* ``CELERY_TASK_RESULT_EXPIRES`` now defaults to 1 day.
Previous default setting was to expire in 5 days.
* AMQP backend: Don't use different values for `auto_delete`.
This bug became visible with RabbitMQ 1.8.0, which no longer
allows conflicting declarations for the auto_delete and durable settings.
If you've already used celery with this backend chances are you
have to delete the previous declaration::
$ camqadm exchange.delete celeryresults
* Now uses pickle instead of cPickle on Python versions <= 2.5
cPikle is broken in Python <= 2.5.
It unsafely and incorrectly uses relative instead of absolute imports,
so e.g::
exceptions.KeyError
becomes::
celery.exceptions.KeyError
Your best choice is to upgrade to Python 2.6,
as while the pure pickle version has worse performance,
it is the only safe option for older Python versions.
.. _120news:
News
----
* **celeryev**: Curses Celery Monitor and Event Viewer.
This is a simple monitor allowing you to see what tasks are
executing in real-time and investigate tracebacks and results of ready
tasks. It also enables you to set new rate limits and revoke tasks.
Screenshot:
.. image:: http://celeryproject.org/img/celeryevshotsm.jpg
If you run ``celeryev`` with the ``-d`` switch it will act as an event
dumper, simply dumping the events it receives to standard out::
$ celeryev -d
-> celeryev: starting capture...
casper.local [2010-06-04 10:42:07.020000] heartbeat
casper.local [2010-06-04 10:42:14.750000] task received:
tasks.add(61a68756-27f4-4879-b816-3cf815672b0e) args=[2, 2] kwargs={}
eta=2010-06-04T10:42:16.669290, retries=0
casper.local [2010-06-04 10:42:17.230000] task started
tasks.add(61a68756-27f4-4879-b816-3cf815672b0e) args=[2, 2] kwargs={}
casper.local [2010-06-04 10:42:17.960000] task succeeded:
tasks.add(61a68756-27f4-4879-b816-3cf815672b0e)
args=[2, 2] kwargs={} result=4, runtime=0.782663106918
The fields here are, in order: *sender hostname*, *timestamp*, *event type* and
*additional event fields*.
* AMQP result backend: Now supports ``.ready()``, ``.successful()``,
``.result``, ``.status``, and even responds to changes in task state
* New user guides:
* :doc:`userguide/workers`
* :doc:`userguide/tasksets`
* :doc:`userguide/routing`
* celeryd: Standard out/error is now being redirected to the logfile.
* :mod:`billiard` has been moved back to the celery repository.
===================================== =====================================
**Module name** **celery equivalent**
===================================== =====================================
``billiard.pool`` ``celery.concurrency.processes.pool``
``billiard.serialization`` ``celery.serialization``
``billiard.utils.functional`` ``celery.utils.functional``
===================================== =====================================
The :mod:`billiard` distribution may be maintained, depending on interest.
* now depends on :mod:`carrot` >= 0.10.5
* now depends on :mod:`pyparsing`
* celeryd: Added ``--purge`` as an alias to ``--discard``.
* celeryd: Ctrl+C (SIGINT) once does warm shutdown, hitting Ctrl+C twice
forces termination.
* Added support for using complex crontab-expressions in periodic tasks. For
example, you can now use::
>>> crontab(minute="*/15")
or even::
>>> crontab(minute="*/30", hour="8-17,1-2", day_of_week="thu-fri")
See :doc:`getting-started/periodic-tasks`.
* celeryd: Now waits for available pool processes before applying new
tasks to the pool.
This means it doesn't have to wait for dozens of tasks to finish at shutdown
because it has applied prefetched tasks without having any pool
processes available to immediately accept them.
See http://github.com/ask/celery/issues/closed#issue/122
* New built-in way to do task callbacks using
:class:`~celery.task.sets.subtask`.
See :doc:`userguide/tasksets` for more information.
* TaskSets can now contain several types of tasks.
:class:`~celery.task.sets.TaskSet` has been refactored to use
a new syntax, please see :doc:`userguide/tasksets` for more information.
The previous syntax is still supported, but will be deprecated in
version 1.4.
* TaskSet failed() result was incorrect.
See http://github.com/ask/celery/issues/closed#issue/132
* Now creates different loggers per task class.
See http://github.com/ask/celery/issues/closed#issue/129
* Missing queue definitions are now created automatically.
You can disable this using the CELERY_CREATE_MISSING_QUEUES setting.
The missing queues are created with the following options::
CELERY_QUEUES[name] = {"exchange": name,
"exchange_type": "direct",
"routing_key": "name}
This feature is added for easily setting up routing using the ``-Q``
option to ``celeryd``::
$ celeryd -Q video, image
See the new routing section of the userguide for more information:
:doc:`userguide/routing`.
* New Task option: ``Task.queue``
If set, message options will be taken from the corresponding entry
in ``CELERY_QUEUES``. ``exchange``, ``exchange_type`` and ``routing_key``
will be ignored
* Added support for task soft and hard timelimits.
New settings added:
* CELERYD_TASK_TIME_LIMIT
Hard time limit. The worker processing the task will be killed and
replaced with a new one when this is exceeded.
* CELERYD_SOFT_TASK_TIME_LIMIT
Soft time limit. The celery.exceptions.SoftTimeLimitExceeded exception
will be raised when this is exceeded. The task can catch this to
e.g. clean up before the hard time limit comes.
New command line arguments to celeryd added:
``--time-limit`` and ``--soft-time-limit``.
What's left?
This won't work on platforms not supporting signals (and specifically
the ``SIGUSR1`` signal) yet. So an alternative the ability to disable
the feature alltogether on nonconforming platforms must be implemented.
Also when the hard time limit is exceeded, the task result should
be a ``TimeLimitExceeded`` exception.
* Test suite is now passing without a running broker, using the carrot
in-memory backend.
* Log output is now available in colors.
===================================== =====================================
**Log level** **Color**
===================================== =====================================
``DEBUG`` Blue
``WARNING`` Yellow
``CRITICAL`` Magenta
``ERROR`` Red
===================================== =====================================
This is only enabled when the log output is a tty.
You can explicitly enable/disable this feature using the
``CELERYD_LOG_COLOR`` setting.
* Added support for task router classes (like the django multidb routers)
* New setting: CELERY_ROUTES
This is a single, or a list of routers to traverse when
sending tasks. Dicts in this list converts to a
:class:`celery.routes.MapRoute` instance.
Examples:
>>> CELERY_ROUTES = {"celery.ping": "default",
"mytasks.add": "cpu-bound",
"video.encode": {
"queue": "video",
"exchange": "media"
"routing_key": "media.video.encode"}}
>>> CELERY_ROUTES = ("myapp.tasks.Router",
{"celery.ping": "default})
Where ``myapp.tasks.Router`` could be:
.. code-block:: python
class Router(object):
def route_for_task(self, task, args=None, kwargs=None):
if task == "celery.ping":
return "default"
route_for_task may return a string or a dict. A string then means
it's a queue name in ``CELERY_QUEUES``, a dict means it's a custom route.
When sending tasks, the routers are consulted in order. The first
router that doesn't return ``None`` is the route to use. The message options
is then merged with the found route settings, where the routers settings
have priority.
Example if :func:`~celery.execute.apply_async` has these arguments::
>>> Task.apply_async(immediate=False, exchange="video",
... routing_key="video.compress")
and a router returns::
{"immediate": True,
"exchange": "urgent"}
the final message options will be::
immediate=True, exchange="urgent", routing_key="video.compress"
(and any default message options defined in the
:class:`~celery.task.base.Task` class)
* New Task handler called after the task returns:
:meth:`~celery.task.base.Task.after_return`.
* :class:`~celery.datastructures.ExceptionInfo` now passed to
:meth:`~celery.task.base.Task.on_retry`/
:meth:`~celery.task.base.Task.on_failure` as einfo keyword argument.
* celeryd: Added ``CELERYD_MAX_TASKS_PER_CHILD`` /
:option:`--maxtasksperchild`
Defines the maximum number of tasks a pool worker can process before
the process is terminated and replaced by a new one.
* Revoked tasks now marked with state ``REVOKED``, and ``result.get()``
will now raise :exc:`~celery.exceptions.TaskRevokedError`.
* :func:`celery.task.control.ping` now works as expected.
* ``apply(throw=True)`` / ``CELERY_EAGER_PROPAGATES_EXCEPTIONS``: Makes eager
execution re-raise task errors.
* New signal: :data:`~celery.signals.worker_process_init`: Sent inside the
pool worker process at init.
* celeryd :option:`-Q` option: Ability to specifiy list of queues to use,
disabling other configured queues.
For example, if ``CELERY_QUEUES`` defines four queues: ``image``, ``video``,
``data`` and ``default``, the following command would make celeryd only
consume from the ``image`` and ``video`` queues::
$ celeryd -Q image,video
* celeryd: New return value for the ``revoke`` control command:
Now returns::
{"ok": "task $id revoked"}
instead of ``True``.
* celeryd: Can now enable/disable events using remote control
Example usage:
>>> from celery.task.control import broadcast
>>> broadcast("enable_events")
>>> broadcast("disable_events")
* Removed top-level tests directory. Test config now in celery.tests.config
This means running the unittests doesn't require any special setup.
``celery/tests/__init__`` now configures the ``CELERY_CONFIG_MODULE`` and
``CELERY_LOADER``, so when ``nosetests`` imports that, the unit test
environment is all set up.
Before you run the tests you need to install the test requirements::
$ pip install -r contrib/requirements/test.txt
Running all tests::
$ nosetests
Specifying the tests to run::
$ nosetests celery.tests.test_task
Producing HTML coverage::
$ nosetests --with-coverage3
The coverage output is then located in ``celery/tests/cover/index.html``.
* celeryd: New option ``--version``: Dump version info and exit.
* :mod:`celeryd-multi <celeryd.bin.celeryd_multi>`: Tool for shell scripts
to start multiple workers.
Some examples::
# Advanced example with 10 workers:
# * Three of the workers processes the images and video queue
# * Two of the workers processes the data queue with loglevel DEBUG
# * the rest processes the default' queue.
$ celeryd-multi start 10 -l INFO -Q:1-3 images,video -Q:4,5:data
-Q default -L:4,5 DEBUG
# get commands to start 10 workers, with 3 processes each
$ celeryd-multi start 3 -c 3
celeryd -n celeryd1.myhost -c 3
celeryd -n celeryd2.myhost -c 3
celeryd- n celeryd3.myhost -c 3
# start 3 named workers
$ celeryd-multi start image video data -c 3
celeryd -n image.myhost -c 3
celeryd -n video.myhost -c 3
celeryd -n data.myhost -c 3
# specify custom hostname
$ celeryd-multi start 2 -n worker.example.com -c 3
celeryd -n celeryd1.worker.example.com -c 3
celeryd -n celeryd2.worker.example.com -c 3
# Additionl options are added to each celeryd',
# but you can also modify the options for ranges of or single workers
# 3 workers: Two with 3 processes, and one with 10 processes.
$ celeryd-multi start 3 -c 3 -c:1 10
celeryd -n celeryd1.myhost -c 10
celeryd -n celeryd2.myhost -c 3
celeryd -n celeryd3.myhost -c 3
# can also specify options for named workers
$ celeryd-multi start image video data -c 3 -c:image 10
celeryd -n image.myhost -c 10
celeryd -n video.myhost -c 3
celeryd -n data.myhost -c 3
# ranges and lists of workers in options is also allowed:
# (-c:1-3 can also be written as -c:1,2,3)
$ celeryd-multi start 5 -c 3 -c:1-3 10
celeryd-multi -n celeryd1.myhost -c 10
celeryd-multi -n celeryd2.myhost -c 10
celeryd-multi -n celeryd3.myhost -c 10
celeryd-multi -n celeryd4.myhost -c 3
celeryd-multi -n celeryd5.myhost -c 3
# lists also works with named workers
$ celeryd-multi start foo bar baz xuzzy -c 3 -c:foo,bar,baz 10
celeryd-multi -n foo.myhost -c 10
celeryd-multi -n bar.myhost -c 10
celeryd-multi -n baz.myhost -c 10
celeryd-multi -n xuzzy.myhost -c 3
* The worker now calls the result backends ``process_cleanup`` method
*after* task execution instead of before.
* AMQP result backend now supports Pika.
1.0.6
=====
:release-date: 2010-06-30 09:57 A.M CEST
* RabbitMQ 1.8.0 has extended their exchange equivalence tests to
include ``auto_delete`` and ``durable``. This broke the AMQP backend.
If you've already used the AMQP backend this means you have to
delete the previous definitions::
$ camqadm exchange.delete celeryresults
or::
$ python manage.py camqadm exchange.delete celeryresults
1.0.5
=====
:release-date: 2010-06-01 02:36 P.M CEST
Critical
--------
* SIGINT/Ctrl+C killed the pool, abrubtly terminating the currently executing
tasks.
Fixed by making the pool worker processes ignore :const:`SIGINT`.
* Should not close the consumers before the pool is terminated, just cancel the consumers.
Issue #122. http://github.com/ask/celery/issues/issue/122
* Now depends on :mod:`billiard` >= 0.3.1
* celeryd: Previously exceptions raised by worker components could stall startup,
now it correctly logs the exceptions and shuts down.
* celeryd: Prefetch counts was set too late. QoS is now set as early as possible,
so celeryd can't slurp in all the messages at start-up.
Changes
-------
* :mod:`celery.contrib.abortable`: Abortable tasks.
Tasks that defines steps of execution, the task can then
be aborted after each step has completed.
* :class:`~celery.events.EventDispatcher`: No longer creates AMQP channel
if events are disabled
* Added required RPM package names under ``[bdist_rpm]`` section, to support building RPMs
from the sources using setup.py
* Running unittests: :envvar:`NOSE_VERBOSE` environment var now enables verbose output from Nose.
* :func:`celery.execute.apply`: Pass logfile/loglevel arguments as task kwargs.
Issue #110 http://github.com/ask/celery/issues/issue/110
* celery.execute.apply: Should return exception, not :class:`~celery.datastructures.ExceptionInfo`
on error.
Issue #111 http://github.com/ask/celery/issues/issue/111
* Added new entries to the :doc:`FAQs <faq>`:
* Should I use retry or acks_late?
* Can I execute a task by name?
1.0.4
=====
:release-date: 2010-05-31 09:54 A.M CEST
* Changlog merged with 1.0.5 as the release was never announced.
1.0.3
=====
:release-date: 2010-05-15 03:00 P.M CEST
Important notes
---------------
* Messages are now acked *just before* the task function is executed.
This is the behavior we've wanted all along, but couldn't have because of
limitations in the multiprocessing module.
The previous behavior was not good, and the situation worsened with the
release of 1.0.1, so this change will definitely improve
reliability, performance and operations in general.
For more information please see http://bit.ly/9hom6T
* Database result backend: result now explicitly sets ``null=True`` as
``django-picklefield`` version 0.1.5 changed the default behavior
right under our noses :(
See: http://bit.ly/d5OwMr
This means those who created their celery tables (via syncdb or
celeryinit) with picklefield versions >= 0.1.5 has to alter their tables to
allow the result field to be ``NULL`` manually.
MySQL::
ALTER TABLE celery_taskmeta MODIFY result TEXT NULL
PostgreSQL::
ALTER TABLE celery_taskmeta ALTER COLUMN result DROP NOT NULL
* Removed ``Task.rate_limit_queue_type``, as it was not really useful
and made it harder to refactor some parts.
* Now depends on carrot >= 0.10.4
* Now depends on billiard >= 0.3.0
News
----
* AMQP backend: Added timeout support for ``result.get()`` /
``result.wait()``.
* New task option: ``Task.acks_late`` (default: ``CELERY_ACKS_LATE``)
Late ack means the task messages will be acknowledged **after** the task
has been executed, not *just before*, which is the default behavior.
Note that this means the tasks may be executed twice if the worker
crashes in the middle of their execution. Not acceptable for most
applications, but desirable for others.
* Added crontab-like scheduling to periodic tasks.
Like a cron job, you can specify units of time of when
you would like the task to execute. While not a full implementation
of cron's features, it should provide a fair degree of common scheduling
needs.
You can specify a minute (0-59), an hour (0-23), and/or a day of the
week (0-6 where 0 is Sunday, or by names: sun, mon, tue, wed, thu, fri,
sat).
Examples:
.. code-block:: python
from celery.task.schedules import crontab
from celery.decorators import periodic_task
@periodic_task(run_every=crontab(hour=7, minute=30))
def every_morning():
print("Runs every morning at 7:30a.m")
@periodic_task(run_every=crontab(hour=7, minute=30, day_of_week="mon"))
def every_monday_morning():
print("Run every monday morning at 7:30a.m")
@periodic_task(run_every=crontab(minutes=30))
def every_hour():
print("Runs every hour on the clock. e.g. 1:30, 2:30, 3:30 etc.")
Note that this a late addition. While we have unittests, due to the
nature of this feature we haven't been able to completely test this
in practice, so consider this experimental.
* ``TaskPool.apply_async``: Now supports the ``accept_callback`` argument.
* ``apply_async``: Now raises :exc:`ValueError` if task args is not a list,
or kwargs is not a tuple (http://github.com/ask/celery/issues/issue/95).
* ``Task.max_retries`` can now be ``None``, which means it will retry forever.
* Celerybeat: Now reuses the same connection when publishing large
sets of tasks.
* Modified the task locking example in the documentation to use
``cache.add`` for atomic locking.
* Added experimental support for a *started* status on tasks.
If ``Task.track_started`` is enabled the task will report its status
as "started" when the task is executed by a worker.
The default value is ``False`` as the normal behaviour is to not
report that level of granularity. Tasks are either pending, finished,
or waiting to be retried. Having a "started" status can be useful for
when there are long running tasks and there is a need to report which
task is currently running.
The global default can be overridden by the ``CELERY_TRACK_STARTED``
setting.
* User Guide: New section ``Tips and Best Practices``.
Contributions welcome!
Remote control commands
-----------------------
* Remote control commands can now send replies back to the caller.
Existing commands has been improved to send replies, and the client
interface in ``celery.task.control`` has new keyword arguments: ``reply``,
``timeout`` and ``limit``. Where reply means it will wait for replies,
timeout is the time in seconds to stop waiting for replies, and limit
is the maximum number of replies to get.
By default, it will wait for as many replies as possible for one second.
* rate_limit(task_name, destination=all, reply=False, timeout=1, limit=0)
Worker returns ``{"ok": message}`` on success,
or ``{"failure": message}`` on failure.
>>> from celery.task.control import rate_limit
>>> rate_limit("tasks.add", "10/s", reply=True)
[{'worker1': {'ok': 'new rate limit set successfully'}},
{'worker2': {'ok': 'new rate limit set successfully'}}]
* ping(destination=all, reply=False, timeout=1, limit=0)
Worker returns the simple message ``"pong"``.
>>> from celery.task.control import ping
>>> ping(reply=True)
[{'worker1': 'pong'},
{'worker2': 'pong'},
* revoke(destination=all, reply=False, timeout=1, limit=0)
Worker simply returns ``True``.
>>> from celery.task.control import revoke
>>> revoke("419e46eb-cf6a-4271-86a8-442b7124132c", reply=True)
[{'worker1': True},
{'worker2'; True}]
* You can now add your own remote control commands!
Remote control commands are functions registered in the command
registry. Registering a command is done using
:meth:`celery.worker.control.Panel.register`:
.. code-block:: python
from celery.task.control import Panel
@Panel.register
def reset_broker_connection(panel, **kwargs):
panel.listener.reset_connection()
return {"ok": "connection re-established"}
With this module imported in the worker, you can launch the command
using ``celery.task.control.broadcast``::
>>> from celery.task.control import broadcast
>>> broadcast("reset_broker_connection", reply=True)
[{'worker1': {'ok': 'connection re-established'},
{'worker2': {'ok': 'connection re-established'}}]
**TIP** You can choose the worker(s) to receive the command
by using the ``destination`` argument::
>>> broadcast("reset_broker_connection", destination=["worker1"])
[{'worker1': {'ok': 'connection re-established'}]
* New remote control command: ``dump_reserved``
Dumps tasks reserved by the worker, waiting to be executed::
>>> from celery.task.control import broadcast
>>> broadcast("dump_reserved", reply=True)
[{'myworker1': [<TaskRequest ....>]}]
* New remote control command: ``dump_schedule``
Dumps the workers currently registered ETA schedule.
These are tasks with an ``eta`` (or ``countdown``) argument
waiting to be executed by the worker.
>>> from celery.task.control import broadcast
>>> broadcast("dump_schedule", reply=True)
[{'w1': []},
{'w3': []},
{'w2': ['0. 2010-05-12 11:06:00 pri0 <TaskRequest
{name:"opalfeeds.tasks.refresh_feed_slice",
id:"95b45760-4e73-4ce8-8eac-f100aa80273a",
args:"(<Feeds freq_max:3600 freq_min:60
start:2184.0 stop:3276.0>,)",
kwargs:"{'page': 2}"}>']},
{'w4': ['0. 2010-05-12 11:00:00 pri0 <TaskRequest
{name:"opalfeeds.tasks.refresh_feed_slice",
id:"c053480b-58fb-422f-ae68-8d30a464edfe",
args:"(<Feeds freq_max:3600 freq_min:60
start:1092.0 stop:2184.0>,)",
kwargs:"{\'page\': 1}"}>',
'1. 2010-05-12 11:12:00 pri0 <TaskRequest
{name:"opalfeeds.tasks.refresh_feed_slice",
id:"ab8bc59e-6cf8-44b8-88d0-f1af57789758",
args:"(<Feeds freq_max:3600 freq_min:60
start:3276.0 stop:4365>,)",
kwargs:"{\'page\': 3}"}>']}]
Fixes
-----
* Mediator thread no longer blocks for more than 1 second.
With rate limits enabled and when there was a lot of remaining time,
the mediator thread could block shutdown (and potentially block other
jobs from coming in).
* Remote rate limits was not properly applied
(http://github.com/ask/celery/issues/issue/98)
* Now handles exceptions with unicode messages correctly in
``TaskRequest.on_failure``.
* Database backend: ``TaskMeta.result``: default value should be ``None``
not empty string.
1.0.2
=====
:release-date: 2010-03-31 12:50 P.M CET
* Deprecated: ``CELERY_BACKEND``, please use ``CELERY_RESULT_BACKEND``
instead.
* We now use a custom logger in tasks. This logger supports task magic
keyword arguments in formats.
The default format for tasks (``CELERYD_TASK_LOG_FORMAT``) now includes
the id and the name of tasks so the origin of task log messages can
easily be traced.
Example output::
[2010-03-25 13:11:20,317: INFO/PoolWorker-1]
[tasks.add(a6e1c5ad-60d9-42a0-8b24-9e39363125a4)] Hello from add
To revert to the previous behavior you can set::
CELERYD_TASK_LOG_FORMAT = """
[%(asctime)s: %(levelname)s/%(processName)s] %(message)s
""".strip()
* Unittests: Don't disable the django test database teardown,
instead fixed the underlying issue which was caused by modifications
to the ``DATABASE_NAME`` setting (http://github.com/ask/celery/issues/82).
* Django Loader: New config ``CELERY_DB_REUSE_MAX`` (max number of tasks
to reuse the same database connection)
The default is to use a new connection for every task.
We would very much like to reuse the connection, but a safe number of
reuses is not known, and we don't have any way to handle the errors
that might happen, which may even be database dependent.
See: http://bit.ly/94fwdd
* celeryd: The worker components are now configurable: ``CELERYD_POOL``,
``CELERYD_LISTENER``, ``CELERYD_MEDIATOR``, and ``CELERYD_ETA_SCHEDULER``.
The default configuration is as follows:
.. code-block:: python
CELERYD_POOL = "celery.concurrency.processes.TaskPool"
CELERYD_MEDIATOR = "celery.worker.controllers.Mediator"
CELERYD_ETA_SCHEDULER = "celery.worker.controllers.ScheduleController"
CELERYD_LISTENER = "celery.worker.listener.CarrotListener"
The ``CELERYD_POOL`` setting makes it easy to swap out the multiprocessing
pool with a threaded pool, or how about a twisted/eventlet pool?
Consider the competition for the first pool plug-in started!
* Debian init scripts: Use ``-a`` not ``&&``
(http://github.com/ask/celery/issues/82).
* Debian init scripts: Now always preserves ``$CELERYD_OPTS`` from the
``/etc/default/celeryd`` and ``/etc/default/celerybeat``.
* celery.beat.Scheduler: Fixed a bug where the schedule was not properly
flushed to disk if the schedule had not been properly initialized.
* celerybeat: Now syncs the schedule to disk when receiving the ``SIGTERM``
and ``SIGINT`` signals.
* Control commands: Make sure keywords arguments are not in unicode.
* ETA scheduler: Was missing a logger object, so the scheduler crashed
when trying to log that a task had been revoked.
* management.commands.camqadm: Fixed typo ``camqpadm`` -> ``camqadm``
(http://github.com/ask/celery/issues/83).
* PeriodicTask.delta_resolution: Was not working for days and hours, now fixed
by rounding to the nearest day/hour.
* Fixed a potential infinite loop in ``BaseAsyncResult.__eq__``, although
there is no evidence that it has ever been triggered.
* celeryd: Now handles messages with encoding problems by acking them and
emitting an error message.
1.0.1
=====
:release-date: 2010-02-24 07:05 P.M CET
* Tasks are now acknowledged early instead of late.
This is done because messages can only be acked within the same
connection channel, so if the connection is lost we would have to refetch
the message again to acknowledge it.
This might or might not affect you, but mostly those running tasks with a
really long execution time are affected, as all tasks that has made it
all the way into the pool needs to be executed before the worker can
safely terminate (this is at most the number of pool workers, multiplied
by the ``CELERYD_PREFETCH_MULTIPLIER`` setting.)
We multiply the prefetch count by default to increase the performance at
times with bursts of tasks with a short execution time. If this doesn't
apply to your use case, you should be able to set the prefetch multiplier
to zero, without sacrificing performance.
Please note that a patch to :mod:`multiprocessing` is currently being
worked on, this patch would enable us to use a better solution, and is
scheduled for inclusion in the ``2.0.0`` release.
* celeryd now shutdowns cleanly when receving the ``TERM`` signal.
* celeryd now does a cold shutdown if the ``INT`` signal is received (Ctrl+C),
this means it tries to terminate as soon as possible.
* Caching of results now moved to the base backend classes, so no need
to implement this functionality in the base classes.
* Caches are now also limited in size, so their memory usage doesn't grow
out of control.
You can set the maximum number of results the cache
can hold using the ``CELERY_MAX_CACHED_RESULTS`` setting (the default
is five thousand results). In addition, you can refetch already retrieved
results using ``backend.reload_task_result`` +
``backend.reload_taskset_result`` (that's for those who want to send
results incrementally).
* ``celeryd`` now works on Windows again.
Note that if running with Django,
you can't use ``project.settings`` as the settings module name, but the
following should work::
$ python manage.py celeryd --settings=settings
* Execution: ``.messaging.TaskPublisher.send_task`` now
incorporates all the functionality apply_async previously did.
Like converting countdowns to eta, so :func:`celery.execute.apply_async` is
now simply a convenient front-end to
:meth:`celery.messaging.TaskPublisher.send_task`, using
the task classes default options.
Also :func:`celery.execute.send_task` has been
introduced, which can apply tasks using just the task name (useful
if the client does not have the destination task in its task registry).
Example:
>>> from celery.execute import send_task
>>> result = send_task("celery.ping", args=[], kwargs={})
>>> result.get()
'pong'
* ``camqadm``: This is a new utility for command line access to the AMQP API.
Excellent for deleting queues/bindings/exchanges, experimentation and
testing::
$ camqadm
1> help
Gives an interactive shell, type ``help`` for a list of commands.
When using Django, use the management command instead::
$ python manage.py camqadm
1> help
* Redis result backend: To conform to recent Redis API changes, the following
settings has been deprecated:
* ``REDIS_TIMEOUT``
* ``REDIS_CONNECT_RETRY``
These will emit a ``DeprecationWarning`` if used.
A ``REDIS_PASSWORD`` setting has been added, so you can use the new
simple authentication mechanism in Redis.
* The redis result backend no longer calls ``SAVE`` when disconnecting,
as this is apparently better handled by Redis itself.
* If ``settings.DEBUG`` is on, celeryd now warns about the possible
memory leak it can result in.
* The ETA scheduler now sleeps at most two seconds between iterations.
* The ETA scheduler now deletes any revoked tasks it might encounter.
As revokes are not yet persistent, this is done to make sure the task
is revoked even though it's currently being hold because its eta is e.g.
a week into the future.
* The ``task_id`` argument is now respected even if the task is executed
eagerly (either using apply, or ``CELERY_ALWAYS_EAGER``).
* The internal queues are now cleared if the connection is reset.
* New magic keyword argument: ``delivery_info``.
Used by retry() to resend the task to its original destination using the same
exchange/routing_key.
* Events: Fields was not passed by ``.send()`` (fixes the uuid keyerrors
in celerymon)
* Added ``--schedule``/``-s`` option to celeryd, so it is possible to
specify a custom schedule filename when using an embedded celerybeat
server (the ``-B``/``--beat``) option.
* Better Python 2.4 compatibility. The test suite now passes.
* task decorators: Now preserve docstring as ``cls.__doc__``, (was previously
copied to ``cls.run.__doc__``)
* The ``testproj`` directory has been renamed to ``tests`` and we're now using
``nose`` + ``django-nose`` for test discovery, and ``unittest2`` for test
cases.
* New pip requirements files available in ``contrib/requirements``.
* TaskPublisher: Declarations are now done once (per process).
* Added ``Task.delivery_mode`` and the ``CELERY_DEFAULT_DELIVERY_MODE``
setting.
These can be used to mark messages non-persistent (i.e. so they are
lost if the broker is restarted).
* Now have our own ``ImproperlyConfigured`` exception, instead of using the
Django one.
* Improvements to the debian init scripts: Shows an error if the program is
not executeable. Does not modify ``CELERYD`` when using django with
virtualenv.
1.0.0
=====
:release-date: 2010-02-10 04:00 P.M CET
Backward incompatible changes
-----------------------------
* Celery does not support detaching anymore, so you have to use the tools
available on your platform, or something like supervisord to make
celeryd/celerybeat/celerymon into background processes.
We've had too many problems with celeryd daemonizing itself, so it was
decided it has to be removed. Example startup scripts has been added to
``contrib/``:
* Debian, Ubuntu, (start-stop-daemon)
``contrib/debian/init.d/celeryd``
``contrib/debian/init.d/celerybeat``
* Mac OS X launchd
``contrib/mac/org.celeryq.celeryd.plist``
``contrib/mac/org.celeryq.celerybeat.plist``
``contrib/mac/org.celeryq.celerymon.plist``
* Supervisord (http://supervisord.org)
``contrib/supervisord/supervisord.conf``
In addition to ``--detach``, the following program arguments has been
removed: ``--uid``, ``--gid``, ``--workdir``, ``--chroot``, ``--pidfile``,
``--umask``. All good daemonization tools should support equivalent
functionality, so don't worry.
Also the following configuration keys has been removed:
``CELERYD_PID_FILE``, ``CELERYBEAT_PID_FILE``, ``CELERYMON_PID_FILE``.
* Default celeryd loglevel is now ``WARN``, to enable the previous log level
start celeryd with ``--loglevel=INFO``.
* Tasks are automatically registered.
This means you no longer have to register your tasks manually.
You don't have to change your old code right away, as it doesn't matter if
a task is registered twice.
If you don't want your task to be automatically registered you can set
the ``abstract`` attribute
.. code-block:: python
class MyTask(Task):
abstract = True
By using ``abstract`` only tasks subclassing this task will be automatically
registered (this works like the Django ORM).
If you don't want subclasses to be registered either, you can set the
``autoregister`` attribute to ``False``.
Incidentally, this change also fixes the problems with automatic name
assignment and relative imports. So you also don't have to specify a task name
anymore if you use relative imports.
* You can no longer use regular functions as tasks.
This change was added
because it makes the internals a lot more clean and simple. However, you can
now turn functions into tasks by using the ``@task`` decorator:
.. code-block:: python
from celery.decorators import task
@task
def add(x, y):
return x + y
See the User Guide: :doc:`userguide/tasks` for more information.
* The periodic task system has been rewritten to a centralized solution.
This means ``celeryd`` no longer schedules periodic tasks by default,
but a new daemon has been introduced: ``celerybeat``.
To launch the periodic task scheduler you have to run celerybeat::
$ celerybeat
Make sure this is running on one server only, if you run it twice, all
periodic tasks will also be executed twice.
If you only have one worker server you can embed it into celeryd like this::
$ celeryd --beat # Embed celerybeat in celeryd.
* The supervisor has been removed.
This means the ``-S`` and ``--supervised`` options to ``celeryd`` is
no longer supported. Please use something like http://supervisord.org
instead.
* ``TaskSet.join`` has been removed, use ``TaskSetResult.join`` instead.
* The task status ``"DONE"`` has been renamed to `"SUCCESS"`.
* ``AsyncResult.is_done`` has been removed, use ``AsyncResult.successful``
instead.
* The worker no longer stores errors if ``Task.ignore_result`` is set, to
revert to the previous behaviour set
``CELERY_STORE_ERRORS_EVEN_IF_IGNORED`` to ``True``.
* The staticstics functionality has been removed in favor of events,
so the ``-S`` and ``--statistics`` switches has been removed.
* The module ``celery.task.strategy`` has been removed.
* ``celery.discovery`` has been removed, and it's ``autodiscover`` function is
now in ``celery.loaders.djangoapp``. Reason: Internal API.
* ``CELERY_LOADER`` now needs loader class name in addition to module name,
E.g. where you previously had: ``"celery.loaders.default"``, you now need
``"celery.loaders.default.Loader"``, using the previous syntax will result
in a DeprecationWarning.
* Detecting the loader is now lazy, and so is not done when importing
``celery.loaders``.
To make this happen ``celery.loaders.settings`` has
been renamed to ``load_settings`` and is now a function returning the
settings object. ``celery.loaders.current_loader`` is now also
a function, returning the current loader.
So::
loader = current_loader
needs to be changed to::
loader = current_loader()
Deprecations
------------
* The following configuration variables has been renamed and will be
deprecated in v2.0:
* CELERYD_DAEMON_LOG_FORMAT -> CELERYD_LOG_FORMAT
* CELERYD_DAEMON_LOG_LEVEL -> CELERYD_LOG_LEVEL
* CELERY_AMQP_CONNECTION_TIMEOUT -> CELERY_BROKER_CONNECTION_TIMEOUT
* CELERY_AMQP_CONNECTION_RETRY -> CELERY_BROKER_CONNECTION_RETRY
* CELERY_AMQP_CONNECTION_MAX_RETRIES -> CELERY_BROKER_CONNECTION_MAX_RETRIES
* SEND_CELERY_TASK_ERROR_EMAILS -> CELERY_SEND_TASK_ERROR_EMAILS
* The public api names in celery.conf has also changed to a consistent naming
scheme.
* We now support consuming from an arbitrary number of queues.
To do this we had to rename the configuration syntax. If you use any of
the custom AMQP routing options (queue/exchange/routing_key, etc), you
should read the new FAQ entry: http://bit.ly/aiWoH.
The previous syntax is deprecated and scheduled for removal in v2.0.
* ``TaskSet.run`` has been renamed to ``TaskSet.apply_async``.
``TaskSet.run`` has now been deprecated, and is scheduled for
removal in v2.0.
News
----
* Rate limiting support (per task type, or globally).
* New periodic task system.
* Automatic registration.
* New cool task decorator syntax.
* celeryd now sends events if enabled with the ``-E`` argument.
Excellent for monitoring tools, one is already in the making
(http://github.com/ask/celerymon).
Current events include: worker-heartbeat,
task-[received/succeeded/failed/retried],
worker-online, worker-offline.
* You can now delete (revoke) tasks that has already been applied.
* You can now set the hostname celeryd identifies as using the ``--hostname``
argument.
* Cache backend now respects ``CELERY_TASK_RESULT_EXPIRES``.
* Message format has been standardized and now uses ISO-8601 format
for dates instead of datetime.
* ``celeryd`` now responds to the ``HUP`` signal by restarting itself.
* Periodic tasks are now scheduled on the clock.
I.e. ``timedelta(hours=1)`` means every hour at :00 minutes, not every
hour from the server starts. To revert to the previous behaviour you
can set ``PeriodicTask.relative = True``.
* Now supports passing execute options to a TaskSets list of args, e.g.:
>>> ts = TaskSet(add, [([2, 2], {}, {"countdown": 1}),
... ([4, 4], {}, {"countdown": 2}),
... ([8, 8], {}, {"countdown": 3})])
>>> ts.run()
* Got a 3x performance gain by setting the prefetch count to four times the
concurrency, (from an average task round-trip of 0.1s to 0.03s!).
A new setting has been added: ``CELERYD_PREFETCH_MULTIPLIER``, which
is set to ``4`` by default.
* Improved support for webhook tasks.
``celery.task.rest`` is now deprecated, replaced with the new and shiny
:mod:`celery.task.http`. With more reflective names, sensible interface,
and it's possible to override the methods used to perform HTTP requests.
* The results of tasksets are now cached by storing it in the result
backend.
Changes
-------
* Now depends on carrot >= 0.8.1
* New dependencies: billiard, python-dateutil, django-picklefield
* No longer depends on python-daemon
* The ``uuid`` distribution is added as a dependency when running Python 2.4.
* Now remembers the previously detected loader by keeping it in
the ``CELERY_LOADER`` environment variable.
This may help on windows where fork emulation is used.
* ETA no longer sends datetime objects, but uses ISO 8601 date format in a
string for better compatibility with other platforms.
* No longer sends error mails for retried tasks.
* Task can now override the backend used to store results.
* Refactored the ExecuteWrapper, ``apply`` and ``CELERY_ALWAYS_EAGER`` now
also executes the task callbacks and signals.
* Now using a proper scheduler for the tasks with an ETA.
This means waiting eta tasks are sorted by time, so we don't have
to poll the whole list all the time.
* Now also imports modules listed in CELERY_IMPORTS when running
with django (as documented).
* Loglevel for stdout/stderr changed from INFO to ERROR
* ImportErrors are now properly propogated when autodiscovering tasks.
* You can now use ``celery.messaging.establish_connection`` to establish a
connection to the broker.
* When running as a separate service the periodic task scheduler does some
smart moves to not poll too regularly.
If you need faster poll times you can lower the value
of ``CELERYBEAT_MAX_LOOP_INTERVAL``.
* You can now change periodic task intervals at runtime, by making
``run_every`` a property, or subclassing ``PeriodicTask.is_due``.
* The worker now supports control commands enabled through the use of a
broadcast queue, you can remotely revoke tasks or set the rate limit for
a task type. See :mod:`celery.task.control`.
* The services now sets informative process names (as shown in ``ps``
listings) if the :mod:`setproctitle` module is installed.
* :exc:`celery.exceptions.NotRegistered` now inherits from :exc:`KeyError`,
and ``TaskRegistry.__getitem__``+``pop`` raises ``NotRegistered`` instead
* You can set the loader via the ``CELERY_LOADER`` environment variable.
* You can now set ``CELERY_IGNORE_RESULT`` to ignore task results by default
(if enabled, tasks doesn't save results or errors to the backend used).
* celeryd now correctly handles malformed messages by throwing away and
acknowledging the message, instead of crashing.
Bugs
----
* Fixed a race condition that could happen while storing task results in the
database.
Documentation
-------------
* Reference now split into two sections; API reference and internal module
reference.
0.8.4
=====
:release-date: 2010-02-05 01:52 P.M CEST
* Now emits a warning if the --detach argument is used.
--detach should not be used anymore, as it has several not easily fixed
bugs related to it. Instead, use something like start-stop-daemon,
supervisord or launchd (os x).
* Make sure logger class is process aware, even if running Python >= 2.6.
* Error e-mails are not sent anymore when the task is retried.
0.8.3
=====
:release-date: 2009-12-22 09:43 A.M CEST
* Fixed a possible race condition that could happen when storing/querying
task results using the the database backend.
* Now has console script entry points in the setup.py file, so tools like
buildout will correctly install the programs celerybin and celeryinit.
0.8.2
=====
:release-date: 2009-11-20 03:40 P.M CEST
* QOS Prefetch count was not applied properly, as it was set for every message
received (which apparently behaves like, "receive one more"), instead of only
set when our wanted value cahnged.
0.8.1
=================================
:release-date: 2009-11-16 05:21 P.M CEST
Very important note
-------------------
This release (with carrot 0.8.0) enables AMQP QoS (quality of service), which
means the workers will only receive as many messages as it can handle at a
time. As with any release, you should test this version upgrade on your
development servers before rolling it out to production!
Important changes
-----------------
* If you're using Python < 2.6 and you use the multiprocessing backport, then
multiprocessing version 2.6.2.1 is required.
* All AMQP_* settings has been renamed to BROKER_*, and in addition
AMQP_SERVER has been renamed to BROKER_HOST, so before where you had::
AMQP_SERVER = "localhost"
AMQP_PORT = 5678
AMQP_USER = "myuser"
AMQP_PASSWORD = "mypassword"
AMQP_VHOST = "celery"
You need to change that to::
BROKER_HOST = "localhost"
BROKER_PORT = 5678
BROKER_USER = "myuser"
BROKER_PASSWORD = "mypassword"
BROKER_VHOST = "celery"
* Custom carrot backends now need to include the backend class name, so before
where you had::
CARROT_BACKEND = "mycustom.backend.module"
you need to change it to::
CARROT_BACKEND = "mycustom.backend.module.Backend"
where ``Backend`` is the class name. This is probably ``"Backend"``, as
that was the previously implied name.
* New version requirement for carrot: 0.8.0
Changes
-------
* Incorporated the multiprocessing backport patch that fixes the
``processName`` error.
* Ignore the result of PeriodicTask's by default.
* Added a Redis result store backend
* Allow /etc/default/celeryd to define additional options for the celeryd init
script.
* MongoDB periodic tasks issue when using different time than UTC fixed.
* Windows specific: Negate test for available os.fork (thanks miracle2k)
* Now tried to handle broken PID files.
* Added a Django test runner to contrib that sets CELERY_ALWAYS_EAGER = True for testing with the database backend
* Added a CELERY_CACHE_BACKEND setting for using something other than the django-global cache backend.
* Use custom implementation of functools.partial (curry) for Python 2.4 support
(Probably still problems with running on 2.4, but it will eventually be
supported)
* Prepare exception to pickle when saving RETRY status for all backends.
* SQLite no concurrency limit should only be effective if the db backend is used.
0.8.0
=====
:release-date: 2009-09-22 03:06 P.M CEST
Backward incompatible changes
-----------------------------
* Add traceback to result value on failure.
**NOTE** If you use the database backend you have to re-create the
database table ``celery_taskmeta``.
Contact the mailinglist or IRC channel listed in README for help
doing this.
* Database tables are now only created if the database backend is used,
so if you change back to the database backend at some point,
be sure to initialize tables (django: ``syncdb``, python: ``celeryinit``).
(Note: This is only the case when using Django 1.1 or higher)
* Now depends on ``carrot`` version 0.6.0.
* Now depends on python-daemon 1.4.8
Important changes
-----------------
* Celery can now be used in pure Python (outside of a Django project).
This means celery is no longer Django specific.
For more information see the FAQ entry
`Can I use celery without Django?`_.
.. _`Can I use celery without Django?`:
http://ask.github.com/celery/faq.html#can-i-use-celery-without-django
* Celery now supports task retries.
See `Cookbook: Retrying Tasks`_ for more information.
.. _`Cookbook: Retrying Tasks`:
http://ask.github.com/celery/cookbook/task-retries.html
* We now have an AMQP result store backend.
It uses messages to publish task return value and status. And it's
incredibly fast!
See http://github.com/ask/celery/issues/closed#issue/6 for more info!
* AMQP QoS (prefetch count) implemented:
This to not receive more messages than we can handle.
* Now redirects stdout/stderr to the celeryd logfile when detached
* Now uses ``inspect.getargspec`` to only pass default arguments
the task supports.
* Add Task.on_success, .on_retry, .on_failure handlers
See :meth:`celery.task.base.Task.on_success`,
:meth:`celery.task.base.Task.on_retry`,
:meth:`celery.task.base.Task.on_failure`,
* ``celery.utils.gen_unique_id``: Workaround for
http://bugs.python.org/issue4607
* You can now customize what happens at worker start, at process init, etc
by creating your own loaders. (see :mod:`celery.loaders.default`,
:mod:`celery.loaders.djangoapp`, :mod:`celery.loaders`.)
* Support for multiple AMQP exchanges and queues.
This feature misses documentation and tests, so anyone interested
is encouraged to improve this situation.
* celeryd now survives a restart of the AMQP server!
Automatically re-establish AMQP broker connection if it's lost.
New settings:
* AMQP_CONNECTION_RETRY
Set to ``True`` to enable connection retries.
* AMQP_CONNECTION_MAX_RETRIES.
Maximum number of restarts before we give up. Default: ``100``.
News
----
* Fix an incompatibility between python-daemon and multiprocessing,
which resulted in the ``[Errno 10] No child processes`` problem when
detaching.
* Fixed a possible DjangoUnicodeDecodeError being raised when saving pickled
data to Django's memcached cache backend.
* Better Windows compatibility.
* New version of the pickled field (taken from
http://www.djangosnippets.org/snippets/513/)
* New signals introduced: ``task_sent``, ``task_prerun`` and
``task_postrun``, see :mod:`celery.signals` for more information.
* ``TaskSetResult.join`` caused ``TypeError`` when ``timeout=None``.
Thanks Jerzy Kozera. Closes #31
* ``views.apply`` should return ``HttpResponse`` instance.
Thanks to Jerzy Kozera. Closes #32
* ``PeriodicTask``: Save conversion of ``run_every`` from ``int``
to ``timedelta`` to the class attribute instead of on the instance.
* Exceptions has been moved to ``celery.exceptions``, but are still
available in the previous module.
* Try to rollback transaction and retry saving result if an error happens
while setting task status with the database backend.
* jail() refactored into :class:`celery.execute.ExecuteWrapper`.
* ``views.apply`` now correctly sets mimetype to "application/json"
* ``views.task_status`` now returns exception if status is RETRY
* ``views.task_status`` now returns traceback if status is "FAILURE"
or "RETRY"
* Documented default task arguments.
* Add a sensible __repr__ to ExceptionInfo for easier debugging
* Fix documentation typo ``.. import map`` -> ``.. import dmap``.
Thanks mikedizon
0.6.0
=====
:release-date: 2009-08-07 06:54 A.M CET
Important changes
-----------------
* Fixed a bug where tasks raising unpickleable exceptions crashed pool
workers. So if you've had pool workers mysteriously dissapearing, or
problems with celeryd stopping working, this has been fixed in this
version.
* Fixed a race condition with periodic tasks.
* The task pool is now supervised, so if a pool worker crashes,
goes away or stops responding, it is automatically replaced with
a new one.
* Task.name is now automatically generated out of class module+name, e.g.
``"djangotwitter.tasks.UpdateStatusesTask"``. Very convenient. No idea why
we didn't do this before. Some documentation is updated to not manually
specify a task name.
News
----
* Tested with Django 1.1
* New Tutorial: Creating a click counter using carrot and celery
* Database entries for periodic tasks are now created at ``celeryd``
startup instead of for each check (which has been a forgotten TODO/XXX
in the code for a long time)
* New settings variable: ``CELERY_TASK_RESULT_EXPIRES``
Time (in seconds, or a `datetime.timedelta` object) for when after
stored task results are deleted. For the moment this only works for the
database backend.
* ``celeryd`` now emits a debug log message for which periodic tasks
has been launched.
* The periodic task table is now locked for reading while getting
periodic task status. (MySQL only so far, seeking patches for other
engines)
* A lot more debugging information is now available by turning on the
``DEBUG`` loglevel (``--loglevel=DEBUG``).
* Functions/methods with a timeout argument now works correctly.
* New: ``celery.strategy.even_time_distribution``:
With an iterator yielding task args, kwargs tuples, evenly distribute
the processing of its tasks throughout the time window available.
* Log message ``Unknown task ignored...`` now has loglevel ``ERROR``
* Log message ``"Got task from broker"`` is now emitted for all tasks, even if
the task has an ETA (estimated time of arrival). Also the message now
includes the ETA for the task (if any).
* Acknowledgement now happens in the pool callback. Can't do ack in the job
target, as it's not pickleable (can't share AMQP connection, etc)).
* Added note about .delay hanging in README
* Tests now passing in Django 1.1
* Fixed discovery to make sure app is in INSTALLED_APPS
* Previously overrided pool behaviour (process reap, wait until pool worker
available, etc.) is now handled by ``multiprocessing.Pool`` itself.
* Convert statistics data to unicode for use as kwargs. Thanks Lucy!
0.4.1
=====
:release-date: 2009-07-02 01:42 P.M CET
* Fixed a bug with parsing the message options (``mandatory``,
``routing_key``, ``priority``, ``immediate``)
0.4.0
=====
:release-date: 2009-07-01 07:29 P.M CET
* Adds eager execution. ``celery.execute.apply``|``Task.apply`` executes the
function blocking until the task is done, for API compatiblity it
returns an ``celery.result.EagerResult`` instance. You can configure
celery to always run tasks locally by setting the
``CELERY_ALWAYS_EAGER`` setting to ``True``.
* Now depends on ``anyjson``.
* 99% coverage using python ``coverage`` 3.0.
0.3.20
======
:release-date: 2009-06-25 08:42 P.M CET
* New arguments to ``apply_async`` (the advanced version of
``delay_task``), ``countdown`` and ``eta``;
>>> # Run 10 seconds into the future.
>>> res = apply_async(MyTask, countdown=10);
>>> # Run 1 day from now
>>> res = apply_async(MyTask, eta=datetime.now() +
... timedelta(days=1)
* Now unlinks the pidfile if it's stale.
* Lots of more tests.
* Now compatible with carrot >= 0.5.0.
* **IMPORTANT** The ``subtask_ids`` attribute on the ``TaskSetResult``
instance has been removed. To get this information instead use:
>>> subtask_ids = [subtask.task_id for subtask in ts_res.subtasks]
* ``Taskset.run()`` now respects extra message options from the task class.
* Task: Add attribute ``ignore_result``: Don't store the status and
return value. This means you can't use the
``celery.result.AsyncResult`` to check if the task is
done, or get its return value. Only use if you need the performance
and is able live without these features. Any exceptions raised will
store the return value/status as usual.
* Task: Add attribute ``disable_error_emails`` to disable sending error
emails for that task.
* Should now work on Windows (although running in the background won't
work, so using the ``--detach`` argument results in an exception
being raised.)
* Added support for statistics for profiling and monitoring.
To start sending statistics start ``celeryd`` with the
``--statistics`` option. Then after a while you can dump the results
by running ``python manage.py celerystats``. See
``celery.monitoring`` for more information.
* The celery daemon can now be supervised (i.e it is automatically
restarted if it crashes). To use this start celeryd with the
``--supervised`` option (or alternatively ``-S``).
* views.apply: View applying a task. Example::
http://e.com/celery/apply/task_name/arg1/arg2//?kwarg1=a&kwarg2=b
**NOTE** Use with caution, preferably not make this publicly
accessible without ensuring your code is safe!
* Refactored ``celery.task``. It's now split into three modules:
* celery.task
Contains ``apply_async``, ``delay_task``, ``discard_all``, and task
shortcuts, plus imports objects from ``celery.task.base`` and
``celery.task.builtins``
* celery.task.base
Contains task base classes: ``Task``, ``PeriodicTask``,
``TaskSet``, ``AsynchronousMapTask``, ``ExecuteRemoteTask``.
* celery.task.builtins
Built-in tasks: ``PingTask``, ``DeleteExpiredTaskMetaTask``.
0.3.7
=====
:release-date: 2008-06-16 11:41 P.M CET
* **IMPORTANT** Now uses AMQP's ``basic.consume`` instead of
``basic.get``. This means we're no longer polling the broker for
new messages.
* **IMPORTANT** Default concurrency limit is now set to the number of CPUs
available on the system.
* **IMPORTANT** ``tasks.register``: Renamed ``task_name`` argument to
``name``, so
>>> tasks.register(func, task_name="mytask")
has to be replaced with:
>>> tasks.register(func, name="mytask")
* The daemon now correctly runs if the pidlock is stale.
* Now compatible with carrot 0.4.5
* Default AMQP connnection timeout is now 4 seconds.
* ``AsyncResult.read()`` was always returning ``True``.
* Only use README as long_description if the file exists so easy_install
doesn't break.
* ``celery.view``: JSON responses now properly set its mime-type.
* ``apply_async`` now has a ``connection`` keyword argument so you
can re-use the same AMQP connection if you want to execute
more than one task.
* Handle failures in task_status view such that it won't throw 500s.
* Fixed typo ``AMQP_SERVER`` in documentation to ``AMQP_HOST``.
* Worker exception e-mails sent to admins now works properly.
* No longer depends on ``django``, so installing ``celery`` won't affect
the preferred Django version installed.
* Now works with PostgreSQL (psycopg2) again by registering the
``PickledObject`` field.
* ``celeryd``: Added ``--detach`` option as an alias to ``--daemon``, and
it's the term used in the documentation from now on.
* Make sure the pool and periodic task worker thread is terminated
properly at exit. (So ``Ctrl-C`` works again).
* Now depends on ``python-daemon``.
* Removed dependency to ``simplejson``
* Cache Backend: Re-establishes connection for every task process
if the Django cache backend is memcached/libmemcached.
* Tyrant Backend: Now re-establishes the connection for every task
executed.
0.3.3
=====
:release-date: 2009-06-08 01:07 P.M CET
* The ``PeriodicWorkController`` now sleeps for 1 second between checking
for periodic tasks to execute.
0.3.2
=====
:release-date: 2009-06-08 01:07 P.M CET
* celeryd: Added option ``--discard``: Discard (delete!) all waiting
messages in the queue.
* celeryd: The ``--wakeup-after`` option was not handled as a float.
0.3.1
=====
:release-date: 2009-06-08 01:07 P.M CET
* The `PeriodicTask`` worker is now running in its own thread instead
of blocking the ``TaskController`` loop.
* Default ``QUEUE_WAKEUP_AFTER`` has been lowered to ``0.1`` (was ``0.3``)
0.3.0
=====
:release-date: 2009-06-08 12:41 P.M CET
**NOTE** This is a development version, for the stable release, please
see versions 0.2.x.
**VERY IMPORTANT:** Pickle is now the encoder used for serializing task
arguments, so be sure to flush your task queue before you upgrade.
* **IMPORTANT** TaskSet.run() now returns a celery.result.TaskSetResult
instance, which lets you inspect the status and return values of a
taskset as it was a single entity.
* **IMPORTANT** Celery now depends on carrot >= 0.4.1.
* The celery daemon now sends task errors to the registered admin e-mails.
To turn off this feature, set ``SEND_CELERY_TASK_ERROR_EMAILS`` to
``False`` in your ``settings.py``. Thanks to Grégoire Cachet.
* You can now run the celery daemon by using ``manage.py``::
$ python manage.py celeryd
Thanks to Grégoire Cachet.
* Added support for message priorities, topic exchanges, custom routing
keys for tasks. This means we have introduced
``celery.task.apply_async``, a new way of executing tasks.
You can use ``celery.task.delay`` and ``celery.Task.delay`` like usual, but
if you want greater control over the message sent, you want
``celery.task.apply_async`` and ``celery.Task.apply_async``.
This also means the AMQP configuration has changed. Some settings has
been renamed, while others are new::
CELERY_AMQP_EXCHANGE
CELERY_AMQP_PUBLISHER_ROUTING_KEY
CELERY_AMQP_CONSUMER_ROUTING_KEY
CELERY_AMQP_CONSUMER_QUEUE
CELERY_AMQP_EXCHANGE_TYPE
See the entry `Can I send some tasks to only some servers?`_ in the
`FAQ`_ for more information.
.. _`Can I send some tasks to only some servers?`:
http://bit.ly/celery_AMQP_routing
.. _`FAQ`: http://ask.github.com/celery/faq.html
* Task errors are now logged using loglevel ``ERROR`` instead of ``INFO``,
and backtraces are dumped. Thanks to Grégoire Cachet.
* Make every new worker process re-establish it's Django DB connection,
this solving the "MySQL connection died?" exceptions.
Thanks to Vitaly Babiy and Jirka Vejrazka.
* **IMOPORTANT** Now using pickle to encode task arguments. This means you
now can pass complex python objects to tasks as arguments.
* Removed dependency to ``yadayada``.
* Added a FAQ, see ``docs/faq.rst``.
* Now converts any unicode keys in task ``kwargs`` to regular strings.
Thanks Vitaly Babiy.
* Renamed the ``TaskDaemon`` to ``WorkController``.
* ``celery.datastructures.TaskProcessQueue`` is now renamed to
``celery.pool.TaskPool``.
* The pool algorithm has been refactored for greater performance and
stability.
0.2.0
=====
:release-date: 2009-05-20 05:14 P.M CET
* Final release of 0.2.0
* Compatible with carrot version 0.4.0.
* Fixes some syntax errors related to fetching results
from the database backend.
0.2.0-pre3
==========
:release-date: 2009-05-20 05:14 P.M CET
* *Internal release*. Improved handling of unpickled exceptions,
``get_result`` now tries to recreate something looking like the
original exception.
0.2.0-pre2
==========
:release-date: 2009-05-20 01:56 P.M CET
* Now handles unpickleable exceptions (like the dynimically generated
subclasses of ``django.core.exception.MultipleObjectsReturned``).
0.2.0-pre1
==========
:release-date: 2009-05-20 12:33 P.M CET
* It's getting quite stable, with a lot of new features, so bump
version to 0.2. This is a pre-release.
* ``celery.task.mark_as_read()`` and ``celery.task.mark_as_failure()`` has
been removed. Use ``celery.backends.default_backend.mark_as_read()``,
and ``celery.backends.default_backend.mark_as_failure()`` instead.
0.1.15
======
:release-date: 2009-05-19 04:13 P.M CET
* The celery daemon was leaking AMQP connections, this should be fixed,
if you have any problems with too many files open (like ``emfile``
errors in ``rabbit.log``, please contact us!
0.1.14
======
:release-date: 2009-05-19 01:08 P.M CET
* Fixed a syntax error in the ``TaskSet`` class. (No such variable
``TimeOutError``).
0.1.13
======
:release-date: 2009-05-19 12:36 P.M CET
* Forgot to add ``yadayada`` to install requirements.
* Now deletes all expired task results, not just those marked as done.
* Able to load the Tokyo Tyrant backend class without django
configuration, can specify tyrant settings directly in the class
constructor.
* Improved API documentation
* Now using the Sphinx documentation system, you can build
the html documentation by doing ::
$ cd docs
$ make html
and the result will be in ``docs/.build/html``.
0.1.12
======
:release-date: 2009-05-18 04:38 P.M CET
* ``delay_task()`` etc. now returns ``celery.task.AsyncResult`` object,
which lets you check the result and any failure that might have
happened. It kind of works like the ``multiprocessing.AsyncResult``
class returned by ``multiprocessing.Pool.map_async``.
* Added dmap() and dmap_async(). This works like the
``multiprocessing.Pool`` versions except they are tasks
distributed to the celery server. Example:
>>> from celery.task import dmap
>>> import operator
>>> dmap(operator.add, [[2, 2], [4, 4], [8, 8]])
>>> [4, 8, 16]
>>> from celery.task import dmap_async
>>> import operator
>>> result = dmap_async(operator.add, [[2, 2], [4, 4], [8, 8]])
>>> result.ready()
False
>>> time.sleep(1)
>>> result.ready()
True
>>> result.result
[4, 8, 16]
* Refactored the task metadata cache and database backends, and added
a new backend for Tokyo Tyrant. You can set the backend in your django
settings file. e.g::
CELERY_RESULT_BACKEND = "database"; # Uses the database
CELERY_RESULT_BACKEND = "cache"; # Uses the django cache framework
CELERY_RESULT_BACKEND = "tyrant"; # Uses Tokyo Tyrant
TT_HOST = "localhost"; # Hostname for the Tokyo Tyrant server.
TT_PORT = 6657; # Port of the Tokyo Tyrant server.
0.1.11
======
:release-date: 2009-05-12 02:08 P.M CET
* The logging system was leaking file descriptors, resulting in
servers stopping with the EMFILES (too many open files) error. (fixed)
0.1.10
======
:release-date: 2009-05-11 12:46 P.M CET
* Tasks now supports both positional arguments and keyword arguments.
* Requires carrot 0.3.8.
* The daemon now tries to reconnect if the connection is lost.
0.1.8
=====
:release-date: 2009-05-07 12:27 P.M CET
* Better test coverage
* More documentation
* celeryd doesn't emit ``Queue is empty`` message if
``settings.CELERYD_EMPTY_MSG_EMIT_EVERY`` is 0.
0.1.7
=====
:release-date: 2009-04-30 1:50 P.M CET
* Added some unittests
* Can now use the database for task metadata (like if the task has
been executed or not). Set ``settings.CELERY_TASK_META``
* Can now run ``python setup.py test`` to run the unittests from
within the ``tests`` project.
* Can set the AMQP exchange/routing key/queue using
``settings.CELERY_AMQP_EXCHANGE``, ``settings.CELERY_AMQP_ROUTING_KEY``,
and ``settings.CELERY_AMQP_CONSUMER_QUEUE``.
0.1.6
=====
:release-date: 2009-04-28 2:13 P.M CET
* Introducing ``TaskSet``. A set of subtasks is executed and you can
find out how many, or if all them, are done (excellent for progress
bars and such)
* Now catches all exceptions when running ``Task.__call__``, so the
daemon doesn't die. This does't happen for pure functions yet, only
``Task`` classes.
* ``autodiscover()`` now works with zipped eggs.
* celeryd: Now adds curernt working directory to ``sys.path`` for
convenience.
* The ``run_every`` attribute of ``PeriodicTask`` classes can now be a
``datetime.timedelta()`` object.
* celeryd: You can now set the ``DJANGO_PROJECT_DIR`` variable
for ``celeryd`` and it will add that to ``sys.path`` for easy launching.
* Can now check if a task has been executed or not via HTTP.
* You can do this by including the celery ``urls.py`` into your project,
>>> url(r'^celery/$', include("celery.urls"))
then visiting the following url,::
http://mysite/celery/$task_id/done/
this will return a JSON dictionary like e.g:
>>> {"task": {"id": $task_id, "executed": true}}
* ``delay_task`` now returns string id, not ``uuid.UUID`` instance.
* Now has ``PeriodicTasks``, to have ``cron`` like functionality.
* Project changed name from ``crunchy`` to ``celery``. The details of
the name change request is in ``docs/name_change_request.txt``.
0.1.0
=====
:release-date: 2009-04-24 11:28 A.M CET
* Initial release
Jump to Line
Something went wrong with that request. Please try again.