make procd wait for ubus to come up

[project/procd.git] / service / instance.c

diff --git a/service/instance.c b/service/instance.c
index 3e784bf..6dfc61b 100644 (file)
--- a/service/instance.c
+++ b/service/instance.c
@@ -19,6 +19,7 @@
 #include <unistd.h>
 #include <stdint.h>
 #include <fcntl.h>
+#include <pwd.h>
 
 #include <libubox/md5.h>
 
@@ -38,6 +39,9 @@ enum {
        INSTANCE_ATTR_RESPAWN,
        INSTANCE_ATTR_NICE,
        INSTANCE_ATTR_LIMITS,
+       INSTANCE_ATTR_WATCH,
+       INSTANCE_ATTR_ERROR,
+       INSTANCE_ATTR_USER,
        __INSTANCE_ATTR_MAX
 };
 
@@ -51,6 +55,9 @@ static const struct blobmsg_policy instance_attr[__INSTANCE_ATTR_MAX] = {
        [INSTANCE_ATTR_RESPAWN] = { "respawn", BLOBMSG_TYPE_ARRAY },
        [INSTANCE_ATTR_NICE] = { "nice", BLOBMSG_TYPE_INT32 },
        [INSTANCE_ATTR_LIMITS] = { "limits", BLOBMSG_TYPE_TABLE },
+       [INSTANCE_ATTR_WATCH] = { "watch", BLOBMSG_TYPE_ARRAY },
+       [INSTANCE_ATTR_ERROR] = { "error", BLOBMSG_TYPE_ARRAY },
+       [INSTANCE_ATTR_USER] = { "user", BLOBMSG_TYPE_STRING },
 };
 
 struct instance_netdev {
@@ -91,6 +98,7 @@ instance_limits(const char *limit, const char *value)
 {
        int i;
        struct rlimit rlim;
+       unsigned long cur, max;
 
        for (i = 0; rlimit_names[i].name != NULL; i++) {
                if (strcmp(rlimit_names[i].name, limit))
@@ -98,10 +106,20 @@ instance_limits(const char *limit, const char *value)
                if (!strcmp(value, "unlimited")) {
                        rlim.rlim_cur = RLIM_INFINITY;
                        rlim.rlim_max = RLIM_INFINITY;
+               } else {
+                       if (getrlimit(rlimit_names[i].resource, &rlim))
+                               return;
+
+                       cur = rlim.rlim_cur;
+                       max = rlim.rlim_max;
+
+                       if (sscanf(value, "%lu %lu", &cur, &max) < 1)
+                               return;
+
+                       rlim.rlim_cur = cur;
+                       rlim.rlim_max = max;
                }
-               else if (getrlimit(rlimit_names[i].resource, &rlim) ||
-                        sscanf(value, "%lu %lu", &rlim.rlim_cur, &rlim.rlim_max) == 0)
-                       return;
+
                setrlimit(rlimit_names[i].resource, &rlim);
                return;
        }
@@ -143,6 +161,10 @@ instance_run(struct service_instance *in)
                if (fd > STDERR_FILENO)
                        close(fd);
        }
+       if (in->uid || in->gid) {
+               setuid(in->uid);
+               setgid(in->gid);
+       }
        execvp(argv[0], argv);
        exit(127);
 }
@@ -152,6 +174,11 @@ instance_start(struct service_instance *in)
 {
        int pid;
 
+       if (!avl_is_empty(&in->errors.avl)) {
+               LOG("Not starting instance %s::%s, an error was indicated\n", in->srv->name, in->name);
+               return;
+       }
+
        if (in->proc.pending)
                return;
 
@@ -175,6 +202,7 @@ instance_start(struct service_instance *in)
        in->proc.pid = pid;
        clock_gettime(CLOCK_MONOTONIC, &in->start);
        uloop_process_add(&in->proc);
+       service_event("instance.start", in->srv->name, in->name);
 }
 
 static void
@@ -223,6 +251,7 @@ instance_exit(struct uloop_process *p, int ret)
                        uloop_timeout_set(&in->timeout, in->respawn_timeout * 1000);
                }
        }
+       service_event("instance.stop", in->srv->name, in->name);
 }
 
 void
@@ -269,9 +298,18 @@ instance_config_changed(struct service_instance *in, struct service_instance *in
        if (in->nice != in_new->nice)
                return true;
 
+       if (in->uid != in_new->uid)
+               return true;
+
+       if (in->gid != in_new->gid)
+               return true;
+
        if (!blobmsg_list_equal(&in->limits, &in_new->limits))
                return true;
 
+       if (!blobmsg_list_equal(&in->errors, &in_new->errors))
+               return true;
+
        return false;
 }
 
@@ -334,6 +372,15 @@ instance_file_update(struct blobmsg_list_node *l)
        close(fd);
 }
 
+static void
+instance_fill_any(struct blobmsg_list *l, struct blob_attr *cur)
+{
+       if (!cur)
+               return;
+
+       blobmsg_list_fill(l, blobmsg_data(cur), blobmsg_data_len(cur), false);
+}
+
 static bool
 instance_fill_array(struct blobmsg_list *l, struct blob_attr *cur, blobmsg_update_cb cb, bool array)
 {
@@ -397,23 +444,36 @@ instance_config_parse(struct service_instance *in)
                in->respawn_retry = vals[2];
        }
        if (tb[INSTANCE_ATTR_TRIGGER]) {
-               in->trigger = malloc(blob_pad_len(tb[INSTANCE_ATTR_TRIGGER]));
-               if (!in->trigger)
-                       return -1;
-               memcpy(in->trigger, tb[INSTANCE_ATTR_TRIGGER], blob_pad_len(tb[INSTANCE_ATTR_TRIGGER]));
+               in->trigger = tb[INSTANCE_ATTR_TRIGGER];
                trigger_add(in->trigger, in);
        }
 
