Merge branch '3.0'

Conflicts:
	Changelog
	README.rst
	celery/__init__.py
	docs/includes/introduction.txt
	extra/centos/celeryd.init
	extra/centos/celeryd.sysconfig
	extra/generic-init.d/celeryd
	requirements/default-py3k.txt
	requirements/default.txt
	setup.cfg

CONTRIBUTORS.txt

@@ -127,3 +127,4 @@ Marius Gedminas, 2012/11/29
 Christoph Krybus, 2013/01/07
 Jun Sakai, 2013/01/16
 Vlad Frolov, 2013/01/23
+Milen Pavlov, 2013/03/08

celery/backends/cache.py

@@ -115,7 +115,6 @@ class CacheBackend(KeyValueStoreBackend):
 
     def on_chord_apply(self, group_id, body, result=None, **kwargs):
         self.client.set(self.get_key_for_chord(group_id), '0', time=86400)
-        print('GROUP_ID: %r RESULT: %r' % (group_id, result))
         self.app.GroupResult(group_id, result).save()
 
     def incr(self, key):

celery/loaders/base.py

@@ -28,8 +28,6 @@ from celery.utils.imports import (
     import_from_cwd, symbol_by_name, NotAPackage, find_module,
 )
 
-BUILTIN_MODULES = frozenset()
-
 ERROR_ENVVAR_NOT_SET = """\
 The environment variable {0!r} is not set,
 and as such the configuration could not be loaded.
@@ -66,7 +64,7 @@ class BaseLoader(object):
         * What modules are imported to find tasks?
 
     """
-    builtin_modules = BUILTIN_MODULES
+    builtin_modules = frozenset()
     configured = False
     error_envvar_not_set = ERROR_ENVVAR_NOT_SET
     override_backends = {}
@@ -123,9 +121,10 @@ class BaseLoader(object):
     def import_default_modules(self):
         return [
             self.import_task_module(m) for m in (
-                set(maybe_list(self.app.conf.CELERY_IMPORTS))
-                | set(maybe_list(self.app.conf.CELERY_INCLUDE))
-                | self.builtin_modules)
+                tuple(self.builtin_modules) +
+                tuple(maybe_list(self.app.conf.CELERY_IMPORTS)) +
+                tuple(maybe_list(self.app.conf.CELERY_INCLUDE))
+            )
         ]
 
     def init_worker(self):

docs/configuration.rst

@@ -1103,6 +1103,8 @@ A sequence of modules to import when the worker starts.
 This is used to specify the task modules to import, but also
 to import signal handlers and additional remote control commands, etc.
 
+The modules will be imported in the original order.
+
 .. setting:: CELERY_INCLUDE
 
 CELERY_INCLUDE
@@ -1111,6 +1113,9 @@ CELERY_INCLUDE
 Exact same semantics as :setting:`CELERY_IMPORTS`, but can be used as a means
 to have different import categories.
 
+The modules in this setting are imported after the modules in
+:setting:`CELERY_IMPORTS`.
+
 .. setting:: CELERYD_FORCE_EXECV
 
 CELERYD_FORCE_EXECV

docs/history/changelog-3.0.rst

@@ -13,7 +13,21 @@ If you're looking for versions prior to 3.0.x you should go to :ref:`history`.
 
 3.0.16
 ======
-:release-date: 2013-03-07 XX:XX:XX X.X UTC
+:release-date: 2013-03-07 04:00:00 P.M UTC
+
+- Happy International Women's Day!
+
+    We have a long way to go, so this is a chance for you to get involved in one
+    of the organizations working for making our communities more
+    diverse.
+
+     - PyLadies — http://pyladies.com
+     - Girls Who Code — http://www.girlswhocode.com
+     - Women Who Code — http://www.meetup.com/Women-Who-Code-SF/
+
+- Now depends on :mod:`kombu` version 2.5.7
+
+- Now depends on :mod:`billiard` version 2.7.3.22
 
 - AMQP heartbeats are now disabled by default.
 
@@ -30,6 +44,14 @@ If you're looking for versions prior to 3.0.x you should go to :ref:`history`.
 - Worker: Now propagates connection errors occurring in timer callbacks,
   so that the connection can be reset.
 
