revamp of the resolve struct

src/lib66/service/deps-lib/deps

-service.o
 service_cmp_basedir.o
 service_endof_dir.o
 service_frontend_path.o
 service_frontend_src.o
-service_intree.o
-service_isenabled.o
-service_isenabledat.o
+service_graph_build.o
+service_graph_collect.o
+service_graph_g.o
+service_is_g.o
+service_resolve_array_free.o
+service_resolve_array_search.o
 service_resolve_copy.o
 service_resolve_get_field_tosa.o
 service_resolve_master_copy.o
@@ -17,9 +19,8 @@ service_resolve_master_write.o
 service_resolve_master_write_cdb.o
 service_resolve_modify_field.o
 service_resolve_read_cdb.o
-service_resolve_setlognwrite.o
-service_resolve_setnwrite.o
 service_resolve_sort_bytype.o
+service_resolve_write.o
 service_resolve_write_cdb.o
 -loblibs
 -lskarnet

src/lib66/service/service_cmp_basedir.c

@@ -29,6 +29,8 @@ int service_cmp_basedir(char const *dir)
 
     /** dir can be 0, so nothing to do */
     if (!dir) return 1 ;
+
+    int e = 0 ;
     size_t len = strlen(dir) ;
     uid_t owner = MYUID ;
     stralloc home = STRALLOC_ZERO ;
@@ -65,9 +67,9 @@ int service_cmp_basedir(char const *dir)
                     goto err ;
             } else goto err ;
 
-    stralloc_free(&home) ;
-    return 1 ;
+    e = 1 ;
+
     err:
         stralloc_free(&home) ;
-        return 0 ;
+        return e ;
 }

src/lib66/service/service_frontend_path.c

@@ -15,60 +15,75 @@
 #include <sys/types.h>
 
 #include <oblibs/log.h>
+#include <oblibs/string.h>
 
 #include <skalibs/stralloc.h>
 
+#include <66/config.h>
 #include <66/utils.h>
 #include <66/constants.h>
 #include <66/service.h>
 
