← Back to branch summary

~upstart-devel/upstart/upstart-jobs

« back to all changes in this revision

Viewing changes to utopic/etc/init.d/celeryd

  • Committer: Dimitri John Ledkov
  • Date: 2014-05-06 18:45:46 UTC
  • Revision ID: dimitri.ledkov@canonical.com-20140506184546-5toyx56xxrue0f0v
auto update

Show diffs side-by-side

added added

removed removed

Lines of Context:
utopic/etc/init.d/celeryd
 
1
#!/bin/sh -e
 
2
# ============================================
 
3
#  celeryd - Starts the Celery worker daemon.
 
4
# ============================================
 
5
#
 
6
# :Usage: /etc/init.d/celeryd {start|stop|force-reload|restart|try-restart|status}
 
7
# :Configuration file: /etc/default/celeryd
 
8
#
 
9
# See http://docs.celeryproject.org/en/latest/tutorials/daemonizing.html#generic-init-scripts
 
10
 
 
11
 
 
12
### BEGIN INIT INFO
 
13
# Provides:          celeryd
 
14
# Required-Start:    $network $local_fs $remote_fs
 
15
# Required-Stop:     $network $local_fs $remote_fs
 
16
# Default-Start:     2 3 4 5
 
17
# Default-Stop:      0 1 6
 
18
# Short-Description: celery task worker daemon
 
19
### END INIT INFO
 
20
#
 
21
#
 
22
# To implement separate init scripts, do NOT copy this script.  Instead,
 
23
# symlink it.  I.e., if my new application, "little-worker" needs an init, I
 
24
# should just use:
 
25
#
 
26
#   ln -s /etc/init.d/celeryd /etc/init.d/little-worker
 
27
#
 
28
# You can then configure this by manipulating /etc/default/little-worker.
 
29
#
 
30
# If you want to have separate LSB headers in each script you can source this
 
31
# script instead of symlinking:
 
32
#   # ...
 
33
#   ### END INIT INFO
 
34
#   source /etc/init.d/celeryd
 
35
#
 
36
# Setting `SCRIPT_NAME` here allows you to symlink/source this init script,
 
37
# making it easy to run multiple processes on the system.
 
38
 
 
39
. /lib/lsb/init-functions
 
40
 
 
41
SCRIPT_NAME="$(basename $0)"
 
42
 
 
43
DEFAULT_PID_FILE="/var/run/celery/${SCRIPT_NAME}/%n.pid"
 
44
DEFAULT_LOG_FILE="/var/log/celery/${SCRIPT_NAME}/%n.log"
 
45
DEFAULT_LOG_LEVEL="INFO"
 
46
DEFAULT_NODES="celery"
 
47
DEFAULT_CELERYD="-m celery worker --detach"
 
48
ENABLED="false"
 
49
 
 
50
CELERY_DEFAULTS=${CELERY_DEFAULTS:-"/etc/default/${SCRIPT_NAME}"}
 
51
 
 
52
[ -r "$CELERY_DEFAULTS" ] && . "$CELERY_DEFAULTS"
 
53
 
 
54
if [ "$ENABLED" != "true" ]; then
 
55
    echo "celery daemon disabled - see $CELERY_DEFAULTS"
 
56
    exit 0
 
57
fi
 
58
 
 
59
# Sets --app argument for CELERY_BIN
 
60
CELERY_APP_ARG=""
 
61
if [ ! -z "$CELERY_APP" ]; then
 
62
    CELERY_APP_ARG="--app=$CELERY_APP"
 
63
fi
 
64
 
 
65
 
 
66
# Set CELERY_CREATE_DIRS to always create log/pid dirs.
 
67
CELERY_CREATE_DIRS=${CELERY_CREATE_DIRS:-0}
 
68
CELERY_CREATE_RUNDIR=$CELERY_CREATE_DIRS
 
69
CELERY_CREATE_LOGDIR=$CELERY_CREATE_DIRS
 
70
if [ -z "$CELERYD_PID_FILE" ]; then
 
71
    CELERYD_PID_FILE="$DEFAULT_PID_FILE"
 
72
    CELERY_CREATE_RUNDIR=1
 
73
fi
 
74
if [ -z "$CELERYD_LOG_FILE" ]; then
 
75
    CELERYD_LOG_FILE="$DEFAULT_LOG_FILE"
 
76
    CELERY_CREATE_LOGDIR=1
 
77
fi
 
78
 
 
79
CELERYD_LOG_LEVEL=${CELERYD_LOG_LEVEL:-${CELERYD_LOGLEVEL:-$DEFAULT_LOG_LEVEL}}
 
80
CELERY_BIN=${CELERY_BIN:-"celery"}
 
81
CELERYD_MULTI=${CELERYD_MULTI:-"$CELERY_BIN multi"}
 
82
CELERYD_NODES=${CELERYD_NODES:-$DEFAULT_NODES}
 
83
 
 
84
export CELERY_LOADER
 
85
 
 
86
if [ -n "$2" ]; then
 
87
    CELERYD_OPTS="$CELERYD_OPTS $2"
 
