Merge branch 'be' of bitbucket.org:ouroboros-rina/ouroboros into be

1 files changed, 78 insertions, 123 deletions

diff --git a/src/ipcpd/normal/pol/complete.c b/src/ipcpd/normal/pol/complete.c
index 5faa1ae8..1f3f6031 100644
--- a/src/ipcpd/normal/pol/complete.c
+++ b/src/ipcpd/normal/pol/complete.c
@@ -1,10 +1,10 @@
 /*
  * Ouroboros - Copyright (C) 2016 - 2017
  *
- * Graph adjacency manager for IPC Process components
+ * Sets up a complete graph
  *
- *    Dimitri Staessens <dimitri.staessens@intec.ugent.be>
- *    Sander Vrijders   <sander.vrijders@intec.ugent.be>
+ *    Dimitri Staessens <dimitri.staessens@ugent.be>
+ *    Sander Vrijders   <sander.vrijders@ugent.be>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -20,35 +20,54 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#define OUROBOROS_PREFIX "complete-graph-adjacency-manager"
+#define OUROBOROS_PREFIX "complete"
 
 #include <ouroboros/config.h>
-#include <ouroboros/logs.h>
-#include <ouroboros/list.h>
-#include <ouroboros/qos.h>
+#include <ouroboros/shared.h>
 #include <ouroboros/rib.h>
+#include <ouroboros/dev.h>
+#include <ouroboros/logs.h>
+#include <ouroboros/errno.h>
+#include <ouroboros/cacep.h>
 
-#include "ipcp.h"
-#include "gam.h"
+#include "neighbors.h"
+#include "frct.h"
 #include "ribconfig.h"
+#include "ipcp.h"
+#include "ae.h"
 
 #include <string.h>
 #include <stdlib.h>
 #include <assert.h>
 
-struct neighbor {
-        struct list_head next;
-        char *           neighbor;
+struct complete {
+        struct nbs * nbs;
+        struct ae *  ae;
+        pthread_t    allocator;
+        pthread_t    listener;
 };
 
-struct complete {
-        struct list_head neighbors;
-        pthread_mutex_t  neighbors_lock;
+static void * listener(void * o)
+{
+        struct complete * complete;
+        struct conn       conn;
 
-        pthread_t        allocator;
+        complete = (struct complete *) o;
 
-        struct gam *     gam;
-};
+        while (true) {
+                if (connmgr_wait(complete->ae, &conn)) {
+                        log_err("Error while getting next connection.");
+                        continue;
+                }
+
+                if (nbs_add(complete->nbs, conn)) {
+                        log_err("Failed to add neighbor.");
+                        continue;
+                }
+        }
+
+        return (void *) 0;
+}
 
 static void * allocator(void * o)
 {
@@ -56,19 +75,37 @@ static void * allocator(void * o)
         ssize_t           len;
         char **           children;
         ssize_t           i;
-        struct complete * complete = (struct complete *) o;
+        struct complete * complete;
+        struct conn       conn;
 
-        assert(complete);
-        assert(complete->gam);
+        complete = (struct complete *) o;
 
         qs.delay = 0;
         qs.jitter = 0;
 
+        /* FIXME: implement QoS specs */
+        qs.cube = QOS_CUBE_BE;
+
         /* FIXME: subscribe to members to keep the graph complete. */
         len = rib_children("/" MEMBERS_NAME, &children);
         for (i = 0; i < len; ++i) {
-                if (strcmp(children[i], ipcpi.name) < 0)
-                        gam_flow_alloc(complete->gam, children[i], qs);
+                if (strcmp(children[i], ipcpi.name) < 0) {
+                        if (connmgr_alloc(complete->ae,
+                                          children[i],
+                                          &qs,
+                                          &conn)) {
+                                log_warn("Failed to get a conn to neighbor.");
+                                free(children[i]);
+                                continue;
+                        }
+
+                        if (nbs_add(complete->nbs, conn)) {
+                                log_err("Failed to add neighbor.");
+                                free(children[i]);
+                                continue;
+                        }
+
+                }
                 free(children[i]);
         }
 