-int service_frontend_path(stralloc *sasrc,char const *sv, uid_t owner,char const *directory_forced)
+int service_frontend_path(stralloc *sasrc, char const *sv, uid_t owner, char const *directory_forced)
 {
     log_flow() ;
 
-    int r ;
+    int r, e = 0 ;
     char const *src = 0 ;
-    int err = -1 ;
-    stralloc home = STRALLOC_ZERO ;
-    if (directory_forced)
-    {
-        if (!service_cmp_basedir(directory_forced)) { log_warn("invalid base service directory: ",directory_forced) ; goto err ; }
+    char home[SS_MAX_PATH_LEN + 1 + strlen(SS_USER_DIR) + 1] ;
+
+    if (directory_forced) {
+
+        if (!service_cmp_basedir(directory_forced))
+            log_die(LOG_EXIT_USER, "invalid base service directory: ", directory_forced) ;
+
         src = directory_forced ;
-        r = service_frontend_src(sasrc,sv,src) ;
-        if (r == -1){ log_warnusys("parse source directory: ",src) ; goto err ; }
-        if (!r) { log_warnu("find service: ",sv) ; err = 0 ; goto err ; }
-    }
-    else
-    {
-        if (!owner) src = SS_SERVICE_ADMDIR ;
-        else
-        {
-            if (!set_ownerhome(&home,owner)) { log_warnusys("set home directory") ; goto err ; }
-            if (!stralloc_cats(&home,SS_SERVICE_USERDIR)) { log_warnsys("stralloc") ; goto err ; }
-            if (!stralloc_0(&home)) { log_warnsys("stralloc") ; goto err ; }
-            home.len-- ;
-            src = home.s ;
-        }
+        r = service_frontend_src(sasrc, sv, src) ;
+        if (r == -1)
+            log_dieusys(LOG_EXIT_SYS, "parse source directory: ", src) ;
 
-        r = service_frontend_src(sasrc,sv,src) ;
-        if (r == -1){ log_warnusys("parse source directory: ",src) ; goto err ; }
         if (!r)
-        {
+            goto freed ;
+
+    } else {
+
+        if (!owner)
             src = SS_SERVICE_ADMDIR ;
-            r = service_frontend_src(sasrc,sv,src) ;
-            if (r == -1) { log_warnusys("parse source directory: ",src) ; goto err ; }
-            if (!r)
-            {
+        else {
+
+            if (!set_ownerhome_stack(home))
+                log_dieusys(LOG_EXIT_SYS, "set home directory") ;
+
+            auto_strings(home + strlen(home), SS_USER_DIR) ;
+
+            src = home ;
+        }
+
+        r = service_frontend_src(sasrc, sv, src) ;
+        if (r == -1)
+            log_dieusys(LOG_EXIT_SYS, "parse source directory: ", src) ;
+
+        if (!r) {
+
+            src = SS_SERVICE_ADMDIR ;
+            r = service_frontend_src(sasrc, sv, src) ;
+            if (r == -1)
+                log_dieusys(LOG_EXIT_SYS, "parse source directory: ", src) ;
+
+            if (!r) {
+
                 src = SS_SERVICE_SYSDIR ;
-                r = service_frontend_src(sasrc,sv,src) ;
-                if (r == -1) { log_warnusys("parse source directory: ",src) ; goto err ; }
-                if (!r) { log_warnu("find service: ",sv) ; err = 0 ; goto err ; }
+                r = service_frontend_src(sasrc, sv, src) ;
+                if (r == -1)
+                    log_dieusys(LOG_EXIT_SYS, "parse source directory: ", src) ;
+
+                if (!r)
+                    goto freed ;
             }
         }
     }
-    stralloc_free(&home) ;
-    return 1 ;
-    err:
-        stralloc_free(&home) ;
-        return err ;
+    e = 1 ;
+
+    freed:
+        return e ;
 }

src/lib66/service/service_frontend_src.c

@@ -31,14 +31,23 @@ int service_frontend_src(stralloc *sasrc, char const *name, char const *src)
 
     int  insta, equal = 0, e = -1, r = 0, found = 0 ;
     stralloc sa = STRALLOC_ZERO ;
-    size_t pos = 0, dpos = 0 ;
+    size_t pos = 0, dpos = 0, pathlen = strlen(src) ;
 
     char const *exclude[1] = { 0 } ;
 
-    if (!sastr_dir_get_recursive(&sa, src, exclude, S_IFREG|S_IFDIR, 1)) {
+    char path[pathlen + 1] ;
+
+    auto_strings(path, src) ;
+
+    /** avoid double slash */
+    if (path[pathlen - 1] == '/')
+        path[pathlen - 1] = 0 ;
+
+    if (!sastr_dir_get_recursive(&sa, path, exclude, S_IFREG|S_IFDIR, 1)) {
         stralloc_free(&sa) ;
         return e ;
     }
+
     size_t len = sa.len ;
     char tmp[len + 1] ;
     sastr_to_char(tmp, &sa) ;

src/lib66/service/service_graph_build.c

+/*
+ * service_graph_build.c
+ *
+ * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
+ *
+ * All rights reserved.
+ *
+ * This file is part of Obarun. It is subject to the license terms in
+ * the LICENSE file found in the top-level directory of this
+ * distribution.
+ * This file may not be copied, modified, propagated, or distributed
+ * except according to the terms contained in the LICENSE file./
+ */
+
+#include <stdint.h>
+
+#include <oblibs/log.h>
+#include <oblibs/types.h>
+#include <oblibs/graph.h>
+
+#include <66/service.h>
+#include <66/graph.h>
+#include <66/state.h>
+
+void service_graph_build(graph_t *g, resolve_service_t *ares, unsigned int areslen, uint32_t flag)
+{
+    log_flow() ;
+
+    unsigned int pos = 0 ;
+    resolve_service_t_ref pres = 0 ;
+
+    for (; pos < areslen ; pos++) {
+
+        pres = &ares[pos] ;
+        char *service = pres->sa.s + pres->name ;
+
+        if (!graph_vertex_add(g, service))
+            log_dieu(LOG_EXIT_SYS, "add vertex: ", service) ;
+
+        if (FLAGS_ISSET(flag, STATE_FLAGS_TOPROPAGATE)) {
+
+            if (pres->dependencies.ndepends && FLAGS_ISSET(flag, STATE_FLAGS_WANTUP))
+                if (!graph_compute_dependencies(g, service, pres->sa.s + pres->dependencies.depends, 0))
+                    log_dieu(LOG_EXIT_SYS, "add dependencies of service: ",service) ;
+
+            if (pres->dependencies.nrequiredby && FLAGS_ISSET(flag, STATE_FLAGS_WANTDOWN))
+                if (!graph_compute_dependencies(g, service, pres->sa.s + pres->dependencies.requiredby, 1))
+                    log_dieu(LOG_EXIT_SYS, "add dependencies of service: ",service) ;
+        }
+    }
+
+    if (!graph_matrix_build(g))
+        log_dieu(LOG_EXIT_SYS, "build the graph") ;
+
+    if (!graph_matrix_analyze_cycle(g))
+        log_dieu(LOG_EXIT_SYS, "found cycle") ;
+
+    if (!graph_matrix_sort(g))
+        log_dieu(LOG_EXIT_SYS, "sort the graph") ;
+}

src/lib66/service/service_graph_collect.c

+/*
+ * service_graph_collect.c
+ *
+ * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
+ *
+ * All rights reserved.
+ *
+ * This file is part of Obarun. It is subject to the license terms in
+ * the LICENSE file found in the top-level directory of this
+ * distribution.
+ * This file may not be copied, modified, propagated, or distributed
+ * except according to the terms contained in the LICENSE file./
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <oblibs/log.h>
+#include <oblibs/sastr.h>
+#include <oblibs/types.h>
+
+#include <skalibs/stralloc.h>
+
+#include <66/service.h>
+#include <66/resolve.h>
+#include <66/sanitize.h>
+#include <66/state.h>
+#include <66/graph.h>
+#include <66/enum.h>
+
+/** list all services of the system
+ * STATE_FLAGS_TOINIT -> it call sanitize_source() function.
+ * STATE_FLAGS_TOPROPAGATE -> it build with the dependencies/requiredby services.
+ * STATE_FLAGS_ISSUPERVISED -> only keep already supervised service*/
+void service_graph_collect(graph_t *g, char const *alist, size_t alen, resolve_service_t *ares, unsigned int *areslen, ssexec_t *info, uint32_t flag)
+{
+    log_flow () ;
+
+    size_t pos = 0 ;
+    ss_state_t ste = STATE_ZERO ;
+    stralloc sa = STRALLOC_ZERO ;
+
+    resolve_wrapper_t_ref wres = 0 ;
+
+    for (; pos < alen ; pos += strlen(alist + pos) + 1) {
+
+        sa.len = 0 ;
+        char const *name = alist + pos ;
+
+        if (service_resolve_array_search(ares, (*areslen), name) < 0) {
+
+            resolve_service_t res = RESOLVE_SERVICE_ZERO ;
+            wres = resolve_set_struct(DATA_SERVICE, &res) ;
+
+            if (FLAGS_ISSET(flag, STATE_FLAGS_TOINIT))
+                sanitize_source(name, info, flag) ;
+
+            if (!resolve_read_g(wres, info->base.s, name))
+                log_dieu(LOG_EXIT_SYS, "read resolve file of: ", name, " -- please make a bug report") ;
+
+            if (FLAGS_ISSET(flag, STATE_FLAGS_ISSUPERVISED)) {
+
+                if (!state_read(&ste, res.sa.s + res.path.home, name))
+                    log_dieu(LOG_EXIT_SYS, "read state file of: ", name, " -- please make a bug report") ;
+
+                if (service_is(&ste, STATE_FLAGS_ISSUPERVISED))
+                    ares[(*areslen)++] = res ;
+                else
+                    continue ;
+            } else
+                ares[(*areslen)++] = res ;
+
+            if (FLAGS_ISSET(flag, STATE_FLAGS_TOPROPAGATE)) {
+
+                if (res.dependencies.ndepends && FLAGS_ISSET(flag, STATE_FLAGS_WANTDOWN)) {
+
+                    if (!sastr_clean_string(&sa, res.sa.s + res.dependencies.depends))
+                        log_dieu(LOG_EXIT_SYS, "clean string") ;
+
+                    service_graph_collect(g, sa.s, sa.len, ares, areslen, info, flag) ;
+
+                } else if (res.dependencies.nrequiredby && FLAGS_ISSET(flag, STATE_FLAGS_WANTUP)) {
+
+                    if (!sastr_clean_string(&sa, res.sa.s + res.dependencies.requiredby))
+                        log_dieu(LOG_EXIT_SYS, "clean string") ;
+
+                    service_graph_collect(g, sa.s, sa.len, ares, areslen, info, flag) ;
+                }
+            }
+        }
+    }
+
+    free(wres) ;
+    stralloc_free(&sa) ;
+}

src/lib66/service/service_graph_g.c

+/*
+ * service_graph_g.c
+ *
+ * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
+ *
+ * All rights reserved.
+ *
+ * This file is part of Obarun. It is subject to the license terms in
+ * the LICENSE file found in the top-level directory of this
+ * distribution.
+ * This file may not be copied, modified, propagated, or distributed
+ * except according to the terms contained in the LICENSE file./
+ */
+
+#include <stdint.h>
+
+#include <oblibs/log.h>
+
+#include <66/service.h>
+#include <66/graph.h>
+#include <66/ssexec.h>
+
+void service_graph_g(char const *alist, size_t alen, graph_t *graph, resolve_service_t *ares, unsigned int *areslen, ssexec_t *info, uint32_t flag)
+{
+    log_flow() ;
+
+    service_graph_collect(graph, alist, alen, ares, areslen, info, flag) ;
+
+    service_graph_build(graph, ares, (*areslen), flag) ;
+}

src/lib66/service/service_intree.c

-/*
- * service_intree.c
- *
- * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
- *
- * All rights reserved.
- *
- * This file is part of Obarun. It is subject to the license terms in
- * the LICENSE file found in the top-level directory of this
- * distribution.
- * This file may not be copied, modified, propagated, or distributed
- * except according to the terms contained in the LICENSE file./
- */
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#include <oblibs/log.h>
-#include <oblibs/string.h>
-#include <oblibs/types.h>
-#include <oblibs/sastr.h>
-
-#include <skalibs/stralloc.h>
-
-#include <66/constants.h>
-#include <66/resolve.h>
-#include <66/utils.h>
-#include <66/service.h>
-
-/** @Return -1 system error
- * @Return 0 no tree exist yet
- * @Return 1 svname doesn't exist
- * @Return 2 on success
- * @Return > 2, service exist on different tree */
-int service_intree(stralloc *svtree, char const *svname, char const *tree)
-{
-    log_flow() ;
-
-    uint8_t found = 1, copied = 0 ;
-    uid_t owner = getuid() ;
-    size_t pos = 0, newlen ;
-    stralloc satree = STRALLOC_ZERO ;
-    stralloc tmp = STRALLOC_ZERO ;
-    char const *exclude[3] = { SS_BACKUP + 1, SS_RESOLVE + 1, 0 } ;
-
-    if (!set_ownersysdir(svtree,owner)) { log_warnusys("set owner directory") ; goto err ; }
-    if (!auto_stra(svtree,SS_SYSTEM)) goto err ;
-
-    if (!scan_mode(svtree->s,S_IFDIR))
-    {
-        found = 0 ;
-        goto freed ;
-    }
-
-    if (!auto_stra(svtree,"/")) goto err ;
-    newlen = svtree->len ;
-
-    if (!stralloc_copy(&tmp,svtree)) goto err ;
-
-    if (!sastr_dir_get(&satree, svtree->s, exclude, S_IFDIR)) {
-        log_warnu("get list of trees from directory: ",svtree->s) ;
-        goto err ;
-    }
-
-    if (satree.len)
-    {
-
-        FOREACH_SASTR(&satree, pos) {
-
-            tmp.len = newlen ;
-            char *name = satree.s + pos ;
-
-            if (!auto_stra(&tmp,name,SS_SVDIRS)) goto err ;
-            if (resolve_check(tmp.s,svname)) {
-
-                if (!tree || (tree && !strcmp(name,tree))){
-                    svtree->len = 0 ;
-                    if (!stralloc_copy(svtree,&tmp)) goto err ;
-                    copied = 1 ;
-                }
-                found++ ;
-            }
-        }
-    }
-    else
-    {
-        found = 0 ;
-        goto freed ;
-    }
-
-    if (found > 2 && tree) found = 2 ;
-    if (!copied) found = 1 ;
-    if (!stralloc_0(svtree)) goto err ;
-    freed:
-    stralloc_free(&satree) ;
-    stralloc_free(&tmp) ;
-    return found ;
-    err:
-        stralloc_free(&satree) ;
-        stralloc_free(&tmp) ;
-        return -1 ;
-}

src/lib66/service/service_isenabledat.c → src/lib66/service/service_is_g.c

 /*
- * service_isenabledat.c
+ * service_is_g.c
  *
  * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
  *
@@ -12,7 +12,9 @@
  * except according to the terms contained in the LICENSE file./
  */
 
-#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <errno.h>
 
 #include <oblibs/log.h>
 #include <oblibs/string.h>
@@ -21,92 +23,105 @@
 
 #include <skalibs/stralloc.h>
 
-#include <66/constants.h>
+#include <66/service.h>
+#include <66/tree.h>
 #include <66/resolve.h>
+#include <66/state.h>
+#include <66/constants.h>
 #include <66/utils.h>
-#include <66/service.h>
 
-/** @Return 0 if not found
- * @Return 1 if found
- * @Return 2 if found but marked disabled
- * @Return -1 system error */
-int service_isenabledat(char *atree, char const *sv)
+int service_is(ss_state_t *ste, uint32_t flag)
 {
 
-    log_flow() ;
+    switch (flag) {
 
-    stralloc sa = STRALLOC_ZERO ;
-    resolve_service_t res = RESOLVE_SERVICE_ZERO ;
-    resolve_wrapper_t_ref wres = resolve_set_struct(DATA_SERVICE, &res) ;
-    size_t newlen = 0, pos = 0 ;
-    int e = -1, r ;
-    char const *exclude[3] = { SS_BACKUP + 1, SS_RESOLVE + 1, 0 } ;
+        case STATE_FLAGS_TOINIT : return FLAGS_ISSET(ste->toinit, STATE_FLAGS_TRUE) ;
 
-    if (!set_ownersysdir(&sa, getuid())) {
+        case STATE_FLAGS_TORELOAD: return FLAGS_ISSET(ste->toreload, STATE_FLAGS_TRUE) ;
 
-        log_warnusys("set owner directory") ;
-        stralloc_free(&sa) ;
-        return 0 ;
-    }
+        case STATE_FLAGS_TORESTART : return FLAGS_ISSET(ste->torestart, STATE_FLAGS_TRUE) ;
 
-    char tmp[sa.len + SS_SYSTEM_LEN + 2] ;
-    auto_strings(tmp, sa.s, SS_SYSTEM) ;
+        case STATE_FLAGS_TOUNSUPERVISE : return FLAGS_ISSET(ste->tounsupervise, STATE_FLAGS_TRUE) ;
 
-    // no tree exist yet
-    if (!scan_mode(tmp, S_IFDIR))
-        goto empty ;
+        case STATE_FLAGS_ISDOWNFILE : return FLAGS_ISSET(ste->isdownfile, STATE_FLAGS_TRUE) ;
 
-    auto_strings(tmp, sa.s, SS_SYSTEM, "/") ;
+        case STATE_FLAGS_ISEARLIER : return FLAGS_ISSET(ste->isearlier, STATE_FLAGS_TRUE) ;
 
-    newlen = sa.len + SS_SYSTEM_LEN + 1 ;
-    sa.len = 0 ;
+        case STATE_FLAGS_ISENABLED : return FLAGS_ISSET(ste->isenabled, STATE_FLAGS_TRUE) ;
 
-    if (!sastr_dir_get(&sa, tmp, exclude, S_IFDIR)) {
+        case STATE_FLAGS_ISPARSED : return  FLAGS_ISSET(ste->isparsed, STATE_FLAGS_TRUE) ; //always true framboise
+
+        case STATE_FLAGS_ISSUPERVISED : return FLAGS_ISSET(ste->issupervised, STATE_FLAGS_TRUE) ;
+
+        case STATE_FLAGS_ISUP : return FLAGS_ISSET(ste->isup, STATE_FLAGS_TRUE) ;
+
+        default:
+            break ;
 
-        log_warnu("get list of trees from: ", tmp) ;
-        goto freed ;
     }
 
-    FOREACH_SASTR(&sa, pos) {
+    return 0 ;
+}
 
-        char *treename = sa.s + pos ;
+/*@Return :
+ * -1 system error
+ * 0 check fail
+ * 1 check success */
+int service_is_g(char *atree, char const *name, uint32_t flag)
+{
 
-        char trees[newlen + strlen(treename) + SS_SVDIRS_LEN + 1] ;
-        auto_strings(trees, tmp, treename, SS_SVDIRS) ;
+    log_flow() ;
 
+    ss_state_t ste = STATE_ZERO ;
+    resolve_service_t res = RESOLVE_SERVICE_ZERO ;
+    resolve_wrapper_t_ref wres = resolve_set_struct(DATA_SERVICE, &res) ;
+    int e = -1, r = -1 ;
+    char base[SS_MAX_PATH_LEN + SS_SYSTEM_LEN + 1] ;
 
-        r = resolve_read_g(wres, trees, sv) ;
+    if (!set_ownersysdir_stack(base, getuid())) {
 
-        if (r < 0) {
+        log_warnusys("set owner directory") ;
+        resolve_free(wres) ;
+        return e ;
+    }
 
-            log_warnu("read resolve file: ", trees, "/", sv) ;
-            e = -1 ;
-            goto freed ;
+    size_t baselen = strlen(base) ;
+    //char tmp[baselen + SS_SYSTEM_LEN + 1] ;
+    auto_strings(base + baselen, SS_SYSTEM) ;
 
-        } else if (r) {
+    // no tree exist yet
+    if (!scan_mode(base, S_IFDIR)) {
+        e = 0 ;
+        goto freed ;
+    }
 
-            if (res.disen) {
+    base[baselen] = 0 ;
 
-                log_trace(sv, " enabled at tree: ", treename) ;
-                e = 1 ;
+    r = resolve_read_g(wres, base, name) ;
+    if (r == -1)
+        goto freed ;
+    else if (!r) {
+        e = 0 ;
+        goto freed ;
+    }
 
-            } else {
+    if (strlen(res.sa.s + res.treename) > SS_MAX_TREENAME) {
+        errno = ENAMETOOLONG ;
+        goto freed ;
+    }
 
-                log_trace(sv, " disabled at tree: ", treename) ;
-                e = 2 ;
-            }
+    auto_strings(atree, res.sa.s + res.treename) ;
 
-            if (!auto_strings(atree, treename)) {
-                e = -1 ;
-                goto freed ;
-            }
-            goto freed ;
-        }
+    if (!state_read(&ste, res.sa.s + res.path.home, name)) {
+        log_warnu("read state file of: ", name, " -- please make a bug report") ;
+        goto freed ;
     }
-    empty:
-        e = 0 ;
+
+    e = service_is(&ste, flag) ;
+
     freed:
-        stralloc_free(&sa) ;
         resolve_free(wres) ;
         return e ;
 }
+
+

src/lib66/service/service_resolve_array_free.c

+/*
+ * service_resolve_array_free.c
+ *
+ * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
+ *
+ * All rights reserved.
+ *
+ * This file is part of Obarun. It is subject to the license terms in
+ * the LICENSE file found in the top-level directory of this
+ * distribution.
+ * This file may not be copied, modified, propagated, or distributed
+ * except according to the terms contained in the LICENSE file./
+ */
+
+#include <skalibs/stralloc.h>
+
+#include <66/service.h>
+
+void service_resolve_array_free(resolve_service_t *ares, unsigned int areslen)
+{
+
+    unsigned int pos = 0 ;
+    for (; pos < areslen ; pos++)
+        stralloc_free(&ares[pos].sa) ;
+}
+

src/lib66/service/service_resolve_array_search.c

+/*
+ * service_resolve_array_search.c
+ *
+ * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
+ *
+ * All rights reserved.
+ *
+ * This file is part of Obarun. It is subject to the license terms in
+ * the LICENSE file found in the top-level directory of this
+ * distribution.
+ * This file may not be copied, modified, propagated, or distributed
+ * except according to the terms contained in the LICENSE file./
+ */
+
+#include <string.h>
+
+#include <66/service.h>
+
+int service_resolve_array_search(resolve_service_t *ares, unsigned int areslen, char const *name)
+{
+    unsigned int pos = 0 ;
+
+    for (; pos < areslen ; pos++) {
+
+        char const *n = ares[pos].sa.s + ares[pos].name ;
+            if (!strcmp(name, n))
+                return pos ;
+    }
+
+    return -1 ;
+}
+

src/lib66/service/service_resolve_copy.c

@@ -34,39 +34,93 @@ int service_resolve_copy(resolve_service_t *dst, resolve_service_t *res)
         !stralloc_0(&dst->sa))
             return 0 ;
 
+    // configuration
     dst->name = res->name ;
     dst->description = res->description ;
     dst->version = res->version ;
-    dst->logger = res->logger ;
-    dst->logreal = res->logreal ;
-    dst->logassoc = res->logassoc ;
-    dst->dstlog = res->dstlog ;
-    dst->depends = res->depends ;
-    dst->requiredby = res->requiredby ;
-    dst->optsdeps = res->optsdeps ;
-    dst->extdeps = res->extdeps ;
-    dst->contents = res->contents ;
-    dst->src = res->src ;
-    dst->srconf = res->srconf ;
-    dst->live = res->live ;
-    dst->runat = res->runat ;
-    dst->tree = res->tree ;
-    dst->treename = res->treename ;
-    dst->state = res->state ;
-    dst->exec_run = res->exec_run ;
-    dst->exec_log_run = res->exec_log_run ;
-    dst->real_exec_run = res->real_exec_run ;
-    dst->real_exec_log_run = res->real_exec_log_run ;
-    dst->exec_finish = res->exec_finish ;
-    dst->real_exec_finish = res->real_exec_finish ;
     dst->type = res->type ;
-    dst->ndepends = res->ndepends ;
-    dst->nrequiredby = res->nrequiredby ;
-    dst->noptsdeps = res->noptsdeps ;
-    dst->nextdeps = res->nextdeps ;
-    dst->ncontents = res->ncontents ;
-    dst->down = res->down ;
-    dst->disen = res->disen ;
+    dst->notify = res->notify ;
+    dst->maxdeath = res->maxdeath ;
+    dst->earlier = res->earlier ;
+    dst->hiercopy = res->hiercopy ;
+    dst->intree = res->intree ;
+    dst->ownerstr = res->ownerstr ;
+    dst->owner = res->owner ;
+    dst->treename = res->treename ;
+    dst->user = res->user ;
+    dst->inmodule = res->inmodule ;
+
+    // path
+    dst->path.home = res->path.home ;
+    dst->path.frontend = res->path.frontend ;
+    dst->path.tree = res->path.tree ;
+    dst->path.status = res->path.status ;
+
+    // dependencies
+    dst->dependencies.depends = res->dependencies.depends ;
+    dst->dependencies.requiredby = res->dependencies.requiredby ;
+    dst->dependencies.optsdeps = res->dependencies.optsdeps ;
+    dst->dependencies.ndepends = res->dependencies.ndepends ;
+    dst->dependencies.nrequiredby = res->dependencies.nrequiredby ;
+    dst->dependencies.noptsdeps = res->dependencies.noptsdeps ;
+
+    // execute
+    dst->execute.run.run = res->execute.run.run ;
+    dst->execute.run.run_user = res->execute.run.run_user ;
+    dst->execute.run.build = res->execute.run.build ;
+    dst->execute.run.shebang = res->execute.run.shebang ;
+    dst->execute.run.runas = res->execute.run.runas ;
+    dst->execute.finish.run = res->execute.finish.run ;
+    dst->execute.finish.run_user = res->execute.finish.run_user ;
+    dst->execute.finish.build = res->execute.finish.build ;
+    dst->execute.finish.shebang = res->execute.finish.shebang ;
+    dst->execute.finish.runas = res->execute.finish.runas ;
+    dst->execute.timeout.kill = res->execute.timeout.kill ;
+    dst->execute.timeout.finish = res->execute.timeout.finish ;
+    dst->execute.timeout.up = res->execute.timeout.up ;
+    dst->execute.timeout.down = res->execute.timeout.down ;
+    dst->execute.down = res->execute.down ;
+    dst->execute.downsignal = res->execute.downsignal ;
+
+    // live
+    dst->live.livedir = res->live.livedir ;
+    dst->live.scandir = res->live.scandir ;
+    dst->live.statedir = res->live.statedir ;
+    dst->live.eventdir = res->live.eventdir ;
+    dst->live.notifdir = res->live.notifdir ;
+    dst->live.supervisedir = res->live.supervisedir ;
+    dst->live.fdholderdir = res->live.fdholderdir ;
+    dst->live.oneshotddir = res->live.oneshotddir ;
+
+    // logger
+    dst->logger.name = res->logger.name ;
+    dst->logger.destination = res->logger.destination ;
+    dst->logger.backup = res->logger.backup ;
+    dst->logger.maxsize = res->logger.maxsize ;
+    dst->logger.timestamp = res->logger.timestamp ;
+    dst->logger.want = res->logger.want ;
+    dst->logger.execute.run.run = res->logger.execute.run.run ;
+    dst->logger.execute.run.run_user = res->logger.execute.run.run_user ;
+    dst->logger.execute.run.build = res->logger.execute.run.build ;
+    dst->logger.execute.run.shebang = res->logger.execute.run.shebang ;
+    dst->logger.execute.run.runas = res->logger.execute.run.runas ;
+    dst->logger.timeout.kill = res->logger.timeout.kill ;
+    dst->logger.timeout.finish = res->logger.timeout.finish ;
+
+    // environment
+    dst->environ.env = res->environ.env ;
+    dst->environ.envdir = res->environ.envdir ;
+    dst->environ.env_overwrite = res->environ.env_overwrite ;
+
+    // regex
+    dst->regex.configure = res->regex.configure ;
+    dst->regex.directories = res->regex.directories ;
+    dst->regex.files = res->regex.files ;
+    dst->regex.infiles = res->regex.infiles ;
+    dst->regex.ndirectories = res->regex.ndirectories ;
+    dst->regex.nfiles = res->regex.nfiles ;
+    dst->regex.ninfiles = res->regex.ninfiles ;
+
 
     return 1 ;
 }

src/lib66/service/service_resolve_from_cmdline.c

+/*
+ * resolve_from_cmdline.c
+ *
+ * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
+ *
+ * All rights reserved.
+ *
+ * This file is part of Obarun. It is subject to the license terms in
+ * the LICENSE file found in the top-level directory of this
+ * distribution.
+ * This file may not be copied, modified, propagated, or distributed
+ * except according to the terms contained in the LICENSE file./
+ */
+
+#include <stdint.h>
+
+#include <oblibs/log.h>
+#include <oblibs/string.h>
+#include <oblibs/graph.h>
+
+#include <skalibs/genalloc.h>
+
+#include <66/resolve.h>
+#include <66/service.h>
+#include <66/graph.h>
+#include <66/ssexec.h>
+#include <66/constants.h>
+
+int service_resolve_from_cmdline(resolve_service_t *ares, graph_t *graph, ssexec_t *info, char const *const *argv, uint8_t requiredby)
+{
+
+    resolve_service_t res = RESOLVE_SERVICE_ZERO ;
+    resolve_wrapper_t_ref wres = 0 ;
+    unsigned int areslen = 0 ;
+
+    for (; *argv ; argv++) {
+
+        unsigned int pos = 0, *alist = 0, ndeps = 0 ;
+        char const *name = *argv ;
+
+        wres = resolve_set_struct(DATA_SERVICE, &res) ;
+
+        if (resolve_read_g(wres, info->base.s, name) <= 0)
+            log_dieusys(LOG_EXIT_SYS,"read resolve file of: ", name) ;
+
+        resolve_service_t cp = RESOLVE_SERVICE_ZERO ;
+
+        if (!service_resolve_copy(&cp, &res))
+            log_dieusys(LOG_EXIT_SYS,"copy resolve file of: ", name) ;
+
+        if (service_resolve_array_search(ares, areslen, name) < 0)
+            ares[areslen++] = cp ;
+
+        ndeps = graph_matrix_get_edge_g_list(alist, graph, name, requiredby, 1) ;
+
+        if (ndeps < 0)
+            log_dieu(LOG_EXIT_SYS, "get dependencies of service: ", name) ;
+
+        for (; pos < ndeps ; pos++) {
+
+            char *name = graph->data.s + genalloc_s(graph_hash_t, &graph->hash)[alist[pos]].vertex ;
+
+            resolve_service_t dres = RESOLVE_SERVICE_ZERO ;
+            wres = resolve_set_struct(DATA_SERVICE, &dres) ;
+
+            if (!service_resolve_array_search(ares, areslen, name)) {
+
+                if (resolve_read_g(wres, info->base.s, name) <= 0)
+                    log_dieusys(LOG_EXIT_SYS,"read resolve file of: ",name) ;
+
+                ares[areslen++] = dres ;
+            }
+
+            resolve_free(wres) ;
+        }
+
+        resolve_free(wres) ;
+    }
+
+
+    return areslen ;
+}

src/lib66/service/service_resolve_get_field_tosa.c

@@ -29,155 +29,341 @@ int service_resolve_get_field_tosa(stralloc *sa, resolve_service_t *res, resolve
 
     char fmt[UINT32_FMT] ;
     char const *str = 0 ;
+    int e = 0 ;
 
     switch(field) {
 
-        case SERVICE_ENUM_NAME:
+        // configuration
+
+        case E_RESOLVE_SERVICE_NAME:
             str = res->sa.s + res->name ;
             break ;
 
-        case SERVICE_ENUM_DESCRIPTION:
+        case E_RESOLVE_SERVICE_DESCRIPTION:
             str = res->sa.s + res->description ;
             break ;
 
-        case SERVICE_ENUM_VERSION:
+        case E_RESOLVE_SERVICE_VERSION:
             str = res->sa.s + res->version ;
             break ;
 
-        case SERVICE_ENUM_LOGGER:
-            str = res->sa.s + res->logger ;
+        case E_RESOLVE_SERVICE_TYPE:
+            fmt[uint32_fmt(fmt,res->type)] = 0 ;
+            str = fmt ;
             break ;
 
-        case SERVICE_ENUM_LOGREAL:
-            str = res->sa.s + res->logreal ;
+        case E_RESOLVE_SERVICE_NOTIFY:
+            fmt[uint32_fmt(fmt,res->notify)] = 0 ;
+            str = fmt ;
             break ;
 
-        case SERVICE_ENUM_LOGASSOC:
-            str = res->sa.s + res->logassoc ;
+        case E_RESOLVE_SERVICE_MAXDEATH:
+            fmt[uint32_fmt(fmt,res->maxdeath)] = 0 ;
+            str = fmt ;
             break ;
 
-        case SERVICE_ENUM_DSTLOG:
-            str = res->sa.s + res->dstlog ;
+        case E_RESOLVE_SERVICE_EARLIER:
+            fmt[uint32_fmt(fmt,res->earlier)] = 0 ;
+            str = fmt ;
             break ;
 
-        case SERVICE_ENUM_DEPENDS:
-            str = res->sa.s + res->depends ;
+        case E_RESOLVE_SERVICE_HIERCOPY:
+            str = res->sa.s + res->hiercopy ;
             break ;
 
-        case SERVICE_ENUM_REQUIREDBY:
-            str = res->sa.s + res->requiredby ;
+        case E_RESOLVE_SERVICE_INTREE:
+            str = res->sa.s + res->intree ;
             break ;
 
-        case SERVICE_ENUM_OPTSDEPS:
-            str = res->sa.s + res->optsdeps ;
+        case E_RESOLVE_SERVICE_OWNERSTR:
+            str = res->sa.s + res->ownerstr ;
             break ;
 
-        case SERVICE_ENUM_EXTDEPS:
-            str = res->sa.s + res->extdeps ;
+        case E_RESOLVE_SERVICE_OWNER:
+            fmt[uint32_fmt(fmt,res->owner)] = 0 ;
+            str = fmt ;
             break ;
 
-        case SERVICE_ENUM_CONTENTS:
-            str = res->sa.s + res->contents ;
+        case E_RESOLVE_SERVICE_TREENAME:
+            str = res->sa.s + res->treename ;
             break ;
 
-        case SERVICE_ENUM_SRC:
-            str = res->sa.s + res->src ;
+        case E_RESOLVE_SERVICE_USER:
+            str = res->sa.s + res->user ;
             break ;
 
-        case SERVICE_ENUM_SRCONF:
-            str = res->sa.s + res->srconf ;
+        case E_RESOLVE_SERVICE_INMODULE:
+            str = res->sa.s + res->inmodule ;
             break ;
 
-        case SERVICE_ENUM_LIVE:
-            str = res->sa.s + res->live ;
+        // path configuration
+
+        case E_RESOLVE_SERVICE_HOME:
+            str = res->sa.s + res->path.home ;
             break ;
 
-        case SERVICE_ENUM_RUNAT:
-            str = res->sa.s + res->runat ;
+        case E_RESOLVE_SERVICE_FRONTEND:
+            str = res->sa.s + res->path.frontend ;
             break ;
 
-        case SERVICE_ENUM_TREE:
-            str = res->sa.s + res->tree ;
+        case E_RESOLVE_SERVICE_TREE:
+            str = res->sa.s + res->path.tree ;
             break ;
 
-        case SERVICE_ENUM_TREENAME:
-            str = res->sa.s + res->treename ;
+        case E_RESOLVE_SERVICE_STATUS:
+            str = res->sa.s + res->path.status ;
+
+        // dependencies
+
+        case E_RESOLVE_SERVICE_DEPENDS:
+            str = res->sa.s + res->dependencies.depends ;
+            break ;
+
+        case E_RESOLVE_SERVICE_REQUIREDBY:
+            str = res->sa.s + res->dependencies.requiredby ;
             break ;
 
-        case SERVICE_ENUM_STATE:
-            str = res->sa.s + res->state ;
+        case E_RESOLVE_SERVICE_OPTSDEPS:
+            str = res->sa.s + res->dependencies.optsdeps ;
             break ;
 
-        case SERVICE_ENUM_EXEC_RUN:
-            str = res->sa.s + res->exec_run ;
+        case E_RESOLVE_SERVICE_NDEPENDS:
+            fmt[uint32_fmt(fmt,res->dependencies.ndepends)] = 0 ;
+            str = fmt ;
             break ;
 
-        case SERVICE_ENUM_EXEC_LOG_RUN:
-            str = res->sa.s + res->exec_log_run ;
+        case E_RESOLVE_SERVICE_NREQUIREDBY:
+            fmt[uint32_fmt(fmt,res->dependencies.nrequiredby)] = 0 ;
+            str = fmt ;
             break ;
 
-        case SERVICE_ENUM_REAL_EXEC_RUN:
-            str = res->sa.s + res->real_exec_run ;
+        case E_RESOLVE_SERVICE_NOPTSDEPS:
+            fmt[uint32_fmt(fmt,res->dependencies.noptsdeps)] = 0 ;
+            str = fmt ;
             break ;
 
-        case SERVICE_ENUM_REAL_EXEC_LOG_RUN:
-            str = res->sa.s + res->real_exec_log_run ;
+        // execute
+
+        case E_RESOLVE_SERVICE_RUN:
+            str = res->sa.s + res->execute.run.run ;
             break ;
 
-        case SERVICE_ENUM_EXEC_FINISH:
-            str = res->sa.s + res->exec_finish ;
+        case E_RESOLVE_SERVICE_RUN_USER:
+            str = res->sa.s + res->execute.run.run_user ;
             break ;
 
-        case SERVICE_ENUM_REAL_EXEC_FINISH:
-            str = res->sa.s + res->real_exec_finish ;
+        case E_RESOLVE_SERVICE_RUN_BUILD:
+            str = res->sa.s + res->execute.run.build ;
             break ;
 
-        case SERVICE_ENUM_TYPE:
-            fmt[uint32_fmt(fmt,res->type)] = 0 ;
+        case E_RESOLVE_SERVICE_RUN_SHEBANG:
+            str = res->sa.s + res->execute.run.shebang ;
+            break ;
+
+        case E_RESOLVE_SERVICE_RUN_RUNAS:
+            str = res->sa.s + res->execute.run.runas ;
+            break ;
+
+        case E_RESOLVE_SERVICE_FINISH:
+            str = res->sa.s + res->execute.finish.run ;
+            break ;
+
+        case E_RESOLVE_SERVICE_FINISH_USER:
+            str = res->sa.s + res->execute.finish.run_user ;
+            break ;
+
+        case E_RESOLVE_SERVICE_FINISH_BUILD:
+            str = res->sa.s + res->execute.finish.build ;
+            break ;
+
+        case E_RESOLVE_SERVICE_FINISH_SHEBANG:
+            str = res->sa.s + res->execute.finish.shebang ;
+            break ;
+
+        case E_RESOLVE_SERVICE_FINISH_RUNAS:
+            str = res->sa.s + res->execute.finish.runas ;
+            break ;
+
+        case E_RESOLVE_SERVICE_TIMEOUTKILL:
+            fmt[uint32_fmt(fmt,res->execute.timeout.kill)] = 0 ;
+            str = fmt ;
+            break ;
+
+        case E_RESOLVE_SERVICE_TIMEOUTFINISH:
+            fmt[uint32_fmt(fmt,res->execute.timeout.finish)] = 0 ;
+            str = fmt ;
+            break ;
+
+        case E_RESOLVE_SERVICE_TIMEOUTUP:
+            fmt[uint32_fmt(fmt,res->execute.timeout.up)] = 0 ;
+            str = fmt ;
+            break ;
+
+        case E_RESOLVE_SERVICE_TIMEOUTDOWN:
+            fmt[uint32_fmt(fmt,res->execute.timeout.down)] = 0 ;
+            str = fmt ;
+            break ;
+
+        case E_RESOLVE_SERVICE_DOWN:
+            fmt[uint32_fmt(fmt,res->execute.down)] = 0 ;
+            str = fmt ;
+            break ;
+
+        case E_RESOLVE_SERVICE_DOWNSIGNAL:
+            fmt[uint32_fmt(fmt,res->execute.downsignal)] = 0 ;
+            str = fmt ;
+            break ;
+
+        // live
+
+        case E_RESOLVE_SERVICE_LIVEDIR:
+            str = res->sa.s + res->live.livedir ;
+            break ;
+
+        case E_RESOLVE_SERVICE_SCANDIR:
+            str = res->sa.s + res->live.scandir ;
+            break ;
+
+        case E_RESOLVE_SERVICE_STATEDIR:
+            str = res->sa.s + res->live.statedir ;
+            break ;
+
+        case E_RESOLVE_SERVICE_EVENTDIR:
+            str = res->sa.s + res->live.eventdir ;
+            break ;
+
+        case E_RESOLVE_SERVICE_NOTIFDIR:
+            str = res->sa.s + res->live.notifdir ;
+            break ;
+
+        case E_RESOLVE_SERVICE_SUPERVISEDIR:
+            str = res->sa.s + res->live.supervisedir ;
+            break ;
+
+        case E_RESOLVE_SERVICE_FDHOLDERDIR:
+            str = res->sa.s + res->live.fdholderdir ;
+            break ;
+
+        case E_RESOLVE_SERVICE_ONESHOTDDIR:
+            str = res->sa.s + res->live.oneshotddir ;
+            break ;
+
+        // logger
+
+        case E_RESOLVE_SERVICE_LOGNAME:
+            str = res->sa.s + res->logger.name ;
+            break ;
+
+        case E_RESOLVE_SERVICE_LOGDESTINATION:
+            str = res->sa.s + res->logger.destination ;
+            break ;
+
+        case E_RESOLVE_SERVICE_LOGBACKUP:
+            fmt[uint32_fmt(fmt,res->logger.backup)] = 0 ;
+            str = fmt ;
+            break ;
+
+        case E_RESOLVE_SERVICE_LOGMAXSIZE:
+            fmt[uint32_fmt(fmt,res->logger.maxsize)] = 0 ;
+            str = fmt ;
+            break ;
+
+        case E_RESOLVE_SERVICE_LOGTIMESTAMP:
+            fmt[uint32_fmt(fmt,res->logger.timestamp)] = 0 ;
             str = fmt ;
             break ;
 
-        case SERVICE_ENUM_NDEPENDS:
-            fmt[uint32_fmt(fmt,res->ndepends)] = 0 ;
+        case E_RESOLVE_SERVICE_LOGWANT:
+            fmt[uint32_fmt(fmt,res->logger.want)] = 0 ;
             str = fmt ;
             break ;
 
-        case SERVICE_ENUM_NREQUIREDBY:
-            fmt[uint32_fmt(fmt,res->nrequiredby)] = 0 ;
+        case E_RESOLVE_SERVICE_LOGRUN:
+            str = res->sa.s + res->logger.execute.run.run ;
+            break ;
+
+        case E_RESOLVE_SERVICE_LOGRUN_USER:
+            str = res->sa.s + res->logger.execute.run.run_user ;
+            break ;
+
+        case E_RESOLVE_SERVICE_LOGRUN_BUILD:
+            str = res->sa.s + res->logger.execute.run.build ;
+            break ;
+
+        case E_RESOLVE_SERVICE_LOGRUN_SHEBANG:
+            str = res->sa.s + res->logger.execute.run.shebang ;
+            break ;
+
+        case E_RESOLVE_SERVICE_LOGRUN_RUNAS:
+            str = res->sa.s + res->logger.execute.run.runas ;
+            break ;
+
+        case E_RESOLVE_SERVICE_LOGTIMEOUTKILL:
+            fmt[uint32_fmt(fmt,res->logger.timeout.kill)] = 0 ;
             str = fmt ;
             break ;
 
-        case SERVICE_ENUM_NOPTSDEPS:
-            fmt[uint32_fmt(fmt,res->noptsdeps)] = 0 ;
+        case E_RESOLVE_SERVICE_LOGTIMEOUTFINISH:
+            fmt[uint32_fmt(fmt,res->logger.timeout.finish)] = 0 ;
             str = fmt ;
             break ;
 
-        case SERVICE_ENUM_NEXTDEPS:
-            fmt[uint32_fmt(fmt,res->nextdeps)] = 0 ;
+
+        // environment
+
+        case E_RESOLVE_SERVICE_ENV:
+            str = res->sa.s + res->environ.env ;
+            break ;
+
+        case E_RESOLVE_SERVICE_ENVDIR:
+            str = res->sa.s + res->environ.envdir ;
+            break ;
+
+        case E_RESOLVE_SERVICE_ENV_OVERWRITE:
+            fmt[uint32_fmt(fmt,res->environ.env_overwrite)] = 0 ;
             str = fmt ;
             break ;
 
-        case SERVICE_ENUM_NCONTENTS:
-            fmt[uint32_fmt(fmt,res->ncontents)] = 0 ;
+        // regex
+
+        case E_RESOLVE_SERVICE_REGEX_CONFIGURE:
+            str = res->sa.s + res->regex.directories ;
+            break ;
+
+        case E_RESOLVE_SERVICE_REGEX_DIRECTORIES:
+            str = res->sa.s + res->regex.directories ;
+            break ;
+
+        case E_RESOLVE_SERVICE_REGEX_FILES:
+            str = res->sa.s + res->regex.files ;
+            break ;
+
+        case E_RESOLVE_SERVICE_REGEX_INFILES:
+            str = res->sa.s + res->regex.infiles ;
+            break ;
+
+        case E_RESOLVE_SERVICE_REGEX_NDIRECTORIES:
+            fmt[uint32_fmt(fmt,res->regex.ndirectories)] = 0 ;
             str = fmt ;
             break ;
 
-        case SERVICE_ENUM_DOWN:
-            fmt[uint32_fmt(fmt,res->down)] = 0 ;
+        case E_RESOLVE_SERVICE_REGEX_NFILES:
+            fmt[uint32_fmt(fmt,res->regex.nfiles)] = 0 ;
             str = fmt ;
             break ;
 
-        case SERVICE_ENUM_DISEN:
-            fmt[uint32_fmt(fmt,res->disen)] = 0 ;
+        case E_RESOLVE_SERVICE_REGEX_NINFILES:
+            fmt[uint32_fmt(fmt,res->regex.ninfiles)] = 0 ;
             str = fmt ;
             break ;
 
         default:
-            return 0 ;
+            return e ;
     }
 
     if (!auto_stra(sa,str))
-        return 0 ;
+        return e ;
 
-    return 1 ;
+    e = 1 ;
+    return e ;
 }

src/lib66/service/service_resolve_master_copy.c

@@ -36,15 +36,19 @@ int service_resolve_master_copy(resolve_service_master_t *dst, resolve_service_m
     dst->name = mres->name ;
     dst->classic = mres->classic ;
     dst->bundle = mres->bundle ;
-    dst->longrun = mres->longrun ;
     dst->oneshot = mres->oneshot ;
     dst->module = mres->module ;
+    dst->enabled = mres->enabled ;
+    dst->disabled = mres->disabled ;
+    dst->contents = mres->contents ;
 
     dst->nclassic = mres->nclassic ;
     dst->nbundle = mres->nbundle ;
-    dst->nlongrun = mres->nlongrun ;
     dst->noneshot = mres->noneshot ;
     dst->nmodule = mres->nmodule ;
+    dst->nenabled = mres->nenabled ;
+    dst->ndisabled = mres->ndisabled ;
+    dst->ncontents = mres->ncontents ;
 
     return 1 ;
 

src/lib66/service/service_resolve_master_get_field_tosa.c

@@ -29,52 +29,70 @@ int service_resolve_master_get_field_tosa(stralloc *sa, resolve_service_master_t
 
     switch(field) {
 
-        case SERVICE_ENUM_MASTER_NAME:
+        case E_RESOLVE_SERVICE_MASTER_NAME:
             str = mres->sa.s + mres->name ;
             break ;
 
-        case SERVICE_ENUM_MASTER_CLASSIC:
+        case E_RESOLVE_SERVICE_MASTER_CLASSIC:
             str = mres->sa.s + mres->classic ;
             break ;
 
-        case SERVICE_ENUM_MASTER_LONGRUN:
-            str = mres->sa.s + mres->longrun ;
-            break ;
-
-        case SERVICE_ENUM_MASTER_BUNDLE:
+        case E_RESOLVE_SERVICE_MASTER_BUNDLE:
             str = mres->sa.s + mres->bundle ;
             break ;
 
-        case SERVICE_ENUM_MASTER_ONESHOT:
+        case E_RESOLVE_SERVICE_MASTER_ONESHOT:
             str = mres->sa.s + mres->oneshot ;
             break ;
 
-        case SERVICE_ENUM_MASTER_MODULE:
+        case E_RESOLVE_SERVICE_MASTER_MODULE:
             str = mres->sa.s + mres->module ;
             break ;
 
-        case SERVICE_ENUM_MASTER_NCLASSIC:
+        case E_RESOLVE_SERVICE_MASTER_ENABLED:
+            str = mres->sa.s + mres->enabled ;
+            break ;
+
+        case E_RESOLVE_SERVICE_MASTER_DISABLED:
+            str = mres->sa.s + mres->disabled ;
+            break ;
+
+        case E_RESOLVE_SERVICE_MASTER_CONTENTS:
+            str = mres->sa.s + mres->contents ;
+            break ;
+
+        case E_RESOLVE_SERVICE_MASTER_NCLASSIC:
             fmt[uint32_fmt(fmt,mres->nclassic)] = 0 ;
             str = fmt ;
             break ;
 
-        case SERVICE_ENUM_MASTER_NBUNDLE:
+        case E_RESOLVE_SERVICE_MASTER_NBUNDLE:
             fmt[uint32_fmt(fmt,mres->nbundle)] = 0 ;
             str = fmt ;
             break ;
 
-        case SERVICE_ENUM_MASTER_NLONGRUN:
-            fmt[uint32_fmt(fmt,mres->nlongrun)] = 0 ;
+        case E_RESOLVE_SERVICE_MASTER_NONESHOT:
+            fmt[uint32_fmt(fmt,mres->noneshot)] = 0 ;
+            str = fmt ;
+            break ;
+
+        case E_RESOLVE_SERVICE_MASTER_NMODULE:
+            fmt[uint32_fmt(fmt,mres->nmodule)] = 0 ;
             str = fmt ;
             break ;
 
-        case SERVICE_ENUM_MASTER_NONESHOT:
-            fmt[uint32_fmt(fmt,mres->noneshot)] = 0 ;
+        case E_RESOLVE_SERVICE_MASTER_NENABLED:
+            fmt[uint32_fmt(fmt,mres->nenabled)] = 0 ;
             str = fmt ;
             break ;
 
-        case SERVICE_ENUM_MASTER_NMODULE:
-            fmt[uint32_fmt(fmt,mres->nmodule)] = 0 ;
+        case E_RESOLVE_SERVICE_MASTER_NDISABLED:
+            fmt[uint32_fmt(fmt,mres->ndisabled)] = 0 ;
+            str = fmt ;
+            break ;
+
+        case E_RESOLVE_SERVICE_MASTER_NCONTENTS:
+            fmt[uint32_fmt(fmt,mres->ncontents)] = 0 ;
             str = fmt ;
             break ;
 

src/lib66/service/service_resolve_master_modify_field.c

@@ -26,19 +26,23 @@
 
 resolve_field_table_t resolve_service_master_field_table[] = {
 
-    [SERVICE_ENUM_MASTER_NAME] = { .field = "name" },
-    [SERVICE_ENUM_MASTER_CLASSIC] = { .field = "classic" },
-    [SERVICE_ENUM_MASTER_BUNDLE] = { .field = "bundle" },
-    [SERVICE_ENUM_MASTER_LONGRUN] = { .field = "longrun" },
-    [SERVICE_ENUM_MASTER_ONESHOT] = { .field = "oneshot" },
-    [SERVICE_ENUM_MASTER_MODULE] = { .field = "module" },
-
-    [SERVICE_ENUM_MASTER_NCLASSIC] = { .field = "nclassic" },
-    [SERVICE_ENUM_MASTER_NBUNDLE] = { .field = "nbundle" },
-    [SERVICE_ENUM_MASTER_NLONGRUN] = { .field = "nlongrun" },
-    [SERVICE_ENUM_MASTER_NONESHOT] = { .field = "noneshot" },
-    [SERVICE_ENUM_MASTER_NMODULE] = { .field = "nmodule" },
-    [SERVICE_ENUM_MASTER_ENDOFKEY] = { .field = 0 },
+    [E_RESOLVE_SERVICE_MASTER_NAME] = { .field = "name" },
+    [E_RESOLVE_SERVICE_MASTER_CLASSIC] = { .field = "classic" },
+    [E_RESOLVE_SERVICE_MASTER_BUNDLE] = { .field = "bundle" },
+    [E_RESOLVE_SERVICE_MASTER_ONESHOT] = { .field = "oneshot" },
+    [E_RESOLVE_SERVICE_MASTER_MODULE] = { .field = "module" },
+    [E_RESOLVE_SERVICE_MASTER_ENABLED] = { .field = "enabled" },
+    [E_RESOLVE_SERVICE_MASTER_DISABLED] = { .field = "disabled" },
+    [E_RESOLVE_SERVICE_MASTER_CONTENTS] = { .field = "contents" },
+
+    [E_RESOLVE_SERVICE_MASTER_NCLASSIC] = { .field = "nclassic" },
+    [E_RESOLVE_SERVICE_MASTER_NBUNDLE] = { .field = "nbundle" },
+    [E_RESOLVE_SERVICE_MASTER_NONESHOT] = { .field = "noneshot" },
+    [E_RESOLVE_SERVICE_MASTER_NMODULE] = { .field = "nmodule" },
+    [E_RESOLVE_SERVICE_MASTER_NENABLED] = { .field = "nenabled" },
+    [E_RESOLVE_SERVICE_MASTER_NDISABLED] = { .field = "ndisabled" },
+    [E_RESOLVE_SERVICE_MASTER_NCONTENTS] = { .field = "ncontents" },
+    [E_RESOLVE_SERVICE_MASTER_ENDOFKEY] = { .field = 0 },
 } ;
 
 int service_resolve_master_modify_field(resolve_service_master_t *mres, uint8_t field, char const *data)
@@ -52,53 +56,85 @@ int service_resolve_master_modify_field(resolve_service_master_t *mres, uint8_t
 
     switch(field) {
 
-        case SERVICE_ENUM_MASTER_NAME:
+        case E_RESOLVE_SERVICE_MASTER_NAME:
             mres->name = resolve_add_string(wres,data) ;
             break ;
 
-        case SERVICE_ENUM_MASTER_CLASSIC:
+        case E_RESOLVE_SERVICE_MASTER_CLASSIC:
             mres->classic = resolve_add_string(wres,data) ;
             break ;
 
-        case SERVICE_ENUM_MASTER_BUNDLE:
+        case E_RESOLVE_SERVICE_MASTER_BUNDLE:
             mres->bundle = resolve_add_string(wres,data) ;
             break ;
 
-        case SERVICE_ENUM_MASTER_LONGRUN:
-            mres->longrun = resolve_add_string(wres,data) ;
-            break ;
-
-        case SERVICE_ENUM_MASTER_ONESHOT:
+        case E_RESOLVE_SERVICE_MASTER_ONESHOT:
             mres->oneshot = resolve_add_string(wres,data) ;
             break ;
 
-        case SERVICE_ENUM_MASTER_MODULE:
+        case E_RESOLVE_SERVICE_MASTER_MODULE:
             mres->module = resolve_add_string(wres,data) ;
             break ;
 
-        case SERVICE_ENUM_MASTER_NCLASSIC:
+        case E_RESOLVE_SERVICE_MASTER_ENABLED:
+            mres->enabled = resolve_add_string(wres,data) ;
+            break ;
+
+        case E_RESOLVE_SERVICE_MASTER_DISABLED:
+            mres->disabled = resolve_add_string(wres,data) ;
+            break ;
+
+        case E_RESOLVE_SERVICE_MASTER_CONTENTS:
+            mres->contents = resolve_add_string(wres,data) ;
+            break ;
+
+        case E_RESOLVE_SERVICE_MASTER_NCLASSIC:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
             mres->nclassic= ifield ;
             break ;
 
-        case SERVICE_ENUM_MASTER_NBUNDLE:
+        case E_RESOLVE_SERVICE_MASTER_NBUNDLE:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
             mres->nbundle = ifield ;
             break ;
 
-        case SERVICE_ENUM_MASTER_NLONGRUN:
+        case E_RESOLVE_SERVICE_MASTER_NONESHOT:
+            if (!data)
+                data = "0" ;
+            if (!uint0_scan(data, &ifield)) goto err ;
+            mres->noneshot = ifield ;
+            break ;
+
+        case E_RESOLVE_SERVICE_MASTER_NMODULE:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
-            mres->nlongrun = ifield ;
+            mres->nmodule = ifield ;
             break ;
 
-        case SERVICE_ENUM_MASTER_NONESHOT:
+        case E_RESOLVE_SERVICE_MASTER_NENABLED:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
-            mres->noneshot = ifield ;
+            mres->nenabled = ifield ;
             break ;
 
-        case SERVICE_ENUM_MASTER_NMODULE:
+        case E_RESOLVE_SERVICE_MASTER_NDISABLED:
+            if (!data)
+                data = "0" ;
             if (!uint0_scan(data, &ifield)) goto err ;
-            mres->nmodule = ifield ;
+            mres->ndisabled = ifield ;
+            break ;
+
+        case E_RESOLVE_SERVICE_MASTER_NCONTENTS:
+            if (!data)
+                data = "0" ;
+            if (!uint0_scan(data, &ifield)) goto err ;
+            mres->ncontents = ifield ;
             break ;
 
         default:

src/lib66/service/service_resolve_master_read_cdb.c

@@ -47,10 +47,6 @@ int service_resolve_master_read_cdb(cdb *c, resolve_service_master_t *tres)
     resolve_find_cdb(&tmp,c,"bundle") ;
     tres->bundle = tmp.len ? resolve_add_string(wres,tmp.s) : 0 ;
 
-    /* longrun */
-    resolve_find_cdb(&tmp,c,"longrun") ;
-    tres->longrun = tmp.len ? resolve_add_string(wres,tmp.s) : 0 ;
-
     /* oneshot */
     resolve_find_cdb(&tmp,c,"oneshot") ;
     tres->oneshot = tmp.len ? resolve_add_string(wres,tmp.s) : 0 ;
@@ -59,6 +55,18 @@ int service_resolve_master_read_cdb(cdb *c, resolve_service_master_t *tres)
     resolve_find_cdb(&tmp,c,"module") ;
     tres->module = tmp.len ? resolve_add_string(wres,tmp.s) : 0 ;
 
+    /* enabled */
+    resolve_find_cdb(&tmp,c,"enabled") ;
+    tres->enabled = tmp.len ? resolve_add_string(wres,tmp.s) : 0 ;
+
+    /* disabled */
+    resolve_find_cdb(&tmp,c,"disabled") ;
+    tres->disabled = tmp.len ? resolve_add_string(wres,tmp.s) : 0 ;
+
+    /* contents */
+    resolve_find_cdb(&tmp,c,"contents") ;
+    tres->contents = tmp.len ? resolve_add_string(wres,tmp.s) : 0 ;
+
     /* nclassic */
     x = resolve_find_cdb(&tmp,c,"nclassic") ;
     tres->nclassic = x ;
@@ -67,10 +75,6 @@ int service_resolve_master_read_cdb(cdb *c, resolve_service_master_t *tres)
     x = resolve_find_cdb(&tmp,c,"nbundle") ;
     tres->nbundle = x ;
 
-    /* nlongrun */
-    x = resolve_find_cdb(&tmp,c,"nlongrun") ;
-    tres->nlongrun = x ;
-
     /* noneshot */
     x = resolve_find_cdb(&tmp,c,"noneshot") ;
     tres->noneshot = x ;
@@ -79,6 +83,18 @@ int service_resolve_master_read_cdb(cdb *c, resolve_service_master_t *tres)
     x = resolve_find_cdb(&tmp,c,"nmodule") ;
     tres->nmodule = x ;
 
+    /* nenabled */
+    x = resolve_find_cdb(&tmp,c,"nenabled") ;
+    tres->nenabled = x ;
+
+    /* ndisabled */
+    x = resolve_find_cdb(&tmp,c,"ndisabled") ;
+    tres->ndisabled = x ;
+
+    /* ncontents */
+    x = resolve_find_cdb(&tmp,c,"ncontents") ;
+    tres->ncontents = x ;
+
     free(wres) ;
     stralloc_free(&tmp) ;
 

src/lib66/service/service_resolve_master_write.c

@@ -16,12 +16,15 @@
 
 #include <oblibs/log.h>
 #include <oblibs/string.h>
+#include <oblibs/types.h>
 
 #include <skalibs/genalloc.h>
 
 #include <66/constants.h>
 #include <66/resolve.h>
 #include <66/graph.h>
+#include <66/enum.h>
+#include <66/state.h>
 #include <66/service.h>
 
 int service_resolve_master_write(graph_t *graph, char const *dest)
@@ -31,6 +34,7 @@ int service_resolve_master_write(graph_t *graph, char const *dest)
     int e = 0 ;
     unsigned int pos = 0 ;
 
+    ss_state_t ste = STATE_ZERO ;
     resolve_service_master_t mres = RESOLVE_SERVICE_MASTER_ZERO ;
     resolve_wrapper_t_ref mwres = resolve_set_struct(DATA_SERVICE_MASTER, &mres) ;
 
@@ -39,54 +43,67 @@ int service_resolve_master_write(graph_t *graph, char const *dest)
 
     resolve_init(mwres) ;
 
-    {
-        for (; pos < graph->sort_count ; pos++) {
 
-           char *name = graph->data.s + genalloc_s(graph_hash_t,&graph->hash)[graph->sort[pos]].vertex ;
+    for (; pos < graph->sort_count ; pos++) {
 
-            if (resolve_read_g(wres, dest, name) <= 0) {
-                log_warnu("read resolve file of: ", dest, name) ;
-                goto err ;
-            }
+        char *name = graph->data.s + genalloc_s(graph_hash_t,&graph->hash)[graph->sort[pos]].vertex ;
+
+        if (!resolve_check(dest, name) ||
+            !resolve_read(wres, dest, name)) {
+            log_warnu("read resolve file of: ", dest, name) ;
+            goto err ;
+        }
 
-            switch (res.type) {
+        switch (res.type) {
 
-                case TYPE_CLASSIC:
+            case TYPE_CLASSIC:
 
-                    mres.classic = resolve_add_string(mwres, res.sa.s + res.name) ;
-                    mres.nclassic++ ;
-                    break ;
+                mres.classic = resolve_add_string(mwres, name) ;
+                mres.nclassic++ ;
+                break ;
 
-                case TYPE_BUNDLE:
+            case TYPE_BUNDLE:
 
-                    mres.bundle = resolve_add_string(mwres, res.sa.s + res.name) ;
-                    mres.nbundle++ ;
-                    break ;
+                mres.bundle = resolve_add_string(mwres, name) ;
+                mres.nbundle++ ;
+                break ;
 
-                case TYPE_LONGRUN:
+            case TYPE_ONESHOT:
 
-                    mres.longrun = resolve_add_string(mwres, res.sa.s + res.name) ;
-                    mres.nlongrun++ ;
-                    break ;
+                mres.oneshot = resolve_add_string(mwres, name) ;
+                mres.noneshot++ ;
+                break ;
 
+            case TYPE_MODULE:
 
-                case TYPE_ONESHOT:
+                mres.module = resolve_add_string(mwres, name) ;
+                mres.nmodule++ ;
+                break ;
 
-                    mres.oneshot = resolve_add_string(mwres, res.sa.s + res.name) ;
-                    mres.noneshot++ ;
-                    break ;
+            default:
+                log_warn("unknown type") ;
+                goto err ;
+        }
 
-                case TYPE_MODULE:
+        if (!state_read(&ste, res.sa.s + res.path.home, name))
+            log_warnu("read state file of: ", name) ;
 
-                    mres.module = resolve_add_string(mwres, res.sa.s + res.name) ;
-                    mres.nmodule++ ;
-                    break ;
 
-                default:
-                    log_warn("unknown type") ;
-                    goto err ;
-            }
+        if (!FLAGS_ISSET(ste.isenabled, STATE_FLAGS_TRUE)) {
+
+            /* disabled */
+            mres.disabled = resolve_add_string(mwres, res.sa.s + res.name) ;
+            mres.ndisabled++ ;
+
+        } else {
+            /* enabled */
+
+            mres.enabled = resolve_add_string(mwres, res.sa.s + res.name) ;
+            mres.nenabled++ ;
         }
+
+        mres.contents = resolve_add_string(mwres, res.sa.s + res.name) ;
+        mres.ncontents++ ;
     }
 
     if (!resolve_write(mwres, dest, SS_MASTER + 1))

src/lib66/service/service_resolve_master_write_cdb.c

@@ -34,29 +34,41 @@ int service_resolve_master_write_cdb(cdbmaker *c, resolve_service_master_t *mres
     /* bundle */
     !resolve_add_cdb(c,"bundle",str + mres->bundle) ||
 
-    /* longrun */
-    !resolve_add_cdb(c,"longrun",str + mres->longrun) ||
-
     /* oneshot */
     !resolve_add_cdb(c,"oneshot",str + mres->oneshot) ||
 
     /* module */
     !resolve_add_cdb(c,"module",str + mres->module) ||
 
+    /* enabled */
+    !resolve_add_cdb(c,"enabled",str + mres->enabled) ||
+
+    /* disabled */
+    !resolve_add_cdb(c,"disabled",str + mres->disabled) ||
+
+    /* contents */
+    !resolve_add_cdb(c,"contents",str + mres->contents) ||
+
     /* nclassic */
     !resolve_add_cdb_uint(c,"nclassic",mres->nclassic) ||
 
     /* nbundle */
     !resolve_add_cdb_uint(c,"nbundle",mres->nbundle) ||
 
-    /* nlongrun */
-    !resolve_add_cdb_uint(c,"nlongrun",mres->nlongrun) ||
-
     /* noneshot */
     !resolve_add_cdb_uint(c,"noneshot",mres->noneshot) ||
 
     /* nmodule */
-    !resolve_add_cdb_uint(c,"nmodule",mres->nmodule)) return 0 ;
+    !resolve_add_cdb_uint(c,"nmodule",mres->nmodule) ||
+
+    /* nenabled */
+    !resolve_add_cdb_uint(c,"nenabled",mres->nenabled) ||
+
+    /* ndisabled */
+    !resolve_add_cdb_uint(c,"ndisabled",mres->ndisabled) ||
+
+    /* ncontents */
+    !resolve_add_cdb_uint(c,"ncontents",mres->ncontents)) return 0 ;
 
     return 1 ;
 }