initial work of api server

src/controller/apiserver.c

@@ -0,0 +1,140 @@
+#include <errno.h>
+#include <stdlib.h>
+
+#include "cluster.h"
+#include "controller.capnp.h"
+#include "request.h"
+#include "xce/types.h"
+
+static int xce_apiserver_push_configs(cluster_t* c, endpoint_t* ep)
+{
+    xce_configdata_t configdata;
+    int              rc = 0;
+
+    memset(&configdata, 0x0, sizeof(configdata));
+    configdata.data.clusterconfig = c->myconf->cluster_config;
+    configdata.data_which         = ConfigData_data_clusterconfig;
+
+    rc = xce_pushconfig_req(ep, c->myhost, &configdata);
+
+    return rc;
+}
+
+static int xce_apiserver_push_workers(cluster_t* c, endpoint_t* ep)
+{
+    xce_data_t         data;
+    xce_workers_data_t workers
+        = { .n_total = 0, .pos = 0, .count = 0, .workers = NULL };
+    int i, rc = 0;
+
+    memset(&data, 0x0, sizeof(data));
+
+    data.table        = Data_data_schedworkers;
+    data.data.workers = &workers;
+
+    collect_workers(c, (collect_check_fn_t)check_worker_, &(workers.n_total),
+                    &(workers.workers));
+    workers.count = workers.n_total;
+
+    rc = xce_push_data_req(ep, c->myhost, &data, check_controller, c, 100);
+
+    /* free up collected resource value which used
+       passed to scheduler
+    */
+    for (i = 0; i < workers.n_total; i++) {
+        xce_worker_t* w = workers.workers[i];
+
+        free_resval_with_idx_list(&(w->resvals_to_sched), w->nresvals_to_sched);
+    }
+
+    deref_objs(workers.n_total, (void**)workers.workers);
+    FREEUP(workers.workers);
+
+    return 0;
+}
+
+static int check_job_(xce_job_t* j)
+{
+    if (j == NULL) {
+        return 0;
+    }
+
+    return 1;
+}
+
+static int xce_apiserver_push_jobs(cluster_t* c, endpoint_t* ep)
+{
+    xce_data_t      data;
+    xce_jobs_data_t jobs = { .n_total = 0, .pos = 0, .count = 0, .jobs = NULL };
+    int             rc   = 0;
+
+    memset(&data, 0x0, sizeof(data));
+
+    data.table     = Data_data_schedjobs;
+    data.data.jobs = &jobs;
+
+    collect_jobs(c, (collect_check_fn_t)check_job_, &(jobs.n_total),
+                 &(jobs.jobs));
+    jobs.count = jobs.n_total;
+
+    rc = xce_push_data_req(c->sched.ep, c->myhost, &data, check_controller, c,
+                           100);
+    deref_objs(jobs.n_total, (void**)jobs.jobs);
+    FREEUP(jobs.jobs);
+
+    return 0;
+}
+
+static int apiserver_job_hook_fun(int type, int situation, int detail,
+                                  void* data, va_list ap)
+{
+    return 0;
+}
+
+static int apiserver_worker_hook_fun(int type, int situation, int detail,
+                                     void* data, va_list ap)
+{
+    return 0;
+}
+
+static int apiserver_resource_hook_fun(int type, int situation, int detail,
+                                       void* data, va_list ap)
+{
+    return 0;
+}
+
+static int apiserver_queue_hook_fun(int type, int situation, int detail,
+                                    void* data, va_list ap)
+{
+    return 0;
+}
+
+int on_apiserver_join(cluster_t* c, endpoint_t* ep)
+{
+    /* FIXME: use lock to protect this later */
+    static int hook_installed = 0;
+
+    xce_apiserver_push_configs(c, ep);
+    xce_apiserver_push_workers(c, ep);
+    xce_apiserver_push_jobs(c, ep);
+
+    if (!hook_installed) {
+        hook_installed = 1;
+
+        xce_add_hook(&(c->hooksys), XCE_CONTROLLER_HOOK_JOB,
+                     (hook_fn_t)apiserver_job_hook_fun, NULL);
+        xce_add_hook(&(c->hooksys), XCE_CONTROLLER_HOOK_WORKER,
+                     (hook_fn_t)apiserver_worker_hook_fun, NULL);
+        xce_add_hook(&(c->hooksys), XCE_CONTROLLER_HOOK_RESOURCE,
+                     (hook_fn_t)apiserver_resource_hook_fun, NULL);
+        xce_add_hook(&(c->hooksys), XCE_CONTROLLER_HOOK_QUEUE,
+                     (hook_fn_t)apiserver_queue_hook_fun, NULL);
+    }
+    return 0;
+}
+
+int handle_apiserver_leave(cluster_t* c, endpoint_t* ep)
+{
+    /* FIXME */
+    return 0;
+}

