More db/event/state changes

Signed-off-by: Laurent Bercot <ska@appnovation.com>

1 files changed, 85 insertions, 68 deletions

diff --git a/src/server/state.c b/src/server/state.c
index 29d1548..d9e3f61 100644
--- a/src/server/state.c
+++ b/src/server/state.c
@@ -17,28 +17,28 @@
 
 #include <skalibs/posixishard.h>
 
-static stateatom_t const stateatom_zero = STATEATOM_ZERO ;
+static sstate_t const sstate_zero = SSTATE_ZERO ;
 
 void instance_free (instance_t *ins)
 {
   dynstorage_remove(ins->param) ;
 }
 
-int instance_new (instance_t *ins, stateatom_t const *state, char const *param) ;
+int instance_new (instance_t *ins, sstate_t const *st, char const *param) ;
 {
   char const *s = dynstorage_add(param) ;
   if (!s) return 0 ;
-  ins->state = state ;
+  ins->state = *st ;
   inst->param = s ;
   return 1 ;
 }
 
-void state_free (state_t *st, uint32_t const *dbn)
+void mstate_free (mstate_t *st, uint32_t const *dbn)
 {
-  for (s6rc_stype_t type = S6RC_STYPE_LONGRUN ; type < S6RC_STYPE_PHAIL ; type++)
+  for (size_t type = 0 ; type < S6RC_STYPE_N ; type++)
   {
     alloc_free(st->sta[type]) ;
-    for (size_t i = 0 ; i < dbn[S6RC_STYPE_PHAIL + type] ; i++)
+    for (size_t i = 0 ; i < dbn[S6RC_STYPE_N + type] ; i++)
     {
       for (size_t j = 0 ; j < genalloc_len(instance_t, st->dyn[type] + i) ; j++)
         instance_free(genalloc_s(instance_t, st->dyn[type] + i) + j) ;
@@ -48,18 +48,18 @@ void state_free (state_t *st, uint32_t const *dbn)
   }
 }
 
-int state_init (state_t *st, uint32_t const *dbn)
+int mstate_init (mstate_t *st, uint32_t const *dbn)
 {
-  s6rc_stype_t type = 0 ;
-  for (; type < S6RC_STYPE_PHAIL ; type++)
+  size_t type = 0 ;
+  for (; type < S6RC_STYPE_N ; type++)
   {
-    st->sta[type] = alloc(sizeof(stateatom_t) * dbn[type]) ;
+    st->sta[type] = alloc(dbn[type]) ;
     if (!st->sta[type]) goto err ;
-    st->dyn[type] = alloc(sizeof(genalloc) * dbn[S6RC_STYPE_PHAIL + type]) ;
+    st->dyn[type] = alloc(sizeof(genalloc) * dbn[S6RC_STYPE_N + type]) ;
     if (!st->dyn[type]) { alloc_free(st->sta[type]) ; goto err ; }
     for (uint32_t i = 0 ; i < dbn[type] ; i++)
-      st->sta[type][i] = stateatom_zero ;
-    for (size_t i = 0 ; i < dbn[S6RC_STYPE_PHAIL + type] ; i++)
+      st->sta[type][i] = sstate_zero ;
+    for (uint32_t i = 0 ; i < dbn[S6RC_STYPE_N + type] ; i++)
       st->dyn[type][i] = genalloc_zero ;
   }
   return 1 ;
@@ -73,13 +73,50 @@ int state_init (state_t *st, uint32_t const *dbn)
   return 0 ;
 }
 
-static int atom_write (buffer *b, stateatom_t const *state)
+static int sstate_write (buffer *b, sstate_t const *state)
 {
-  char c = state->wanted | (state->current << 1) | (state->transitioning << 2) ;
-  return buffer_put(b, &c, 1) == 1 ;
+  return buffer_put(b, (char *)state->bits, 1) == 1 ;
 }
 
-int state_write (char const *file, state_t const *st, uint32_t const *dbn)
+static int sstate_read (buffer *b, sstate_t *state)
+{
+  return buffer_get(b, (char *)state->bits, 1) == 1 ;
+}
+
+static inline int instance_write (buffer *b, instance_t const *ins)
+{
+  uint32_t len = strlen(ins->param) ;
+  char pack[4] ;
+  uint32_pack_big(pack, len) ;
+  if (!sstate_write(b, &ins->state)) return 0 ;
+  if (buffer_put(b, pack, 4) < 4) return 0 ;
+  if (buffer_put(b, ins->param, len+1) < len+1) return 0 ;
+  return 1 ;
+}
+
+static inline int instance_read (buffer *b, instance_t *ins)
+{
+  sstate_t st ;
+  char const *p ;
+  uint32_t len ;
+  char pack[4] ;
+  if (!sstate_read(b, &st)) return 0 ;
+  if (buffer_get(&b, pack, 4) < 4) return 0 ;
+  uint32_unpack_big(pack, &len) ;
+  if (len > S6RC_INSTANCE_MAXLEN) return (errno = EPROTO, 0) ;
+  {
+    char param[len + 1] ;
+    if (buffer_get(&b, param, len + 1) < len + 1) return 0 ;
+    if (param[len]) return (errno = EPROTO, 0) ;
+    p = dynstorage_add(param) ;
+    if (!p) return 0 ;
+  }
+  ins->sstate = st ;
+  ins->param = p ;
+  return 1 ;
+}
+
+int mstate_write (char const *file, mstate_t const *st, uint32_t const *dbn)
 {
   size_t filelen = strlen(file) ;
   int fd ;
@@ -92,12 +129,12 @@ int state_write (char const *file, state_t const *st, uint32_t const *dbn)
   if (fd == -1) return 0 ;
   buffer_init(&b, &buffer_write, fd, buf, 1024) ;
 
-  for (s6rc_stype_t type = 0 ; type < S6RC_STYPE_PHAIL ; type++)
+  for (size_t type = 0 ; type < S6RC_STYPE_N ; type++)
     for (uint32_t i = 0 ; i < dbn[type] ; i++)
-      if (!atom_write(&b, st->sta[type] + i)) goto err ;
+      if (!sstate_write(&b, st->sta[type] + i)) goto err ;
 
-  for (s6rc_stype_t type = 0 ; type < S6RC_STYPE_PHAIL ; type++)
-    for (uint32_t i = 0 ; i < dbn[S6RC_STYPE_PHAIL + type] ; i++)
+  for (size_t type = 0 ; type < S6RC_STYPE_N ; type++)
+    for (uint32_t i = 0 ; i < dbn[S6RC_STYPE_N + type] ; i++)
     {
       uint32_t n = genalloc_len(instance_t, st->dyn[type] + i) ;
       instance_t const *p = genalloc_s(instance_t, st->dyn[type] + i) ;
@@ -105,13 +142,7 @@ int state_write (char const *file, state_t const *st, uint32_t const *dbn)
       uint32_pack_big(pack, n) ;
       if (buffer_put(&b, pack, 4) < 4) goto err ;
       for (uint32_t j = 0 ; j < n ; j++)
-      {
-        uint32_t len = strlen(p[j].param) ;
-        uint32_pack_big(pack, len) ;
-        if (!atom_write(&p[j].state)) goto err ;
-        if (buffer_put(&b, pack, 4) < 4) goto err ;
-        if (buffer_put(&b, p[j].param, len+1) < len+1) goto err ;
-      }
+        if (!instance_write(&b, p + j)) goto err ;
     }
 
   if (!buffer_flush(&b)) goto err ;
@@ -126,32 +157,22 @@ int state_write (char const *file, state_t const *st, uint32_t const *dbn)
   return 0 ;
 }
 
-static int atom_read (buffer *b, stateatom_t *state)
-{
-  char c ;
-  if (buffer_get(b, &c, 1) < 1) return 0 ;
-  state->wanted = c & 1 ;
-  state->current = !!(c & 2) ;
-  state->transitioning = !!(c & 4) ;
-  return 1 ;
-}
-
-int state_read (char const *file, state_t *st, uint32_t const *dbn)
+int mstate_read (char const *file, mstate_t *st, uint32_t const *dbn)
 {
   int fd ;
   buffer b ;
   char buf[1024] ;
-  if (!state_init(st, dbn)) return 0 ;
+  if (!mstate_init(st, dbn)) return 0 ;
   fd = openc_read(file) ;
   if (fd == -1) goto err0 ;
   buffer_init(&b, &buffer_read, fd, buf, 1024) ;
 
-  for (s6rc_stype_t type = 0 ; type < S6RC_STYPE_PHAIL ; type++)
+  for (size_t type = 0 ; type < S6RC_STYPE_N ; type++)
     for (uint32_t i = 0 ; i < dbn[type] ; i++)
-      if (!atom_read(&b, st->sta[type] + i)) goto err ;
+      if (!sstate_read(&b, st->sta[type] + i)) goto err ;
 
-  for (s6rc_stype_t type = 0 ; type < S6RC_STYPE_PHAIL ; type++)
-    for (uint32_t i = 0 ; i < dbn[S6RC_STYPE_PHAIL + type] ; i++)
+  for (size_t type = 0 ; type < S6RC_STYPE_N ; type++)
+    for (uint32_t i = 0 ; i < dbn[S6RC_STYPE_N + type] ; i++)
     {
       uint32_t n ;
       char pack[4] ;
@@ -159,22 +180,8 @@ int state_read (char const *file, state_t *st, uint32_t const *dbn)
       uint32_unpack_big(pack, &n) ;
       if (n > S6RC_INSTANCES_MAX) goto eproto ;
       if (!genalloc_ready(instance_t, st->dyn[type] + i, n)) goto err ;
-      for (uint32_t j = 0 ; i < n ; j++)
-      {
-        uint32_t len ;
-        instance_t *ins = genalloc_s(instance_t, st->dyn[type] + i) + j ;
-        if (!atom_read(&b, &ins->state)) goto err ;
-        if (buffer_get(&b, pack, 4) < 4) goto err ;
-        uint32_unpack_big(pack, &len) ;
-        if (len > S6RC_INSTANCE_MAXLEN) goto eproto ;
-        {
-          char param[len + 1] ;
-          if (buffer_get(&b, param, len + 1) < len + 1) goto err ;
-          if (param[len]) goto eproto ;
-          ins->param = dynstorage_add(param) ;
-          if (!ins_param) goto err ;
-        }
-      }
+      for (uint32_t j = 0 ; j < n ; j++)
+        if (!instance_read(&b, genalloc_s(instance_t, st->dyn[type] + i) + j)) goto err ;
       genalloc_setlen(instance_t, st->dyn[type] + i, n) ;
     }
 
@@ -195,19 +202,29 @@ int state_read (char const *file, state_t *st, uint32_t const *dbn)
  err:
   fd_close(fd) ;
  err0:
-  state_free(st, dbn) ;
+  mstate_free(st, dbn) ;
   return 0 ;
 }
 
-stateatom_t *state_atom (state_t const *st, s6rc_sid_t const *id)
+sstate_t *sstate (mstate_t const *m, s6rc_id_t id, char const *param)
 {
-  if (id->param)
+  if (stype(id) >= S6RC_STYPE_N)
   {
-    size_t n = genalloc_len(instance_t, st->dyn[id->stype] + id->i) ;
-    instance_t *instances = genalloc_s(instance_t, st->dyn[id->stype] + id->i) ;
+    size_t n = genalloc_len(instance_t, st->dyn[stype(id)] + snum(id)) ;
+    instance_t *instances = genalloc_s(instance_t, st->dyn[stype(id)] + snum(id)) ;
     for (size_t i = 0 ; i < n ; i++)
-      if (!strcmp(id->param, instances[i].param)) return &instances[i].state ;
-    return 0 ;
+      if (!strcmp(param, instances[i].param)) return &instances[i].sstate ;
+    return STATE_PHAIL ;
+  }
+  else return st->sta[stype(id)] + snum(id) ;
+}
+
+int state_deps_fulfilled (s6rc_db_t const *db, mstate_t const *m, s6rc_id_t id, char const *param, int h)
+{
+  s6rc_common_t const *common = s6rc_service_common(db, id) ;
+  for (uint32_t i = 0 ; i < common->ndeps[h] ; i++)
+  {
+    uint8_t deptype = db->deptypes[h][common->deps[h] + i] ;
+    sstate_t *st = sstate(m, db->deps[h][common->deps[h] + i], param) ;
   }
-  else return st->sta[id->stype] + id->i ;
 }