+- The modules in :setting:`CELERY_IMPORTS` and :setting:`CELERY_INCLUDE`
+  are now imported in the original order (Issue #1161).
+
+    The modules in :setting:`CELERY_IMPORTS` will be imported first,
+    then continued by :setting:`CELERY_INCLUDE`.
+
+    Thanks to Joey Wilhelm.
+
 - New bash completion for ``celery`` available in the git repository:
 
     https://github.com/celery/celery/tree/3.0/extra/bash-completion
@@ -49,6 +71,21 @@ If you're looking for versions prior to 3.0.x you should go to :ref:`history`.
 
 - Chord unlock now handles errors occurring while calling the callback.
 
+- Generic worker init.d script: Status check is now performed by
+  querying the pid of the instance instead of sending messages.
+
+    Contributed by Milen Pavlov.
+
+- Improved init scripts for CentOS.
+
+    - Updated to support celery 3.x conventions.
+    - Now uses CentOS built-in ``status`` and ``killproc``
+    - Support for multi-node / multi-pid worker services.
+    - Standard color-coded CentOS service-init output.
+    - A test suite.
+
+    Contributed by Milen Pavlov.
+
 - ``ResultSet.join`` now always works with empty result set (Issue #1219).
 
 - A ``group`` consisting of a single task is now supported (Issue #1219).

docs/tutorials/daemonizing.rst

@@ -371,3 +371,9 @@ Windows
 See this excellent external tutorial:
 
 http://www.calazan.com/windows-tip-run-applications-in-the-background-using-task-scheduler/
+
+CentOS
+======
+In CentOS we can take advantage of built-in service helpers, such as the
+pid-based status checker function in ``/etc/init.d/functions``.
+See the sample script in http://github.com/celery/celery/tree/3.0/extra/centos/.

extra/centos/celeryd

@@ -0,0 +1,243 @@
+#!/bin/sh
+# ============================================
+# celeryd - Starts the Celery worker daemon.
+# ============================================
+#
+# :Usage: /etc/init.d/celeryd {start|stop|restart|status}
+# :Configuration file: /etc/sysconfig/celeryd
+#
+# See http://docs.celeryproject.org/en/latest/tutorials/daemonizing.html
+
+### BEGIN INIT INFO
+# Provides:          celeryd
+# Required-Start:    $network $local_fs $remote_fs
+# Required-Stop:     $network $local_fs $remote_fs
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: celery task worker daemon
+### END INIT INFO
+
+# Source the centos service helper functions
+source /etc/init.d/functions
+# NOTE: "set -e" does not work with the above functions,
+# which use non-zero return codes as non-error return conditions
+
+# some commands work asyncronously, so we'll wait this many seconds
+SLEEP_SECONDS=5
+
+DEFAULT_PID_FILE="/var/run/celery/%n.pid"
+DEFAULT_LOG_FILE="/var/log/celery/%n.log"
+DEFAULT_LOG_LEVEL="INFO"
+DEFAULT_NODES="celery"
+DEFAULT_CELERYD="-m celery.bin.celeryd_detach"
+
+CELERY_DEFAULTS=${CELERY_DEFAULTS:-"/etc/sysconfig/celeryd"}
+
+test -f "$CELERY_DEFAULTS" && . "$CELERY_DEFAULTS"
+
+# Set CELERY_CREATE_DIRS to always create log/pid dirs.
+CELERY_CREATE_DIRS=${CELERY_CREATE_DIRS:-0}
+CELERY_CREATE_RUNDIR=$CELERY_CREATE_DIRS
+CELERY_CREATE_LOGDIR=$CELERY_CREATE_DIRS
+if [ -z "$CELERYD_PID_FILE" ]; then
+    CELERYD_PID_FILE="$DEFAULT_PID_FILE"
+    CELERY_CREATE_RUNDIR=1
+fi
+if [ -z "$CELERYD_LOG_FILE" ]; then
+    CELERYD_LOG_FILE="$DEFAULT_LOG_FILE"
+    CELERY_CREATE_LOGDIR=1
+fi
+
+CELERYD_LOG_LEVEL=${CELERYD_LOG_LEVEL:-${CELERYD_LOGLEVEL:-$DEFAULT_LOG_LEVEL}}
+CELERYD_MULTI=${CELERYD_MULTI:-"celeryd-multi"}
+CELERYD=${CELERYD:-$DEFAULT_CELERYD}
+CELERYD_NODES=${CELERYD_NODES:-$DEFAULT_NODES}
+
+# This is used to change how Celery loads in the configs.  It does not need to
+# be set to be run.
+export CELERY_LOADER
+
+if [ -n "$2" ]; then
+    CELERYD_OPTS="$CELERYD_OPTS $2"
+fi
+
+CELERYD_LOG_DIR=`dirname $CELERYD_LOG_FILE`
+CELERYD_PID_DIR=`dirname $CELERYD_PID_FILE`
+
+# Extra start-stop-daemon options, like user/group.
+if [ -n "$CELERYD_USER" ]; then
+    DAEMON_OPTS="$DAEMON_OPTS --uid=$CELERYD_USER"
+fi
+if [ -n "$CELERYD_GROUP" ]; then
+    DAEMON_OPTS="$DAEMON_OPTS --gid=$CELERYD_GROUP"
+fi
+
+if [ -n "$CELERYD_CHDIR" ]; then
+    DAEMON_OPTS="$DAEMON_OPTS --workdir=\"$CELERYD_CHDIR\""
+fi
+
+check_dev_null() {
+    if [ ! -c /dev/null ]; then
+        echo "/dev/null is not a character device!"
+        exit 75  # EX_TEMPFAIL
+    fi
+}
+
+
+maybe_die() {
+    if [ $? -ne 0 ]; then
+        echo "Exiting: $* (errno $?)"
+        exit 77  # EX_NOPERM
+    fi
+}
+
+create_default_dir() {
+    if [ ! -d "$1" ]; then
+        echo "- Creating default directory: '$1'"
+        mkdir -p "$1"
+        maybe_die "Couldn't create directory $1"
+        echo "- Changing permissions of '$1' to 02755"
+        chmod 02755 "$1"
+        maybe_die "Couldn't change permissions for $1"
+        if [ -n "$CELERYD_USER" ]; then
+            echo "- Changing owner of '$1' to '$CELERYD_USER'"
+            chown "$CELERYD_USER" "$1"
+            maybe_die "Couldn't change owner of $1"
+        fi
+        if [ -n "$CELERYD_GROUP" ]; then
+            echo "- Changing group of '$1' to '$CELERYD_GROUP'"
+            chgrp "$CELERYD_GROUP" "$1"
+            maybe_die "Couldn't change group of $1"
+        fi
+    fi
+}
+
+
+check_paths() {
+    if [ $CELERY_CREATE_LOGDIR -eq 1 ]; then
+        create_default_dir "$CELERYD_LOG_DIR"
+    fi
+    if [ $CELERY_CREATE_RUNDIR -eq 1 ]; then
+        create_default_dir "$CELERYD_PID_DIR"
+    fi
+}
+
+create_paths() {
+    create_default_dir "$CELERYD_LOG_DIR"
+    create_default_dir "$CELERYD_PID_DIR"
+}
+
+export PATH="${PATH:+$PATH:}/usr/sbin:/sbin"
+
+
+_get_pid_files() {
+    [[ ! -d "$CELERYD_PID_DIR" ]] && return
+    echo $(ls -1 "$CELERYD_PID_DIR"/*.pid 2> /dev/null)
+}
+
+stop() {
+    local pid_files=$(_get_pid_files)
+    [[ -z "$pid_files" ]] && echo "celeryd is stopped" && return 0
+
+    local one_failed=
+    for pid_file in $pid_files; do
+        local pid=$(cat "$pid_file")
+        echo -n $"Stopping celeryd (pid $pid): "
+
+        # killproc comes from 'functions' and brings three nice features:
+        #  1. sending TERM, sleeping, then sleeping more if needed, then sending KILL
+        #  2. handling 'success' and 'failure' output
+        #  3. removes stale pid files, if any remain
+        killproc -p "$pid_file" -d "$SLEEP_SECONDS" celeryd || one_failed=true
+        echo
+    done
+
+    [[ "$one_failed" ]] && return 1 || return 0
+}
+
+start() {
+    echo -n $"Starting celeryd: "
+
+    # If Celery is already running, bail out
+    local pid_files=$(_get_pid_files)
+    if [[ "$pid_files" ]]; then
+        echo -n $"celeryd is already running. Use 'restart'."
+        failure
+        echo
+        return 1
+    fi
+
+    $CELERYD_MULTI start $CELERYD_NODES $DAEMON_OPTS        \
+                         --pidfile="$CELERYD_PID_FILE"      \
+                         --logfile="$CELERYD_LOG_FILE"      \
+                         --loglevel="$CELERYD_LOG_LEVEL"    \
+                         --cmd="$CELERYD"                   \
+                         --quiet                            \
+                         $CELERYD_OPTS
+
+    if [[ "$?" == "0" ]]; then
+        # Sleep a few seconds to give Celery a chance to initialize itself.
+        # This is useful to prevent scripts following this one from trying to
+        # use Celery (or its pid files) too early.
+        sleep $SLEEP_SECONDS
+        pid_files=$(_get_pid_files)
+        if [[ "$pid_files" ]]; then
+            for pid_file in $pid_files; do
+                local node=$(basename "$pid_file" .pid)
+                local pid=$(cat "$pid_file")
+                echo
+                echo -n "    $node (pid $pid):"
+                success
+            done
+            echo
+            return 0
+        else  # celeryd_multi succeeded but no pid files found
+            failure
+        fi
+    else  # celeryd_multi did not succeed
+        failure
+    fi
+    echo
+    return 1
+}
+
+check_status() {
+    local pid_files=$(_get_pid_files)
+    [[ -z "$pid_files" ]] && echo "celeryd is stopped" && return 1
+    for pid_file in $pid_files; do
+        local node=$(basename "$pid_file" .pid)
+        status -p "$pid_file" $"celeryd (node $node)" || return 1  # if one node is down celeryd is down
+    done
+    return 0
+}
+
+case "$1" in
+    start)
+        check_dev_null
+        check_paths
+        start
+    ;;
+
+    stop)
+        check_dev_null
+        check_paths
+        stop
+    ;;
+
+    status)
+        check_status
+    ;;
+
+    restart)
+        check_dev_null
+        check_paths
+        stop && start
+    ;;
+
+    *)
+        echo "Usage: /etc/init.d/celeryd {start|stop|restart|status}"
+        exit 3
+    ;;
+esac
+
+exit $?

extra/centos/celeryd.init

@@ -1,147 +0,0 @@
-#!/bin/sh
-### BEGIN INIT INFO
-# Provides: celeryd
-# Required-Start: $network $local_fs $remote_fs
-# Required-Stop: $network $local_fs $remote_fs
-# Default-Start: 2 3 4 5
-# Default-Stop: 0 1 6
-# Short-Description: celery task worker daemon
-### END INIT INFO
-#
-# ============================================
-# celeryd - Starts the Celery worker daemon.
-# ============================================
-#
-# :Usage: /etc/init.d/${basename $0} {start|stop|restart|status}
-# :Configuration file: /etc/sysconfig/celeryd
-#
-# To implement separate init scripts, do NOT copy this script.  Instead,
-# symlink it.  I.e., if my new application, "little-worker" needs an init, I
-# should just use:
-#
-#   ln -s /etc/init.d/celeryd /etc/init.d/little-worker
-#
-# You can then configure this by manipulating /etc/sysconfig/little-worker.
-#
-
-# Setting `prog` here allows you to symlink this init script, making it easy
-# to run multiple processes on the system.
-prog="$(basename $0)"
-
-# Source the centos stuff
-. /etc/init.d/functions
-
-# Also look at sysconfig; this is where environmental variables should be set
-# on RHEL systems.
-[ -f "/etc/sysconfig/$prog" ] && . /etc/sysconfig/$prog
-
-CELERYD=${CELERYD:-"-m celery worker --detach"}
-CELERY=${CELERY:-"/usr/bin/celery"}
-CELERYD_PID_FILE=${CELERYD_PID_FILE:-"/var/run/celery/$prog.pid"}
-CELERYD_LOG_FILE=${CELERYD_LOG_FILE:-"/var/log/celery/$prog.log"}
-CELERYD_LOG_LEVEL=${CELERYD_LOG_LEVEL:-"INFO"}
-
-# This is used to change how Celery loads in the configs.  It does not need to
-# be set to be run.
-export CELERY_LOADER
-
-start_workers () {
-    CELERYD_LOG_DIR=$(dirname $CELERYD_LOG_FILE)
-    CELERYD_PID_DIR=$(dirname $CELERYD_PID_FILE)
-    # Ensure that the directories exist.
-    mkdir -p $CELERYD_LOG_DIR $CELERYD_PID_DIR
-
-    # If we specified a user, and/or a group, chown as needed
-    if [ -n "$CELERYD_USER" ]; then
-        CHOWN_UG="${CELERYD_USER}"
-
-        # If the group is specified, also use that in the chown.
-        [ -n "$CELERYD_GROUP" ] && CHOWN_UG="$CHOWN_UG:$CELERYD_GROUP"
-
-        # Execute the chown on the directory only
-        chown $CHOWN_UG $CELERYD_LOG_DIR $CELERYD_PID_DIR
-
-        CELERYD_OPTS="$CELERYD_OPTS --uid=$CELERYD_USER"
-    fi
-
-    # If we need to be run from a specific location, cd to it before launch
-    if [ -n "$CELERYD_CHDIR" ]; then
-        cd $CELERYD_CHDIR
-    fi
-
-    log_message "Starting $prog"
-    $CELERY multi start $prog \
-                               --pidfile=$CELERYD_PID_FILE \
-                               --logfile=$CELERYD_LOG_FILE \
-                               --loglevel=$CELERYD_LOG_LEVEL \
-                               --cmd="$CELERYD" \
-                                --quiet \
-                               $CELERYD_OPTS
-    RETVAL=$?
-
-    if [ "$RETVAL" == "0" ]; then
-        touch /var/lock/subsys/$prog
-        success
-    else
-        failure
-    fi
-    echo
-}
-
-stop_workers () {
-    echo -n $"Stopping $prog: "
-
-    # If we haven't ended, explicitly kill it!
-    if [ ! -f $CELERYD_PID_FILE ] || [ ! -e /proc/$(cat $CELERYD_PID_FILE) ]; then
-        failure
-    echo
-        return
-    fi
-
-    # According to the latest Celery workers guide (3.0.x+), 
-    #  stopping workers should be via TERM signals
-    celerypids=$(cat $CELERYD_PID_FILE | xargs echo)
-    echo "Killing PIDs $celerypids"
-    log_message "Killing PIDs $celerypids ..." 
-    kill -s TERM $celerypids
-    RETVAL=$?
-
-    # SLeep a few seconds to make sure the process really is dead
-    sleep 3
-
-    # Now make sure that the process really does not exist
-    RETVAL=$(ps h -p $celerypids)
-    if [ "$RETVAL" == "" ]; then
-        rm -f /var/lock/subsys/$prog
-        log_message "SUCCESS killing PIDs $celerypids" 
-        success
-    else
-        log_message "FAILED killing PIDs $celerypids" 
-        failure
-    fi
-    echo
-}
-
-log_message() {
-    now=$(/bin/date -u "+%Y-%m-%d %H:%M:%S")
-    echo "[$now:] $1" >> $CELERYD_LOG_FILE
-
-}
-
-case "$1" in
-    start)
-        start_workers ;;
-    stop)
-        stop_workers ;;
-    status)
-        status -p $CELERYD_PID_FILE $prog ;;
-    restart)
-        stop_workers
-        start_workers ;;
-    *)
-        echo "Usage: /etc/init.d/$prog {start|stop|restart|status}"
-        exit 1
-    ;;
-esac
-
-exit 0

extra/centos/celeryd.sysconfig

@@ -1,37 +1,24 @@
-# Path to the virtualenv. This could be /usr if python
-#   is in /usr/bin
-#BIN_PATH="/path/to/.virtualenvs/myvenv"
+# In CentOS, contents should be placed in the file /etc/sysconfig/celeryd
 
-# Which Python to use
-#ENV_PYTHON="$BIN_PATH/bin/python"
+# Names of nodes to start (space-separated)
+#CELERYD_NODES="my_application-node_1"
 
-# Where to chdir before launching celeryd
-#CELERYD_CHDIR="$app_path/current"
+# Where to chdir at start. This could be the root of a virtualenv.
+#CELERYD_CHDIR="/path/to/my_application"
 
-# Path to celery - which might be in a virtualenv
-#CELERY="$BIN_PATH/bin/celery"
+# How to call celeryd-multi
+#CELERYD_MULTI="$CELERYD_CHDIR/bin/celeryd-multi"
 
-# Passed into celery multi
-#CELERYD="-m celery worker --detach"
+# Extra arguments
+#CELERYD_OPTS="--app=my_application.path.to.worker --time-limit=300 --concurrency=8 --loglevel=DEBUG"
 
-# Log and PID files
-#CELERYD_LOG_FILE="/path/to/var/log/celeryd/app_name-celeryworker.log"
-#CELERYD_PID_FILE="/path/to/var/run/celeryd/app_name-celeryworker.pid"
+# Create log/pid dirs, if they don't already exist
+#CELERY_CREATE_DIRS=1
 
-# Sets the verbosity of the celeryd logging.
-#CELERYD_LOG_LEVEL="INFO"
+# %n will be replaced with the nodename
+#CELERYD_LOG_FILE="/path/to/my_application/log/%n.log"
+#CELERYD_PID_FILE="/var/run/celery/%n.pid"
 
-# Define the loader that celeryd should use for loading in configs.
-#CELERY_LOADER=""
-
-# User and group information for directories
-#CELERYD_USER="celery"
-#CELERYD_GROUP="celery"
-
-# Default arguments to be passed into celeryd.
-#CELERYD_OPTS=""
-# e.g. add app option:
-#CELERYD="-A proj.tasks:app"
-
-# Set the task modules that you want to have celery load
-#CELERY_IMPORTS=("tasks", )
+# Workers run as an unprivileged user
+#CELERYD_USER=celery
+#CELERYD_GROUP=celery

extra/centos/test_celeryd.sh

@@ -0,0 +1,41 @@
+#!/bin/sh
+
+# If you make changes to the celeryd init script,
+# you can use this test script to verify you didn't break the universe
+
+SERVICE="celeryd"
+SERVICE_CMD="sudo /sbin/service $SERVICE"
+
+run_test() {
+    local msg="$1"
+    local cmd="$2"
+    local expected_retval="${3:-0}"
+    local n=${#msg}
+
+    echo
+    echo `printf "%$((${n}+4))s" | tr " " "#"`
+    echo "# $msg #"
+    echo `printf "%$((${n}+4))s" | tr " " "#"`
+
+    $cmd
+    local retval=$?
+    if [[ "$retval" == "$expected_retval" ]]; then
+        echo "[PASSED]"
+    else
+        echo "[FAILED]"
+        echo "Exit status: $retval, but expected: $expected_retval"
+        exit $retval
+    fi
+}
+
+run_test "stop should succeed" "$SERVICE_CMD stop" 0
+run_test "status on a stopped service should return 1" "$SERVICE_CMD status" 1
+run_test "stopping a stopped celery should not fail" "$SERVICE_CMD stop" 0
+run_test "start should succeed" "$SERVICE_CMD start" 0
+run_test "status on a running service should return 0" "$SERVICE_CMD status" 0
+run_test "starting a running service should fail" "$SERVICE_CMD start" 1
+run_test "restarting a running service should succeed" "$SERVICE_CMD restart" 0
+run_test "status on a restarted service should return 0" "$SERVICE_CMD status" 0
+run_test "stop should succeed" "$SERVICE_CMD stop" 0
+
+echo "All tests passed!"

extra/generic-init.d/celeryd

@@ -18,7 +18,8 @@
 # Short-Description: celery task worker daemon
 ### END INIT INFO
 
-#set -e
+# some commands work asyncronously, so we'll wait this many seconds
+SLEEP_SECONDS=5
 
 DEFAULT_PID_FILE="/var/run/celery/%N.pid"
 DEFAULT_LOG_FILE="/var/log/celery/%N.log"
@@ -26,14 +27,9 @@ DEFAULT_LOG_LEVEL="INFO"
 DEFAULT_NODES="celery"
 DEFAULT_CELERYD="-m celery worker --detach"
 
-# /etc/init.d/celeryd: start and stop the celery task worker daemon.
-
 CELERY_DEFAULTS=${CELERY_DEFAULTS:-"/etc/default/celeryd"}
 
 test -f "$CELERY_DEFAULTS" && . "$CELERY_DEFAULTS"
-if [ -f "/etc/default/celeryd" ]; then
-    . /etc/default/celeryd
-fi
 
 # Sets --app argument for CELERY_BIN
 CELERY_APP_ARG=""
@@ -59,7 +55,6 @@ CELERYD_LOG_LEVEL=${CELERYD_LOG_LEVEL:-${CELERYD_LOGLEVEL:-$DEFAULT_LOG_LEVEL}}
 CELERY_BIN=${CELERY_BIN:-"celery"}
 CELERYD_MULTI=${CELERYD_MULTI:-"$CELERY_BIN multi"}
 CELERYD=${CELERYD:-$DEFAULT_CELERYD}
-CELERYCTL=${CELERYCTL:=$CELERY_BIN}
 CELERYD_NODES=${CELERYD_NODES:-$DEFAULT_NODES}
 
 export CELERY_LOADER
@@ -138,8 +133,14 @@ create_paths() {
 export PATH="${PATH:+$PATH:}/usr/sbin:/sbin"
 
 
+_get_pid_files() {
+    [ ! -d "$CELERYD_PID_DIR" ] && return
+    echo `ls -1 "$CELERYD_PID_DIR"/*.pid 2> /dev/null`
+}
+
 stop_workers () {
     $CELERYD_MULTI stopwait $CELERYD_NODES --pidfile="$CELERYD_PID_FILE"
+    sleep $SLEEP_SECONDS
 }
 
 
@@ -151,6 +152,7 @@ start_workers () {
                          --cmd="$CELERYD"                   \
                          $CELERY_APP_ARG                    \
                          $CELERYD_OPTS
+    sleep $SLEEP_SECONDS
 }
 
 
@@ -162,8 +164,33 @@ restart_workers () {
                            --cmd="$CELERYD"                 \
                            $CELERY_APP_ARG                  \
                            $CELERYD_OPTS
+    sleep $SLEEP_SECONDS
 }
 
+check_status () {
+    local pid_files=`_get_pid_files`
+    [ -z "$pid_files" ] && echo "celeryd is stopped" && exit 1
+
+    local one_failed=
+    for pid_file in $pid_files; do
+        local node=`basename "$pid_file" .pid`
+        local pid=`cat "$pid_file"`
+        if [ -z "$pid" ] || [ "${pid//[0-9]/}" ]; then
+            echo "bad pid file ($pid_file)"
+        else
+            local failed=
+            kill -0 $pid 2> /dev/null || failed=true
+            if [ "$failed" ]; then
+                echo "celeryd (node $node) (pid $pid) is stopped, but pid file exists!"
+                one_failed=true
+            else
+                echo "celeryd (node $node) (pid $pid) is running..."
+            fi
+        fi
+    done
+
+    [ "$one_failed" ] && exit 1 || exit 0
+}
 
 
 case "$1" in
@@ -184,10 +211,7 @@ case "$1" in
     ;;
 
     status)
-        (
-            cd "$CELERYD_CHDIR"
-            $CELERYCTL $CELERY_APP_ARG status $CELERYCTL_OPTS
-        )
+        check_status
     ;;
 
     restart)

requirements/default.txt

@@ -1,3 +1,3 @@
 pytz
-billiard>=2.7.3.21
-kombu>=2.5.6
+billiard>=2.7.3.22
+kombu>=2.5.7

setup.cfg

@@ -15,5 +15,5 @@ upload-dir = docs/.build/html
 
 [bdist_rpm]
 requires = pytz
-           billiard >= 2.7.3.21
-           kombu >= 2.5.6
+           billiard >= 2.7.3.22
+           kombu >= 2.5.7