+       if (tb[INSTANCE_ATTR_WATCH]) {
+               blobmsg_for_each_attr(cur2, tb[INSTANCE_ATTR_WATCH], rem) {
+                       if (blobmsg_type(cur2) != BLOBMSG_TYPE_STRING)
+                               continue;
+                       DEBUG(3, "watch for %s\n", blobmsg_get_string(cur2));
+                       watch_add(blobmsg_get_string(cur2), in);
+               }
+       }
+
        if ((cur = tb[INSTANCE_ATTR_NICE])) {
                in->nice = (int8_t) blobmsg_get_u32(cur);
                if (in->nice < -20 || in->nice > 20)
                        return false;
        }
 
-       if (!instance_fill_array(&in->env, tb[INSTANCE_ATTR_ENV], NULL, false))
-               return false;
+       if (tb[INSTANCE_ATTR_USER]) {
+               struct passwd *p = getpwnam(blobmsg_get_string(tb[INSTANCE_ATTR_USER]));
+               if (p) {
+                       in->uid = p->pw_uid;
+                       in->gid = p->pw_gid;
+               }
+       }
 
-       if (!instance_fill_array(&in->data, tb[INSTANCE_ATTR_DATA], NULL, false))
+       instance_fill_any(&in->data, tb[INSTANCE_ATTR_DATA]);
+
+       if (!instance_fill_array(&in->env, tb[INSTANCE_ATTR_ENV], NULL, false))
                return false;
 
        if (!instance_fill_array(&in->netdev, tb[INSTANCE_ATTR_NETDEV], instance_netdev_update, true))
@@ -425,6 +485,9 @@ instance_config_parse(struct service_instance *in)
        if (!instance_fill_array(&in->limits, tb[INSTANCE_ATTR_LIMITS], NULL, false))
                return false;
 
+       if (!instance_fill_array(&in->errors, tb[INSTANCE_ATTR_ERROR], NULL, true))
+               return false;
+
        return true;
 }
 
@@ -436,6 +499,7 @@ instance_config_cleanup(struct service_instance *in)
        blobmsg_list_free(&in->netdev);
        blobmsg_list_free(&in->file);
        blobmsg_list_free(&in->limits);
+       blobmsg_list_free(&in->errors);
 }
 
 static void
@@ -447,6 +511,7 @@ instance_config_move(struct service_instance *in, struct service_instance *in_sr
        blobmsg_list_move(&in->netdev, &in_src->netdev);
        blobmsg_list_move(&in->file, &in_src->file);
        blobmsg_list_move(&in->limits, &in_src->limits);
+       blobmsg_list_move(&in->errors, &in_src->errors);
        in->trigger = in_src->trigger;
        in->command = in_src->command;
        in->name = in_src->name;
@@ -484,7 +549,7 @@ instance_free(struct service_instance *in)
        uloop_process_delete(&in->proc);
        uloop_timeout_cancel(&in->timeout);
        trigger_del(in);
-       free(in->trigger);
+       watch_del(in);
        instance_config_cleanup(in);
        free(in->config);
        free(in);
@@ -505,6 +570,7 @@ instance_init(struct service_instance *in, struct service *s, struct blob_attr *
        blobmsg_list_simple_init(&in->env);
        blobmsg_list_simple_init(&in->data);
        blobmsg_list_simple_init(&in->limits);
+       blobmsg_list_simple_init(&in->errors);
        in->valid = instance_config_parse(in);
 }
 
@@ -518,6 +584,14 @@ void instance_dump(struct blob_buf *b, struct service_instance *in, int verbose)
                blobmsg_add_u32(b, "pid", in->proc.pid);
        blobmsg_add_blob(b, in->command);
 
+       if (!avl_is_empty(&in->errors.avl)) {
+               struct blobmsg_list_node *var;
+               void *e = blobmsg_open_array(b, "errors");
+               blobmsg_list_for_each(&in->errors, var)
+                       blobmsg_add_string(b, NULL, blobmsg_data(var->data));
+               blobmsg_close_table(b, e);
+       }
+
        if (!avl_is_empty(&in->env.avl)) {
                struct blobmsg_list_node *var;
                void *e = blobmsg_open_table(b, "env");
@@ -526,6 +600,14 @@ void instance_dump(struct blob_buf *b, struct service_instance *in, int verbose)
                blobmsg_close_table(b, e);
        }
 
+       if (!avl_is_empty(&in->data.avl)) {
+               struct blobmsg_list_node *var;
+               void *e = blobmsg_open_table(b, "data");
+               blobmsg_list_for_each(&in->data, var)
+                       blobmsg_add_blob(b, var->data);
+               blobmsg_close_table(b, e);
+       }
+
        if (!avl_is_empty(&in->limits.avl)) {
                struct blobmsg_list_node *var;
                void *e = blobmsg_open_table(b, "limits");