Daemonizing celery

Question

Following instructions found here, I copied the script from github into /etc/init.d/celeryd, then made it executable;

$ ll /etc/init.d/celeryd
-rwxr-xr-x 1 root root 9481 Feb 19 11:27 /etc/init.d/celeryd*

I created config file /etc/default/celeryd as per instructions:

# Names of nodes to start
#   most will only start one node:
#CELERYD_NODES="worker1"
#   but you can also start multiple and configure settings
#   for each in CELERYD_OPTS (see `celery multi --help` for examples).
CELERYD_NODES="worker1 worker2 worker3"

# Absolute or relative path to the 'celery' command:
CELERY_BIN="/usr/local/bin/celery"
#CELERY_BIN="/virtualenvs/def/bin/celery"

# App instance to use
# comment out this line if you don't use an app
#CELERY_APP="proj"
# or fully qualified:
#CELERY_APP="proj.tasks:app"

# Where to chdir at start.
CELERYD_CHDIR="/path/to/folder/containing/tasks/"

# Extra command-line arguments to the worker
CELERYD_OPTS="--time-limit=3000 --concurrency=3 --config=celeryconfig"

# %N will be replaced with the first part of the nodename.
CELERYD_LOG_FILE="/var/log/celery/%N.log"
CELERYD_PID_FILE="/var/run/celery/%N.pid"

# Workers should run as an unprivileged user.
#   You need to create this user manually (or you can choose
#   a user/group combination that already exists, e.g. nobody).
CELERYD_USER="celery"
CELERYD_GROUP="celery"

# If enabled pid and log directories will be created if missing,
# and owned by the userid/group configured.
CELERY_CREATE_DIRS=1

Note: I added the --config=celeryconfig part in CELERYD_OPTS.

I created a new user celery with

sudo useradd -N -M --system -s /bin/false celery

and then created group celery and added user to it:

$ id celery
uid=999(celery) gid=1005(celery) groups=1005(celery)

I used chown celery:celery for folders:

/var/run/celery/

/var/log/celery/

When I try to start the service, I get no indication of error:

$ sudo service celeryd start
celery init v10.0.
Using config script: /etc/default/celeryd

but status gives me "no pids were found":

$ sudo service celeryd status
celery init v10.0.
Using config script: /etc/default/celeryd
celeryd is stopped: no pids were found

and indeed, ps -ef gives no results and no PID file or log files are created:

$ ll /var/run/celery
total 0
drwxr-sr-x  2 celery celery  40 Feb 19 14:13 ./
drwxr-xr-x 16 root   root   620 Feb 19 12:35 ../

$ ll /var/log/celery
total 8
drwxr-sr-x  2 celery celery 4096 Feb 19 14:13 ./
drwxr-xr-x 13 root   root   4096 Feb 19 11:37 ../

Additional info:

$ pip freeze | grep celery
celery==3.1.9

What am I missing? Where should I be looking for more clues as to why celeryd is not starting?

Answer 1

I have experienced the same issue. Even if I had tried to run with root user, I couldn't start any worker. Then I came across this answer https://groups.google.com/forum/#!topic/celery-users/s8OFSdWdHo8 It basically says the user who will run workers should have a home directory.

After creating another user with a home directory, I was able to start workers.

Answer 2

I used a slightly different version of the init script, provided here:

#!/bin/sh -e
# ============================================
#  celeryd - Starts the Celery worker daemon.
# ============================================
#
# :Usage: /etc/init.d/celeryd {start|stop|force-reload|restart|try-restart|status}
# :Configuration file: /etc/default/celeryd
#
# See http://docs.celeryproject.org/en/latest/tutorials/daemonizing.html#generic-init-scripts


### 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
#
#
# 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/default/little-worker.
#
# If you want to have separate LSB headers in each script you can source this
# script instead of symlinking:
#   # ...
#   ### END INIT INFO
#   source /etc/init.d/celeryd
#
# Setting `SCRIPT_NAME` here allows you to symlink/source this init script,
# making it easy to run multiple processes on the system.
SCRIPT_NAME="$(basename $0)"

DEFAULT_PID_FILE="/var/run/celery/${SCRIPT_NAME}/%n.pid"
DEFAULT_LOG_FILE="/var/log/celery/${SCRIPT_NAME}/%n.log"
DEFAULT_LOG_LEVEL="INFO"
DEFAULT_NODES="celery"
DEFAULT_CELERYD="-m celery worker --detach"

CELERY_DEFAULTS=${CELERY_DEFAULTS:-"/etc/default/${SCRIPT_NAME}"}

test -f "$CELERY_DEFAULTS" && . "$CELERY_DEFAULTS"

# Sets --app argument for CELERY_BIN
CELERY_APP_ARG=""
if [ ! -z "$CELERY_APP" ]; then
   CELERY_APP_ARG="--app=$CELERY_APP"
fi


