main.c

   1 /* beanstalk - fast, general-purpose work queue */
   2
   3 /* Copyright (C) 2007 Keith Rarick and Philotic Inc.
   4
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <signal.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <errno.h>
  23 #include <sys/stat.h>
  24 #include <unistd.h>
  25 #include <pwd.h>
  26 #include <fcntl.h>
  27 #include "sd-daemon.h"
  28 #include "dat.h"
  29
  30 static char *user = NULL;
  31 static int detach = 0;
  32 static char *port = "11300";
  33 static char *host_addr;
  34
  35 static void
  36 nullfd(int fd, int flags)
  37 {
  38     int r;
  39
  40     close(fd);
  41     r = open("/dev/null", flags);
  42     if (r != fd) twarn("open(\"/dev/null\")"), exit(1);
  43 }
  44
  45 static void
  46 dfork()
  47 {
  48     pid_t p;
  49
  50     p = fork();
  51     if (p == -1) exit(1);
  52     if (p) exit(0);
  53 }
  54
  55 static void
  56 daemonize()
  57 {
  58     int r;
  59
  60     r = chdir("/");
  61     if (r) return twarn("chdir");
  62
  63     nullfd(0, O_RDONLY);
  64     nullfd(1, O_WRONLY);
  65     nullfd(2, O_WRONLY);
  66     umask(0);
  67     dfork();
  68     setsid();
  69     dfork();
  70 }
  71
  72 static void
  73 su(const char *user) {
  74     int r;
  75     struct passwd *pwent;
  76
  77     errno = 0;
  78     pwent = getpwnam(user);
  79     if (errno) twarn("getpwnam(\"%s\")", user), exit(32);
  80     if (!pwent) twarnx("getpwnam(\"%s\"): no such user", user), exit(33);
  81
  82     r = setgid(pwent->pw_gid);
  83     if (r == -1) twarn("setgid(%d \"%s\")", pwent->pw_gid, user), exit(34);
  84
  85     r = setuid(pwent->pw_uid);
  86     if (r == -1) twarn("setuid(%d \"%s\")", pwent->pw_uid, user), exit(34);
  87 }
  88
  89 void
  90 exit_cleanly(int sig)
  91 {
  92     binlog_shutdown();
  93     exit(0);
  94 }
  95
  96
  97 static void
  98 set_sig_handlers()
  99 {
 100     int r;
 101     struct sigaction sa;
 102
 103     sa.sa_handler = SIG_IGN;
 104     sa.sa_flags = 0;
 105     r = sigemptyset(&sa.sa_mask);
 106     if (r == -1) twarn("sigemptyset()"), exit(111);
 107
 108     r = sigaction(SIGPIPE, &sa, 0);
 109     if (r == -1) twarn("sigaction(SIGPIPE)"), exit(111);
 110
 111     sa.sa_handler = enter_drain_mode;
 112     r = sigaction(SIGUSR1, &sa, 0);
 113     if (r == -1) twarn("sigaction(SIGUSR1)"), exit(111);
 114
 115     sa.sa_handler = exit_cleanly;
 116     r = sigaction(SIGINT, &sa, 0);
 117     if (r == -1) twarn("sigaction(SIGINT)"), exit(111);
 118
 119     sa.sa_handler = exit_cleanly;
 120     r = sigaction(SIGTERM, &sa, 0);
 121     if (r == -1) twarn("sigaction(SIGTERM)"), exit(111);
 122 }
 123
 124 static void
 125 usage(char *msg, char *arg)
 126 {
 127     if (arg) warnx("%s: %s", msg, arg);
 128     fprintf(stderr, "Use: %s [OPTIONS]\n"
 129             "\n"
 130             "Options:\n"
 131             " -d       detach\n"
 132             " -b DIR   binlog directory (must be absolute path if used with -d)\n"
 133             " -f MS    fsync at most once every MS milliseconds"
 134                        " (use -f 0 for \"always fsync\")\n"
 135             " -F       never fsync (default)\n"
 136             " -l ADDR  listen on address (default is 0.0.0.0)\n"
 137             " -p PORT  listen on port (default is 11300)\n"
 138             " -u USER  become user and group\n"
 139             " -z BYTES set the maximum job size in bytes (default is %d)\n"
 140             " -s BYTES set the size of each binlog file (default is %d)\n"
 141             "            (will be rounded up to a multiple of 512 bytes)\n"
 142             " -v       show version information\n"
 143             " -h       show this help\n",
 144             progname, JOB_DATA_SIZE_LIMIT_DEFAULT, BINLOG_SIZE_LIMIT_DEFAULT);
 145     exit(arg ? 5 : 0);
 146 }
 147
 148 static size_t
 149 parse_size_t(char *str)
 150 {
 151     char r, x;
 152     size_t size;
 153
 154     r = sscanf(str, "%zu%c", &size, &x);
 155     if (1 != r) usage("invalid size", str);
 156     return size;
 157 }
 158
 159 static char *
 160 require_arg(char *opt, char *arg)
 161 {
 162     if (!arg) usage("option requires an argument", opt);
 163     return arg;
 164 }
 165
 166 static void
 167 warn_systemd_ignored_option(char *opt, char *arg)
 168 {
 169     if (sd_listen_fds(0) > 0) {
 170         warnx("inherited listen fd; ignoring option: %s %s", opt, arg);
 171     }
 172 }
 173
 174 static void
 175 opts(int argc, char **argv)
 176 {
 177     int i;
 178
 179     for (i = 1; i < argc; ++i) {
 180         if (argv[i][0] != '-') usage("unknown option", argv[i]);
 181         if (argv[i][1] == 0 || argv[i][2] != 0) usage("unknown option",argv[i]);
 182         switch (argv[i][1]) {
 183             case 'd':
 184                 detach = 1;
 185                 break;
 186             case 'p':
 187                 port = require_arg("-p", argv[++i]);
 188                 warn_systemd_ignored_option("-p", argv[i]);
 189                 break;
 190             case 'l':
 191                 host_addr = require_arg("-l", argv[++i]);
 192                 warn_systemd_ignored_option("-l", argv[i]);
 193                 break;
 194             case 'z':
 195                 job_data_size_limit = parse_size_t(require_arg("-z",
 196                                                                argv[++i]));
 197                 break;
 198             case 's':
 199                 binlog_size_limit = parse_size_t(require_arg("-s", argv[++i]));
 200                 break;
 201             case 'f':
 202                 fsync_throttle_ms = parse_size_t(require_arg("-f", argv[++i]));
 203                 enable_fsync = 1;
 204                 break;
 205             case 'F':
 206                 enable_fsync = 0;
 207                 break;
 208             case 'u':
 209                 user = require_arg("-u", argv[++i]);
 210                 break;
 211             case 'b':
 212                 binlog_dir = require_arg("-b", argv[++i]);
 213                 break;
 214             case 'h':
 215                 usage(NULL, NULL);
 216             case 'v':
 217                 printf("beanstalkd %s\n", version);
 218                 exit(0);
 219             default:
 220                 usage("unknown option", argv[i]);
 221         }
 222     }
 223 }
 224
 225 int
 226 main(int argc, char **argv)
 227 {
 228     int r;
 229     Srv s = {};
 230     struct job binlog_jobs = {};
 231
 232     progname = argv[0];
 233     opts(argc, argv);
 234
 235     if (detach && binlog_dir) {
 236         if (binlog_dir[0] != '/') {
 237             warnx("The -b option requires an absolute path when used with -d.");
 238             usage("Path is not absolute", binlog_dir);
 239         }
 240     }
 241
 242     r = make_server_socket(host_addr, port);
 243     if (r == -1) twarnx("make_server_socket()"), exit(111);
 244     s.sock.fd = r;
 245
 246     prot_init();
 247
 248     /* We want to make sure that only one beanstalkd tries to use the binlog
 249      * directory at a time. So acquire a lock now and never release it. */
 250     if (binlog_dir) {
 251         r = binlog_lock();
 252         if (!r) twarnx("failed to lock binlog dir %s", binlog_dir), exit(10);
 253     }
 254
 255     if (user) su(user);
 256     set_sig_handlers();
 257
 258     if (binlog_dir) {
 259         binlog_jobs.prev = binlog_jobs.next = &binlog_jobs;
 260         binlog_init(&binlog_jobs);
 261         prot_replay_binlog(&binlog_jobs);
 262     }
 263
 264     if (detach) {
 265         daemonize();
 266     }
 267
 268     srv(&s);
 269     binlog_shutdown();
 270     return 0;
 271 }