88
fi
 
89
 
 
90
CELERYD_LOG_DIR=`dirname $CELERYD_LOG_FILE`
 
91
CELERYD_PID_DIR=`dirname $CELERYD_PID_FILE`
 
92
 
 
93
# Extra start-stop-daemon options, like user/group.
 
94
if [ -n "$CELERYD_USER" ]; then
 
95
    DAEMON_OPTS="$DAEMON_OPTS --uid=$CELERYD_USER"
 
96
fi
 
97
if [ -n "$CELERYD_GROUP" ]; then
 
98
    DAEMON_OPTS="$DAEMON_OPTS --gid=$CELERYD_GROUP"
 
99
fi
 
100
 
 
101
if [ -n "$CELERYD_CHDIR" ]; then
 
102
    DAEMON_OPTS="$DAEMON_OPTS --workdir=$CELERYD_CHDIR"
 
103
fi
 
104
 
 
105
 
 
106
check_dev_null() {
 
107
    if [ ! -c /dev/null ]; then
 
108
        echo "/dev/null is not a character device!"
 
109
        exit 75  # EX_TEMPFAIL
 
110
    fi
 
111
}
 
112
 
 
113
 
 
114
maybe_die() {
 
115
    if [ $? -ne 0 ]; then
 
116
        echo "Exiting: $* (errno $?)"
 
117
        exit 77  # EX_NOPERM
 
118
    fi
 
119
}
 
120
 
 
121
create_default_dir() {
 
122
    if [ ! -d "$1" ]; then
 
123
        echo "- Creating default directory: '$1'"
 
124
        mkdir -p "$1"
 
125
        maybe_die "Couldn't create directory $1"
 
126
        echo "- Changing permissions of '$1' to 02755"
 
127
        chmod 02755 "$1"
 
128
        maybe_die "Couldn't change permissions for $1"
 
129
        if [ -n "$CELERYD_USER" ]; then
 
130
            echo "- Changing owner of '$1' to '$CELERYD_USER'"
 
131
            chown "$CELERYD_USER" "$1"
 
132
            maybe_die "Couldn't change owner of $1"
 
133
        fi
 
134
        if [ -n "$CELERYD_GROUP" ]; then
 
135
            echo "- Changing group of '$1' to '$CELERYD_GROUP'"
 
136
            chgrp "$CELERYD_GROUP" "$1"
 
137
            maybe_die "Couldn't change group of $1"
 
138
        fi
 
139
    fi
 
140
}
 
141
 
 
142
 
 
143
check_paths() {
 
144
    if [ $CELERY_CREATE_LOGDIR -eq 1 ]; then
 
145
        create_default_dir "$CELERYD_LOG_DIR"
 
146
    fi
 
147
    if [ $CELERY_CREATE_RUNDIR -eq 1 ]; then
 
148
        create_default_dir "$CELERYD_PID_DIR"
 
149
    fi
 
150
}
 
151
 
 
152
create_paths() {
 
153
    create_default_dir "$CELERYD_LOG_DIR"
 
154
    create_default_dir "$CELERYD_PID_DIR"
 
155
}
 
156
 
 
157
export PATH="${PATH:+$PATH:}/usr/sbin:/sbin"
 
158
 
 
159
 
 
160
_get_pid_files() {
 
161
    [ ! -d "$CELERYD_PID_DIR" ] && return
 
162
    echo `ls -1 "$CELERYD_PID_DIR"/*.pid 2> /dev/null`
 
163
}
 
164
 
 
165
_get_pids() {
 
166
    local pid_files=
 
167
    pid_files=`_get_pid_files`
 
168
    [ -z "$pid_files" ] && echo "${SCRIPT_NAME} is stopped" && exit 1
 
169
 
 
170
    for pid_file in $pid_files; do
 
171
        local pid=`cat "$pid_file"`
 
172
        local cleaned_pid=`echo "$pid" | sed -e 's/[^0-9]//g'`
 
173
        if [ -z "$pid" ] || [ "$cleaned_pid" != "$pid" ]; then
 
174
            echo "bad pid file ($pid_file)"
 
175
            one_failed=true
 
176
        else
 
177
            echo "$pid"
 
178
        fi
 
179
    done
 
180
}
 
181
 
 
182
_get_worker_pids() {
 
183
    local pids=
 
184
    pids=`_get_pids`
 
185
    local worker_pids=
 
186
    for pid in $pids; do
 
187
        worker_pids=`ps h --ppid $pid -o pid`
 
188
        [ "$worker_pids" ] && echo "$worker_pids" || one_failed=true
 
189
    done
 
190
}
 
191
 
 
192
 
 
193
start_workers () {
 
194
    if [ ! -z "$CELERYD_ULIMIT" ]; then
 
195
        ulimit $CELERYD_ULIMIT
 
196
    fi
 
197
    $CELERYD_MULTI $* start $CELERYD_NODES $DAEMON_OPTS     \
 
198
                         --pidfile="$CELERYD_PID_FILE"      \
 
199
                         --logfile="$CELERYD_LOG_FILE"      \
 
200
                         --loglevel="$CELERYD_LOG_LEVEL"    \
 
201
                         $CELERY_APP_ARG                    \
 
202
                         $CELERYD_OPTS
 
203
}
 