# 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}}
CELERY_BIN=${CELERY_BIN:-"celery"}
CELERYD_MULTI=${CELERYD_MULTI:-"$CELERY_BIN multi"}
CELERYD_NODES=${CELERYD_NODES:-$DEFAULT_NODES}

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`
}

_get_pids() {
   local pid_files=
   pid_files=`_get_pid_files`
   [ -z "$pid_files" ] && echo "${SCRIPT_NAME} is stopped" && exit 1

   for pid_file in $pid_files; do
       local pid=`cat "$pid_file"`
       local cleaned_pid=`echo "$pid" | sed -e 's/[^0-9]//g'`
       if [ -z "$pid" ] || [ "$cleaned_pid" != "$pid" ]; then
           echo "bad pid file ($pid_file)"
           one_failed=true
       else
           echo "$pid"
       fi
   done
}

_get_worker_pids() {
   local pids=
   pids=`_get_pids`
   local worker_pids=
   for pid in $pids; do
       worker_pids=`ps h --ppid $pid -o pid`
       [ "$worker_pids" ] && echo "$worker_pids" || one_failed=true
   done
}


start_workers () {
   if [ -z "$CELERYD_ULIMIT" ]; then
       ulimit $CELERYD_ULIMIT
   fi
   $CELERYD_MULTI $* start $CELERYD_NODES $DAEMON_OPTS     \
                        --pidfile="$CELERYD_PID_FILE"      \
                        --logfile="$CELERYD_LOG_FILE"      \
                        --loglevel="$CELERYD_LOG_LEVEL"    \
                        $CELERY_APP_ARG                    \
                        $CELERYD_OPTS
}


dryrun () {
   (C_FAKEFORK=1 start_workers --verbose)
}


stop_workers () {
   $CELERYD_MULTI stopwait $CELERYD_NODES --pidfile="$CELERYD_PID_FILE"
}


restart_workers () {
   $CELERYD_MULTI restart $CELERYD_NODES $DAEMON_OPTS      \
                          --pidfile="$CELERYD_PID_FILE"    \
                          --logfile="$CELERYD_LOG_FILE"    \
                          --loglevel="$CELERYD_LOG_LEVEL"  \
                          $CELERY_APP_ARG                  \
                          $CELERYD_OPTS
}


kill_workers() {
   $CELERYD_MULTI kill $CELERYD_NODES --pidfile="$CELERYD_PID_FILE"
}


restart_workers_graceful () {
   local worker_pids=
   worker_pids=`_get_worker_pids`
   [ "$one_failed" ] && exit 1

   for worker_pid in $worker_pids; do
       local failed=
       kill -HUP $worker_pid 2> /dev/null || failed=true
       if [ "$failed" ]; then
           echo "${SCRIPT_NAME} worker (pid $worker_pid) could not be restarted"
           one_failed=true
       else
           echo "${SCRIPT_NAME} worker (pid $worker_pid) received SIGHUP"
       fi
   done

   [ "$one_failed" ] && exit 1 || exit 0
}


check_status () {
   local pid_files=
   pid_files=`_get_pid_files`
   [ -z "$pid_files" ] && echo "${SCRIPT_NAME} not running (no pidfile)" && exit 1

   local one_failed=
   for pid_file in $pid_files; do
       local node=`basename "$pid_file" .pid`
       local pid=`cat "$pid_file"`
       local cleaned_pid=`echo "$pid" | sed -e 's/[^0-9]//g'`
       if [ -z "$pid" ] || [ "$cleaned_pid" != "$pid" ]; then
           echo "bad pid file ($pid_file)"
       else
           local failed=
           kill -0 $pid 2> /dev/null || failed=true
           if [ "$failed" ]; then
               echo "${SCRIPT_NAME} (node $node) (pid $pid) is stopped, but pid file exists!"
               one_failed=true
           else
               echo "${SCRIPT_NAME} (node $node) (pid $pid) is running..."
           fi
       fi
   done

   [ "$one_failed" ] && exit 1 || exit 0
}


case "$1" in
   start)
       check_dev_null
       check_paths
       start_workers
   ;;

   stop)
       check_dev_null
       check_paths
       stop_workers
   ;;

   reload|force-reload)
       echo "Use restart"
   ;;

   status)
       check_status
   ;;

   restart)
       check_dev_null
       check_paths
       restart_workers
   ;;

   graceful)
       check_dev_null
       restart_workers_graceful
   ;;

   kill)
       check_dev_null
       kill_workers
   ;;

   dryrun)
       check_dev_null
       dryrun
   ;;

   try-restart)
       check_dev_null
       check_paths
       restart_workers
   ;;

   create-paths)
       check_dev_null
       create_paths
   ;;

   check-paths)
       check_dev_null
       check_paths
   ;;

   *)
       echo "Usage: /etc/init.d/${SCRIPT_NAME} {start|stop|restart|graceful|kill|dryrun|create-paths}"
       exit 64  # EX_USAGE
   ;;
esac

exit 0

Running it with the dryrun option gave me the exact command the init was constructing.

Running that command after removing the two below options:

--detach
--logfile

allowed me to run it in console and observe the python error trace.

It ended up being I had to reinstall the redis module (that I use as backend) by pip

I will diff the two init scripts to end up with a mixture of them.

Answer 3

I replicated your steps and it resulted in the same issue. The problem was the celery user not having a shell.

sudo useradd -N -M --system -s /bin/false celery

Changing -s /bin/false to -s /bin/bash fixed the issue. The reason being is that the celeryd init script uses the celery user's shell to execute celery commands. Without a shell, the su command below exits silently.

_chuid () {
    su "$CELERYD_USER" -c "$CELERYD_MULTI $*"
}