Changeset 9532981 in mainline


Ignore:
Timestamp:
2019-08-07T09:35:37Z (5 years ago)
Author:
Matthieu Riolo <matthieu.riolo@…>
Children:
db34424
Parents:
af92309
git-author:
Michal Koutný <xm.koutny+hos@…> (2015-11-02 23:10:51)
git-committer:
Matthieu Riolo <matthieu.riolo@…> (2019-08-07 09:35:37)
Message:

sysman: Rename dependency to edge (more generic)

Location:
uspace
Files:
13 edited
2 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/include/ipc/sysman.h

    raf92309 r9532981  
    6767
    6868typedef enum {
    69         STATE_EMBRYO = 0,
     69        STATE_EMBRYO = 0, // embryo is orthogonal to states (again convergence to systemd...)
    7070        STATE_STARTING,
    7171        STATE_STARTED,

  • uspace/srv/sysman/Makefile

    raf92309 r9532981  
    4040        connection_broker.c \
    4141        connection_ctl.c \
    42         dep.c \
     42        edge.c \
    4343        job.c \
    4444        log.c \

  • uspace/srv/sysman/edge.c

    raf92309 r9532981  
    3232#include <str.h>
    3333
    34 #include "dep.h"
     34#include "edge.h"
    3535
    36 static void dep_dependency_init(unit_dependency_t *dep)
     36static void edge_init(unit_edge_t *e)
    3737{
    38         memset(dep, 0, sizeof(*dep));
    39         link_initialize(&dep->dependants);
    40         link_initialize(&dep->dependencies);
    41 
    42         dep->state = DEP_EMBRYO;
     38        memset(e, 0, sizeof(*e));
     39        link_initialize(&e->edges_in);
     40        link_initialize(&e->edges_out);
    4341}
    4442
    45 unit_dependency_t *dep_dependency_create(void)
     43unit_edge_t *edge_create(void)
    4644{
    47         unit_dependency_t *dep = malloc(sizeof(unit_dependency_t));
    48         if (dep) {
    49                 dep_dependency_init(dep);
     45        unit_edge_t *e = malloc(sizeof(unit_edge_t));
     46        if (e) {
     47                edge_init(e);
    5048        }
    51         return dep;
     49        return e;
    5250}
    5351
    54 void dep_dependency_destroy(unit_dependency_t **dep_ptr)
     52void edge_destroy(unit_edge_t **e_ptr)
    5553{
    56         unit_dependency_t *dep = *dep_ptr;
    57         if (dep == NULL) {
     54        unit_edge_t *e = *e_ptr;
     55        if (e == NULL) {
    5856                return;
    5957        }
    6058
    61         list_remove(&dep->dependencies);
    62         list_remove(&dep->dependants);
     59        list_remove(&e->edges_in);
     60        list_remove(&e->edges_out);
    6361
    64         free(dep->dependency_name);
    65         free(dep);
     62        free(e->output_name);
     63        free(e);
    6664
    67         *dep_ptr = NULL;
     65        *e_ptr = NULL;
    6866}
    6967
    70 int dep_sprout_dependency(unit_t *dependant, const char *dependency_name)
     68int edge_sprout_out(unit_t *input, const char *output_name)
    7169{
    72         unit_dependency_t *dep = dep_dependency_create();
     70        unit_edge_t *e = edge_create();
    7371        int rc;
    7472
    75         if (dep == NULL) {
     73        if (e == NULL) {
    7674                rc = ENOMEM;
    7775                goto finish;
    7876        }
    7977
    80         dep->dependency_name = str_dup(dependency_name);
    81         if (dep->dependency_name == NULL) {
     78        e->output_name = str_dup(output_name);
     79        if (e->output_name == NULL) {
    8280                rc = ENOMEM;
    8381                goto finish;
    8482        }
    8583
    86         list_append(&dep->dependencies, &dependant->dependencies);
    87         dep->dependant = dependant;
     84        list_append(&e->edges_out, &input->edges_out);
     85        e->input = input;
    8886
    8987        rc = EOK;
    … …  
    9189finish:
    9290        if (rc != EOK) {
    93                 dep_dependency_destroy(&dep);
     91                edge_destroy(&e);
    9492        }
    9593        return rc;
    9694}
    9795
    98 void dep_resolve_dependency(unit_dependency_t *dep, unit_t *unit)
     96void edge_resolve_output(unit_edge_t *e, unit_t *unit)
    9997{
    100         assert(dep->dependency == NULL);
    101         assert(dep->dependency_name != NULL);
     98        assert(e->output == NULL);
     99        assert(e->output_name != NULL);
    102100
    103         // TODO add to other side dependants list
    104         dep->dependency = unit;
    105         free(dep->dependency_name);
    106         dep->dependency_name = NULL;
     101        // TODO add to other side edges_in list
     102        e->output = unit;
     103        free(e->output_name);
     104        e->output_name = NULL;
    107105}
    108106
    … …  
    112110 * @return        ENOMEM
    113111 */
    114 int dep_add_dependency(unit_t *dependant, unit_t *dependency)
     112int edge_connect(unit_t *input, unit_t *output)
    115113{
    116         unit_dependency_t *dep = dep_dependency_create();
    117         if (dep == NULL) {
     114        unit_edge_t *e = edge_create();
     115        if (e == NULL) {
    118116                return ENOMEM;
    119117        }
    120118
    121         // TODO check existence of the dep
     119        // TODO check existence of the e
    122120        // TODO locking
    123121        // TODO check types and states of connected units
    124         list_append(&dep->dependants, &dependency->dependants);
    125         list_append(&dep->dependencies, &dependant->dependencies);
     122        list_append(&e->edges_in, &output->edges_in);
     123        list_append(&e->edges_out, &input->edges_out);
    126124
    127         dep->dependant = dependant;
    128         dep->dependency = dependency;
     125        e->input = input;
     126        e->output = output;
    129127        return EOK;
    130128}
    131129
    132 /** Remove dependency from dependency graph
     130/** Remove output from output graph
    133131 *
    134  * Given dependency is removed from graph and unallocated.
     132 * Given output is removed from graph and unallocated.
    135133 */
    136 void dep_remove_dependency(unit_dependency_t **dep_ptr)
     134void edge_remove(unit_edge_t **e_ptr)
    137135{
    138136        // TODO here should be some checks, othewise replace this wrapper with
    139137        //      direct destroy
    140         dep_dependency_destroy(dep_ptr);
     138        edge_destroy(e_ptr);
    141139}

  • uspace/srv/sysman/edge.h

    raf92309 r9532981  
    2727 */
    2828
    29 #ifndef SYSMAN_DEP_H
    30 #define SYSMAN_DEP_H
     29#ifndef SYSMAN_EDGE_H
     30#define SYSMAN_EDGE_H
    3131
    3232#include <adt/list.h>
    … …  
    3434#include "unit.h"
    3535
    36 typedef enum {
    37         DEP_EMBRYO,
    38         DEP_VALID
    39 } dependency_state_t;
    40 
    41 /** Dependency edge between unit in dependency graph
     36/** Dependency edge between units in dependency graph
    4237 *
    4338 * @code
    44  * dependant ---> dependency
     39 * input ---> output
    4540 * @endcode
    4641 *
    4742 */
    4843typedef struct {
    49         /** Link to dependants list */
    50         link_t dependants;
    51         /** Link to dependencies list */
    52         link_t dependencies;
     44        /** Link to edges_out list */
     45        link_t edges_in;
     46        /** Link to edges_out list */
     47        link_t edges_out;
    5348
    54         dependency_state_t state;
     49        bool commited;
    5550
    5651        /** Unit that depends on another */
    57         unit_t *dependant;
     52        unit_t *input;
    5853
    5954        /** Unit that is dependency for another */
    60         unit_t *dependency;
     55        unit_t *output;
    6156
    62         /** Name of the dependency unit, for resolved dependencies it's NULL
     57        /** Name of the output unit, for resolved edges it's NULL
    6358         *
    64          * @note Either dependency or dependency_name is set. Never both nor
    65          *       none.
     59         * @note Either output or output_nameis set. Never both nor none.
    6660         */
    67         char *dependency_name;
    68 } unit_dependency_t;
     61        char *output_name;
     62} unit_edge_t;
    6963
    70 extern unit_dependency_t *dep_dependency_create(void);
    71 extern void dep_dependency_destroy(unit_dependency_t **);
     64extern unit_edge_t *edge_create(void);
     65extern void edge_destroy(unit_edge_t **);
    7266
    73 extern int dep_sprout_dependency(unit_t *, const char *);
    74 extern void dep_resolve_dependency(unit_dependency_t *, unit_t *);
     67extern int edge_sprout_out(unit_t *, const char *);
     68extern void edge_resolve_output(unit_edge_t *, unit_t *);
    7569
    76 extern int dep_add_dependency(unit_t *, unit_t *);
    77 extern void dep_remove_dependency(unit_dependency_t **);
     70extern int edge_connect(unit_t *, unit_t *);
     71extern void edge_remove(unit_edge_t **);
    7872
    7973

  • uspace/srv/sysman/job.c

    raf92309 r9532981  
    3333
    3434#include "repo.h"
    35 #include "dep.h"
     35#include "edge.h"
    3636#include "job.h"
    3737#include "log.h"
    … …  
    411411                 * appropriate jobs (currently "After" only).
    412412                 */
    413                 list_foreach(unit->dependencies, dependencies, unit_dependency_t, dep) {
    414                         unit_t *u = dep->dependency;
     413                list_foreach(unit->edges_out, edges_out, unit_edge_t, e) {
     414                        unit_t *u = e->output;
    415415                        job_t *blocking_job;
    416416

  • uspace/srv/sysman/main.c

    raf92309 r9532981  
    4040#include "connection_broker.h"
    4141#include "connection_ctl.h"
    42 #include "dep.h"
     42#include "edge.h"
    4343#include "job.h"
    4444#include "log.h"
    … …  
    137137        repo_add_unit(tgt_init);
    138138
    139         rc = dep_add_dependency(tgt_init, cfg_init);
     139        rc = edge_connect(tgt_init, cfg_init);
    140140        if (rc != EOK) {
    141141                goto rollback;
    142142        }
    143143
    144         rc = dep_add_dependency(cfg_init, mnt_initrd);
     144        rc = edge_connect(cfg_init, mnt_initrd);
    145145        if (rc != EOK) {
    146146                goto rollback;

  • uspace/srv/sysman/repo.c

    raf92309 r9532981  
    3535
    3636#include "repo.h"
    37 #include "dep.h"
     37#include "edge.h"
    3838#include "log.h"
    3939
    … …  
    148148{
    149149        unit_t *unit = hash_table_get_inst(ht_link, unit_t, units_by_name);
    150         // TODO state locking?
    151150        if (unit->state == STATE_EMBRYO) {
    152151                unit->state = STATE_STOPPED;
    153152        }
    154153
    155         list_foreach(unit->dependencies, dependencies, unit_dependency_t, dep) {
    156                 if (dep->state == DEP_EMBRYO) {
    157                         dep->state = DEP_VALID;
    158                 }
     154        list_foreach(unit->edges_out, edges_out, unit_edge_t, e) {
     155                e->commited = true;
    159156        }
    160157        return true;
    … …  
    177174        unit_t *unit = hash_table_get_inst(ht_link, unit_t, units_by_name);
    178175
    179         list_foreach_safe(unit->dependencies, cur_link, next_link) {
    180                 unit_dependency_t *dep =
    181                     list_get_instance(cur_link, unit_dependency_t, dependencies);
    182                 if (dep->state == DEP_EMBRYO) {
    183                         dep_remove_dependency(&dep);
     176        list_foreach_safe(unit->edges_out, cur_link, next_link) {
     177                unit_edge_t *e =
     178                    list_get_instance(cur_link, unit_edge_t, edges_out);
     179                if (!e->commited) {
     180                        edge_remove(&e);
    184181                }
    185182        }
    … …  
    210207        unit_t *unit = hash_table_get_inst(ht_link, unit_t, units_by_name);
    211208
    212         list_foreach(unit->dependencies, dependencies, unit_dependency_t, dep) {
    213                 assert(dep->dependant == unit);
    214                 assert((dep->dependency != NULL) != (dep->dependency_name != NULL));
    215                 if (dep->dependency) {
     209        list_foreach(unit->edges_out, edges_out, unit_edge_t, e) {
     210                assert(e->input == unit);
     211                assert((e->output != NULL) != (e->output_name != NULL));
     212                if (e->output) {
    216213                        continue;
    217214                }
    218215
    219                 unit_t *dependency =
    220                     repo_find_unit_by_name(dep->dependency_name);
    221                 if (dependency == NULL) {
     216                unit_t *output =
     217                    repo_find_unit_by_name(e->output_name);
     218                if (output == NULL) {
    222219                        sysman_log(LVL_ERROR,
    223220                            "Cannot resolve dependency of '%s' to unit '%s'",
    224                             unit_name(unit), dep->dependency_name);
     221                            unit_name(unit), e->output_name);
    225222                        *has_error_ptr = true;
    226223                        // TODO should we just leave the sprout untouched?
    227224                } else {
    228                         dep_resolve_dependency(dep, dependency);
     225                        edge_resolve_output(e, output);
    229226                }
    230227        }
    … …  
    238235 * @return ENOENT  when one or more resolution fails, information is logged
    239236 */
    240 int repo_resolve_dependecies(void)
     237int repo_resolve_references(void)
    241238{
    242239        sysman_log(LVL_DEBUG2, "%s", __func__);

  • uspace/srv/sysman/repo.h

    raf92309 r9532981  
    4747extern void repo_rollback(void);
    4848
    49 extern int repo_resolve_dependecies(void);
     49extern int repo_resolve_references(void);
    5050
    5151extern unit_t *repo_find_unit_by_name(const char *);

  • uspace/srv/sysman/test/job_closure.c

    raf92309 r9532981  
    140140         * u0 -> u1 -> u2 -> u3
    141141         */
    142         mock_add_dependency(u0, u1);
    143         mock_add_dependency(u1, u2);
    144         mock_add_dependency(u2, u3);
     142        mock_add_edge(u0, u1);
     143        mock_add_edge(u1, u2);
     144        mock_add_edge(u2, u3);
    145145
    146146        /* Intentionally omit u0 */
    … …  
    172172         *          \-> u3
    173173         */
    174         mock_add_dependency(u0, u1);
    175         mock_add_dependency(u1, u2);
    176         mock_add_dependency(u1, u3);
     174        mock_add_edge(u0, u1);
     175        mock_add_edge(u1, u2);
     176        mock_add_edge(u1, u3);
    177177
    178178        job_t *main_job = job_create(u1, STATE_STARTED);
    … …  
    204204         *          \-> u3
    205205         */
    206         mock_add_dependency(u0, u1);
    207         mock_add_dependency(u1, u2);
    208         mock_add_dependency(u1, u3);
    209         mock_add_dependency(u2, u3);
     206        mock_add_edge(u0, u1);
     207        mock_add_edge(u1, u2);
     208        mock_add_edge(u1, u3);
     209        mock_add_edge(u2, u3);
    210210
    211211        job_t *main_job = job_create(u1, STATE_STARTED);

  • uspace/srv/sysman/test/job_queue.c

    raf92309 r9532981  
    131131
    132132        /* All services require root fs */
    133         mock_add_dependency(s0, m0);
    134         mock_add_dependency(s1, m0);
     133        mock_add_edge(s0, m0);
     134        mock_add_edge(s1, m0);
    135135       
    136136        /* S1 requires another mount and S0 */
    137         mock_add_dependency(s1, s0);
     137        mock_add_edge(s1, s0);
    138138
    139139        /* Enforce initial state */

  • uspace/srv/sysman/test/mock_unit.c

    raf92309 r9532981  
    2929#include <assert.h>
    3030
    31 #include "../dep.h"
     31#include "../edge.h"
    3232
    3333#include "mock_unit.h"
    … …  
    7676}
    7777
    78 void mock_add_dependency(unit_t *dependant, unit_t *dependency)
     78void mock_add_edge(unit_t *input, unit_t *output)
    7979{
    80         int rc = dep_add_dependency(dependant, dependency);
     80        int rc = edge_connect(input, output);
    8181        assert(rc == EOK);
    8282
    83         link_t *link = list_last(&dependant->dependencies);
    84         unit_dependency_t *dep =
    85             list_get_instance(link, unit_dependency_t, dependencies);
    86         dep->state = DEP_VALID;
     83        link_t *link = list_last(&input->edges_out);
     84        unit_edge_t *e =
     85            list_get_instance(link, unit_edge_t, edges_out);
     86        e->commited = true;
    8787}
    8888

  • uspace/srv/sysman/test/mock_unit.h

    raf92309 r9532981  
    4646
    4747extern void mock_set_units_state(unit_state_t state);
    48 extern void mock_add_dependency(unit_t *dependant, unit_t *dependency);
     48extern void mock_add_edge(unit_t *, unit_t *);
    4949
    5050extern int mock_unit_vmt_start_sync(unit_t *);

  • uspace/srv/sysman/unit.c

    raf92309 r9532981  
    3939#include <sysman/unit.h>
    4040
    41 #include "dep.h"
     41#include "edge.h"
    4242#include "log.h"
    4343#include "sysman.h"
    … …  
    7272        link_initialize(&unit->units);
    7373        link_initialize(&unit->bfs_link);
    74         list_initialize(&unit->dependants);
    75         list_initialize(&unit->dependencies);
     74        list_initialize(&unit->edges_in);
     75        list_initialize(&unit->edges_out);
    7676
    7777        UNIT_VMT(unit)->init(unit);
    … …  
    159159}
    160160
     161// TODO move to libsysman
    161162unit_type_t unit_type_name_to_type(const char *type_name)
    162163{
    … …  
    199200
    200201        while ((cur_tok = str_tok(to_split, " ", &to_split))) {
    201                 if (dep_sprout_dependency(unit, cur_tok) != EOK) {
     202                if (edge_sprout_out(unit, cur_tok) != EOK) {
    202203                        result = false;
    203204                        goto finish;

  • uspace/srv/sysman/unit.h

    raf92309 r9532981  
    7474        unit_state_t state;
    7575
    76         list_t dependencies;
    77         list_t dependants;
     76        list_t edges_in;
     77        list_t edges_out;
    7878} unit_t;
    7979

  • uspace/srv/sysman/units/unit_cfg.c

    raf92309 r9532981  
    182182        closedir(dir);
    183183
    184         int rc = repo_resolve_dependecies();
     184        int rc = repo_resolve_references();
    185185        if (rc != EOK) {
    186186                repo_rollback();
Note: See TracChangeset for help on using the changeset viewer.