204
 
 
205
 
 
206
dryrun () {
 
207
    (C_FAKEFORK=1 start_workers --verbose)
 
208
}
 
209
 
 
210
 
 
211
stop_workers () {
 
212
    $CELERYD_MULTI stopwait $CELERYD_NODES --pidfile="$CELERYD_PID_FILE"
 
213
}
 
214
 
 
215
 
 
216
restart_workers () {
 
217
    $CELERYD_MULTI restart $CELERYD_NODES $DAEMON_OPTS      \
 
218
                           --pidfile="$CELERYD_PID_FILE"    \
 
219
                           --logfile="$CELERYD_LOG_FILE"    \
 
220
                           --loglevel="$CELERYD_LOG_LEVEL"  \
 
221
                           $CELERY_APP_ARG                  \
 
222
                           $CELERYD_OPTS
 
223
}
 
224
 
 
225
 
 
226
kill_workers() {
 
227
    $CELERYD_MULTI kill $CELERYD_NODES --pidfile="$CELERYD_PID_FILE"
 
228
}
 
229
 
 
230
 
 
231
restart_workers_graceful () {
 
232
    local worker_pids=
 
233
    worker_pids=`_get_worker_pids`
 
234
    [ "$one_failed" ] && exit 1
 
235
 
 
236
    for worker_pid in $worker_pids; do
 
237
        local failed=
 
238
        kill -HUP $worker_pid 2> /dev/null || failed=true
 
239
        if [ "$failed" ]; then
 
240
            echo "${SCRIPT_NAME} worker (pid $worker_pid) could not be restarted"
 
241
            one_failed=true
 
242
        else
 
243
            echo "${SCRIPT_NAME} worker (pid $worker_pid) received SIGHUP"
 
244
        fi
 
245
    done
 
246
 
 
247
    [ "$one_failed" ] && exit 1 || exit 0
 
248
}
 
249
 
 
250
 
 
251
check_status () {
 
252
    local pid_files=
 
253
    pid_files=`_get_pid_files`
 
254
    [ -z "$pid_files" ] && echo "${SCRIPT_NAME} not running (no pidfile)" && exit 1
 
255
 
 
256
    local one_failed=
 
257
    for pid_file in $pid_files; do
 
258
        local node=`basename "$pid_file" .pid`
 
259
        local pid=`cat "$pid_file"`
 
260
        local cleaned_pid=`echo "$pid" | sed -e 's/[^0-9]//g'`
 
261
        if [ -z "$pid" ] || [ "$cleaned_pid" != "$pid" ]; then
 
262
            echo "bad pid file ($pid_file)"
 
263
        else
 
264
            local failed=
 
265
            kill -0 $pid 2> /dev/null || failed=true
 
266
            if [ "$failed" ]; then
 
267
                echo "${SCRIPT_NAME} (node $node) (pid $pid) is stopped, but pid file exists!"
 
268
                one_failed=true
 
269
            else
 
270
                echo "${SCRIPT_NAME} (node $node) (pid $pid) is running..."
 
271
            fi
 
272
        fi
 
273
    done
 
274
 
 
275
    [ "$one_failed" ] && exit 1 || exit 0
 
276
}
 
277
 
 
278
 
 
279
case "$1" in
 
280
    start)
 
281
        check_dev_null
 
282
        check_paths
 
283
        start_workers
 
284
    ;;
 
285
 
 
286
    stop)
 
287
        check_dev_null
 
288
        check_paths
 
289
        stop_workers
 
290
    ;;
 
291
 
 
292
    reload|force-reload)
 
293
        echo "Use restart"
 
294
    ;;
 
295
 
 
296
    status)
 
297
        check_status
 
298
    ;;
 
299
 
 
300
    restart)
 
301
        check_dev_null
 
302
        check_paths
 
303
        restart_workers
 
304
    ;;
 
305
 
 
306
    graceful)
 
307
        check_dev_null
 
308
        restart_workers_graceful
 
309
    ;;
 
310
 
 
311
    kill)
 
312
        check_dev_null
 
313
        kill_workers
 
314
    ;;
 
315
 
 
316
    dryrun)
 
317
        check_dev_null
 
318
        dryrun
 
319
    ;;
 
320
 
 
321
    try-restart)
 
322
        check_dev_null
 
323
        check_paths
 
324
        restart_workers
 
325
    ;;
 
326
 
 
327
    create-paths)
 
328
        check_dev_null
 
329
        create_paths
 
330
    ;;
 
331
 
 
332
    check-paths)
 
333
        check_dev_null
 
334
        check_paths
 
335
    ;;
 
336
 
 
337
    *)
 
338
        echo "Usage: /etc/init.d/${SCRIPT_NAME} {start|stop|restart|graceful|kill|dryrun|create-paths}"
 
339
        exit 64  # EX_USAGE
 
340
    ;;
 
341
esac
 
342
 
 
343
exit 0