src/controller/cluster.c

@@ -67,6 +67,9 @@ static void handle_endpoint_error(endpoint_t* ep)
         case HostRole_client:
             handle_client_leave(c);
             break;
+        case HostRole_apiserver:
+            handle_apiserver_leave(c, ep);
+            break;
         default:
             ERROR("unknown role %d for endpoint %p", priv->role, ep);
             break;

src/controller/include/cluster.h

@@ -56,6 +56,7 @@ extern queue_t* qmgr_lockq(qmgr_t*, char*, int);
 extern int xce_update_data(endpoint_t*, cluster_t*, int, int, int*, int,
                            xce_kv_t*);
 extern int on_scheduler_join(cluster_t*);
+extern int on_apiserver_join(cluster_t*, endpoint_t*);
 
 extern int    xce_push_reslist(endpoint_t*, cluster_t*, int, xce_resource_t**);
 extern int    xce_push_confvars(endpoint_t*, cluster_t*, int, xce_config_t**);
@@ -135,5 +136,7 @@ extern int release_resource_from_worker(char*, cluster_t*);
 extern int collect_resval_with_idx(zarray_t*, int*, xce_val_with_idx_t***);
 extern int do_set_preason(cluster_t*, endpoint_t*, xce_request_t*);
 extern int do_clr_preason(cluster_t*, endpoint_t*, xce_request_t*);
+extern int handle_apiserver_leave(cluster_t*, endpoint_t*);
+
 
 #endif

src/controller/join.c

@@ -117,6 +117,24 @@ static int handle_controller_join(cluster_t* c, endpoint_t* ep,
     return rc;
 }
 
+static int handle_apiserver_join(cluster_t *c, endpoint_t *ep, xce_request_t *request) {
+    xce_reply_t reply;
+    ep_private_t *priv = (ep_private_t *)ep->data;
+    int rc = 0;
+
+    TRACE("%s api server join, ep %p", __func__, ep);
+
+    init_reply_by_req(&reply, request);
+
+    rc = on_apiserver_join(c, ep);
+
+    reply.status = rc;
+    reply.data_which = RequestReply_data_nodata;
+    xce_reply(ep, c->myhost, &reply);
+
+    return 0;
+}
+
 static int handle_join_(cluster_t* c, endpoint_t* ep, xce_request_t* request)
 {
     ep_private_t*   priv;
@@ -158,6 +176,9 @@ static int handle_join_(cluster_t* c, endpoint_t* ep, xce_request_t* request)
     case HostRole_controller:
         rc = handle_controller_join(c, ep, request);
         break;
+    case HostRole_apiserver:
+        rc = handle_apiserver_join(c, ep, request);
+        break;
     default:
         rc = -E_XCE_BAD_ROLE;
         ERROR("unknown role %d from host %s", role, from->name);

src/controller/meson.build

@@ -15,7 +15,8 @@ controller_src = [
   'task.c',
   'worker.c',
   'xceobjs.c',
-  'myconf.c'
+  'apiserver.c',
+  'myconf.c',
 ]
 
 incdir = include_directories('.', '../include', '../lib',