ipcpd: normal: Refactor application entities and add neighbors struct

This refactors the different Application Entities of the normal
IPCP. They all listen to and use the connection manager to establish
new application connections.

This commit also adds a neighbors struct to the normal IPCP. It
contains neighbor structs that contain application
connection. Notifiers can be registered in case a neighbor changes
(added, removed, QoS changed).

The flow manager has an instance of this neighbors struct and listens
to these events to update its flow set. The routing component also
listens to these events so that it can update the FSDB if needed. The
flow manager now also creates the PFF instances and the routing
instances per QoS cube.

The RIB manager also uses this an instance of the neighbors struct and
listens to neighbor events as well.

1 files changed, 73 insertions, 116 deletions

diff --git a/src/ipcpd/normal/pol/complete.c b/src/ipcpd/normal/pol/complete.c
index daf8c9bf..f84c3a23 100644
--- a/src/ipcpd/normal/pol/complete.c
+++ b/src/ipcpd/normal/pol/complete.c
@@ -1,7 +1,7 @@
 /*
  * 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>
@@ -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;
-        uint64_t         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,10 +75,10 @@ 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;
@@ -67,8 +86,23 @@ static void * allocator(void * o)
         /* 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,118 +112,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);
-        }
+        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 conn_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);
-                /* FIXME: figure out union type and check name or address */
-                if (e->neighbor == info->addr) {
-                        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 = info->addr;
-
-        list_add(&n->next, &complete->neighbors);
-
-        pthread_mutex_unlock(&complete->neighbors_lock);
-
-        return 0;
-}