@@ -78,123 +115,41 @@ static void * allocator(void * o)
         return (void *) 0;
 }
 
-void * complete_create(struct gam * gam)
+void * complete_create(struct nbs * nbs,
+                       struct ae *  ae)
 {
         struct complete * complete;
 
-        assert(gam);
-
         complete = malloc(sizeof(*complete));
         if (complete == NULL)
                 return NULL;
 
-        list_head_init(&complete->neighbors);
-        complete->gam = gam;
-
-        if (pthread_mutex_init(&complete->neighbors_lock, NULL)) {
-                free(complete);
-                return NULL;
-        }
-
-        return (void *) complete;
-}
-
-int complete_start(void * o)
-{
-        struct complete * complete = (struct complete *) o;
-
-        assert(complete);
-        assert(complete->gam);
+        complete->nbs = nbs;
+        complete->ae = ae;
 
         if (pthread_create(&complete->allocator, NULL,
-                           allocator, (void *) complete)) {
-                pthread_mutex_destroy(&complete->neighbors_lock);
-                free(complete);
-                return -1;
-        }
+                           allocator, (void *) complete))
+                return NULL;
 
-        /* FIXME: Handle flooding of the flow allocator before detaching.*/
-        pthread_join(complete->allocator, NULL);
+        if (pthread_create(&complete->listener, NULL,
+                           listener, (void *) complete))
+                return NULL;
 
-        return 0;
+        return complete;
 }
 
-int complete_stop(void * o)
+void complete_destroy(void * ops_o)
 {
-        (void) o;
+        struct complete * complete;
 
-        return 0;
-}
+        assert(ops_o);
 
-void complete_destroy(void * o)
-{
-        struct list_head * p = NULL;
-        struct list_head * n = NULL;
-        struct complete * complete = (struct complete *) o;
-
-        list_for_each_safe(p, n, &complete->neighbors) {
-                struct neighbor * e = list_entry(p, struct neighbor, next);
-                list_del(&e->next);
-                free(e->neighbor);
-                free(e);
-        }
+        complete = (struct complete *) ops_o;
 
-        pthread_mutex_destroy(&complete->neighbors_lock);
+        pthread_cancel(complete->allocator);
+        pthread_cancel(complete->listener);
+        pthread_join(complete->allocator, NULL);
+        pthread_join(complete->listener, NULL);
 
         free(complete);
 }
-
-int complete_accept_new_flow(void * o)
-{
-        (void) o;
-
-        return 0;
-}
-
-int complete_accept_flow(void *                    o,
-                         qosspec_t                 qs,
-                         const struct cacep_info * info)
-{
-        struct list_head * pos = NULL;
-        struct neighbor * n;
-        struct complete * complete = (struct complete *) o;
-
-        (void) qs;
-
-        assert(complete);
-
-        pthread_mutex_lock(&complete->neighbors_lock);
-
-        list_for_each(pos, &complete->neighbors) {
-                struct neighbor * e = list_entry(pos, struct neighbor, next);
-                if (strcmp(e->neighbor, info->name) == 0) {
-                        pthread_mutex_unlock(&complete->neighbors_lock);
-                        return -1;
-                }
-
-                assert(complete);
-                assert(&complete->neighbors_lock);
-                assert(pos->nxt);
-        }
-
-        n = malloc(sizeof(*n));
-        if (n == NULL) {
-                pthread_mutex_unlock(&complete->neighbors_lock);
-                return -1;
-        }
-
-        list_head_init(&n->next);
-
-        n->neighbor = strdup(info->name);
-        if (n->neighbor == NULL) {
-                pthread_mutex_unlock(&complete->neighbors_lock);
-                free(n);
-                return -1;
-        }
-
-        list_add(&n->next, &complete->neighbors);
-
-        pthread_mutex_unlock(&complete->neighbors_lock);
-
-        return 0;
-}