agoo 2.9.0 → 2.10.0

data/ext/agoo/pub.c

@@ -75,8 +75,6 @@ agoo_pub_publish(const char *subject, int slen, const char *message, size_t mlen
 
 agooPub
 agoo_pub_write(agooUpgraded up, const char *message, size_t mlen, bool bin) {
-    // Allocate an extra 16 bytes so the message can be expanded in place if a
-    // WebSocket write.
     agooPub	p = (agooPub)AGOO_MALLOC(sizeof(struct _agooPub));
 
     if (NULL != p) {
@@ -130,4 +128,3 @@ agoo_pub_destroy(agooPub pub) {
     }
     AGOO_FREE(pub);
 }
-

data/ext/agoo/res.c

@@ -46,6 +46,7 @@ agoo_res_destroy(agooRes res) {
 	    agoo_text_release(res->message);
 	}
 	res->next = NULL;
+	res->message = NULL;
 	pthread_mutex_lock(&res->con->loop->lock);
 	if (NULL == res->con->loop->res_tail) {
 	    res->con->loop->res_head = res;
@@ -58,7 +59,7 @@ agoo_res_destroy(agooRes res) {
 }
 
 void
-agoo_res_message_push(agooRes res, agooText t, bool final) {
+agoo_res_message_push(agooRes res, agooText t) {
     if (NULL != t) {
 	agoo_text_ref(t);
     }
@@ -73,7 +74,7 @@ agoo_res_message_push(agooRes res, agooText t, bool final) {
 	    }
 	    end->next = t;
 	}
-	res->final = final;
+	res->final = true;
     }
     pthread_mutex_unlock(&res->lock);
 }
@@ -91,7 +92,21 @@ agoo_res_add_early(agooRes res, agooEarly early) {
 	t = agoo_text_append(t, "\r\n", 2);
     }
     t = agoo_text_append(t, "\r\n", 2);
-    agoo_res_message_push(res, t, false);
+
+    pthread_mutex_lock(&res->lock);
+    if (!res->final) {
+	if (NULL == res->message) {
+	    res->message = t;
+	} else {
+	    agooText	end = res->message;
+
+	    for (; NULL != end->next; end = end->next) {
+	    }
+	    end->next = t;
+	}
+	res->final = false;
+    }
+    pthread_mutex_unlock(&res->lock);
 }
 
 agooText
@@ -113,8 +128,7 @@ agoo_res_message_next(agooRes res) {
     if (NULL != res->message) {
 	agooText	t2 = res->message;
 
-	res->message = res->message->next;
-	// TBD make sure it is not release by the called, change code if it is
+	res->message = t2->next;
 	agoo_text_release(t2);
     }
     t = res->message;

data/ext/agoo/res.h

@@ -28,7 +28,7 @@ typedef struct _agooRes {
 extern agooRes		agoo_res_create(struct _agooCon *con);
 extern void		agoo_res_destroy(agooRes res);
 
-extern void		agoo_res_message_push(agooRes res, agooText t, bool final);
+extern void		agoo_res_message_push(agooRes res, agooText t);
 extern void		agoo_res_add_early(agooRes res, agooEarly early);
 extern agooText		agoo_res_message_peek(agooRes res);
 extern agooText		agoo_res_message_next(agooRes res);

data/ext/agoo/rgraphql.c

@@ -12,7 +12,9 @@
 #include "gqlintro.h"
 #include "gqlvalue.h"
 #include "graphql.h"
+#include "pub.h"
 #include "sdl.h"
+#include "server.h"
 
 typedef struct _eval {
     gqlDoc	doc;
@@ -423,6 +425,15 @@ resolve(agooErr err, gqlDoc doc, gqlRef target, gqlField field, gqlSel sel, gqlV
 	}
 	child = rb_funcall(obj, rb_intern(sel->name), 1, rargs);
     }
+    if (GQL_SUBSCRIPTION == doc->op->kind && RUBY_T_STRING == rb_type(child)) {
+	gqlValue	c;
+
+	if (NULL == (c = gql_string_create(err, rb_string_value_ptr(&child), RSTRING_LEN(child))) ||
+	    AGOO_ERR_OK != gql_object_set(err, result, "subject", c)) {
+	    return err->code;
+	}
+	return AGOO_ERR_OK;
+    }
     if (NULL != sel->alias) {
 	key = sel->alias;
     }
@@ -750,6 +761,30 @@ graphql_sdl_dump(VALUE self, VALUE options) {
     return dump;
 }
 
+/* Document-method: publish
+ *
+ * call-seq: publish(subject, event)
+ *
+ * Publish an event on the given subject. A subject must be a String while the
+ * event must be one of the objects represented by the the GraphQL
+ * schema. Generally the subjects are selected to identify which objects are
+ * being published and should match the value returned by the subscription
+ * methods.
+ */
+static VALUE
+graphql_publish(VALUE self, VALUE subject, VALUE event) {
+    const char		*subj;
+    struct _agooErr	err = AGOO_ERR_INIT;
+
+    rb_check_type(subject, T_STRING);
+    subj = StringValuePtr(subject);
+
+    if (AGOO_ERR_OK != agoo_server_gpublish(&err, subj, (gqlRef)event)) {
+	rb_raise(rb_eStandardError, "%s", err.msg);
+    }
+    return Qnil;
+}
+
 /* Document-class: Agoo::Graphql
  *
  * The Agoo::GraphQL class provides support for the GraphQL API as defined in
@@ -772,4 +807,6 @@ graphql_init(VALUE mod) {
     rb_define_module_function(graphql_class, "load_file", graphql_load_file, 1);
 
     rb_define_module_function(graphql_class, "sdl_dump", graphql_sdl_dump, 1);
+
+    rb_define_module_function(graphql_class, "publish", graphql_publish, 2);
 }

data/ext/agoo/rserver.c

@@ -312,7 +312,7 @@ rescue_error(VALUE x) {
 	message = agoo_text_create(buf, cnt);
 
 	req->res->close = true;
-	agoo_res_message_push(req->res, message, true);
+	agoo_res_message_push(req->res, message);
 	agoo_queue_wakeup(&agoo_server.con_queue);
     } else {
 /*
@@ -340,7 +340,7 @@ handle_base_inner(void *x) {
 	rb_funcall((VALUE)req->hook->handler, on_request_id, 2, rr, rres);
     }
     DATA_PTR(rr) = NULL;
-    agoo_res_message_push(req->res, response_text(rres), true);
+    agoo_res_message_push(req->res, response_text(rres));
     agoo_queue_wakeup(&agoo_server.con_queue);
 
     return Qfalse;
@@ -367,10 +367,25 @@ header_cb(VALUE key, VALUE value, agooText *tp) {
 	}
     }
     if (0 != strcasecmp("Content-Length", ks)) {
-	*tp = agoo_text_append(*tp, ks, klen);
-	*tp = agoo_text_append(*tp, ": ", 2);
-	*tp = agoo_text_append(*tp, vs, vlen);
-	*tp = agoo_text_append(*tp, "\r\n", 2);
+	char	*end = index(vs, '\n');
+
+	do {
+	    end = index(vs, '\n');
+	    *tp = agoo_text_append(*tp, ks, klen);
+	    *tp = agoo_text_append(*tp, ": ", 2);
+	    if (NULL == end) {
+		if (0 < vlen) {
+		    *tp = agoo_text_append(*tp, vs, vlen);
+		}
+	    } else {
+		if (vs < end) {
+		    *tp = agoo_text_append(*tp, vs, end - vs);
+		}
+		vlen -= end - vs + 1;
+		vs = end + 1;
+	    }
+	    *tp = agoo_text_append(*tp, "\r\n", 2);
+	} while (NULL != end && 0 < vlen);
     }
     return ST_CONTINUE;
 }
@@ -515,7 +530,7 @@ handle_rack_inner(void *x) {
 	    req->hook = agoo_hook_create(AGOO_NONE, NULL, (void*)handler, PUSH_HOOK, &agoo_server.eval_queue);
 	    rupgraded_create(req->res->con, handler, request_env(req, Qnil));
 	    t = agoo_sse_upgrade(req, t);
-	    agoo_res_message_push(req->res, t, true);
+	    agoo_res_message_push(req->res, t);
 	    agoo_queue_wakeup(&agoo_server.con_queue);
 	    return Qfalse;
 	default:
@@ -546,7 +561,7 @@ handle_rack_inner(void *x) {
 	    rb_iterate(rb_each, bv, body_append_cb, (VALUE)&t);
 	}
     }
-    agoo_res_message_push(req->res, t, true);
+    agoo_res_message_push(req->res, t);
     agoo_queue_wakeup(&agoo_server.con_queue);
 
     return Qfalse;
@@ -572,7 +587,7 @@ handle_wab_inner(void *x) {
 	rb_funcall((VALUE)req->hook->handler, on_request_id, 2, rr, rres);
     }
     DATA_PTR(rr) = NULL;
-    agoo_res_message_push(req->res, response_text(rres), true);
+    agoo_res_message_push(req->res, response_text(rres));
     agoo_queue_wakeup(&agoo_server.con_queue);
 
     return Qfalse;
@@ -686,7 +701,7 @@ handle_protected(agooReq req, bool gvi) {
 	agooText	message = agoo_text_create(buf, cnt);
 
 	req->res->close = true;
-	agoo_res_message_push(req->res, message, true);
+	agoo_res_message_push(req->res, message);
 	agoo_queue_wakeup(&agoo_server.con_queue);
 	break;
     }
@@ -1098,7 +1113,7 @@ domain(VALUE self, VALUE host, VALUE path) {
 	volatile VALUE	v = rb_funcall(host, rb_intern("inspect"), 0);
 	char		rx[1024];
 
-	if (sizeof(rx) <= RSTRING_LEN(v)) {
+	if (sizeof(rx) <= (size_t)RSTRING_LEN(v)) {
 	    rb_raise(rb_eArgError, "host Regex limited to %ld characters", sizeof(rx));
 	}
 	strcpy(rx, rb_string_value_ptr((VALUE*)&v) + 1);

data/ext/agoo/sdl.c

@@ -1318,25 +1318,25 @@ make_sel(agooErr err, agooDoc doc, gqlDoc gdoc, gqlOp op, gqlSel *parentp) {
 
 
 static int
-make_op(agooErr err, agooDoc doc, gqlDoc gdoc) {
+make_op(agooErr err, agooDoc doc, gqlDoc gdoc, gqlOpKind kind) {
     char	name[256];
     const char	*start;
-    gqlOpKind	kind;
     gqlOp	op;
     size_t	nlen;
 
     agoo_doc_skip_white(doc);
     start = doc->cur;
     agoo_doc_read_token(doc);
-    if (doc->cur == start ||
-	(5 == (doc->cur - start) && 0 == strncmp(query_str, start, sizeof(query_str) - 1))) {
-	kind = GQL_QUERY;
-    } else if (8 == (doc->cur - start) && 0 == strncmp(mutation_str, start, sizeof(mutation_str) - 1)) {
-	kind = GQL_MUTATION;
-    } else if (12 == (doc->cur - start) && 0 == strncmp(subscription_str, start, sizeof(subscription_str) - 1)) {
-	kind = GQL_SUBSCRIPTION;
-    } else {
-	return agoo_doc_err(doc, err, "Invalid operation type");
+    if ( start < doc->cur) {
+	if (5 == (doc->cur - start) && 0 == strncmp(query_str, start, sizeof(query_str) - 1)) {
+	    kind = GQL_QUERY;
+	} else if (8 == (doc->cur - start) && 0 == strncmp(mutation_str, start, sizeof(mutation_str) - 1)) {
+	    kind = GQL_MUTATION;
+	} else if (12 == (doc->cur - start) && 0 == strncmp(subscription_str, start, sizeof(subscription_str) - 1)) {
+	    kind = GQL_SUBSCRIPTION;
+	} else {
+	    return agoo_doc_err(doc, err, "Invalid operation type");
+	}
     }
     agoo_doc_skip_white(doc);
     start = doc->cur;
@@ -1597,7 +1597,7 @@ validate_doc(agooErr err, gqlDoc doc) {
 }
 
 gqlDoc
-sdl_parse_doc(agooErr err, const char *str, int len, gqlVar vars) {
+sdl_parse_doc(agooErr err, const char *str, int len, gqlVar vars, gqlOpKind default_kind) {
     struct _agooDoc	doc;
     gqlDoc		gdoc = NULL;
 
@@ -1616,7 +1616,7 @@ sdl_parse_doc(agooErr err, const char *str, int len, gqlVar vars) {
 	case 'q':
 	case 'm':
 	case 's':
-	    if (AGOO_ERR_OK != make_op(err, &doc, gdoc)) {
+	    if (AGOO_ERR_OK != make_op(err, &doc, gdoc, default_kind)) {
 		gql_doc_destroy(gdoc);
 		return NULL;
 	    }

data/ext/agoo/sdl.h

@@ -4,6 +4,7 @@
 #define AGOO_SDL_H
 
 #include "err.h"
+#include "graphql.h"
 
 struct _gqlType;
 struct _gqlVar;
@@ -12,7 +13,7 @@ struct _gqlValue;
 extern int		sdl_parse(agooErr err, const char *str, int len);
 
 // Parse a execution definition.
-extern struct _gqlDoc*	sdl_parse_doc(agooErr err, const char *str, int len, struct _gqlVar *vars);
+extern struct _gqlDoc*	sdl_parse_doc(agooErr err, const char *str, int len, struct _gqlVar *vars, gqlOpKind default_kind);
 
 extern gqlVar	gql_op_var_create(agooErr err, const char *name, struct _gqlType *type, struct _gqlValue *value);
 

data/ext/agoo/server.c

@@ -12,11 +12,16 @@
 #include "con.h"
 #include "domain.h"
 #include "dtime.h"
+#include "gqlsub.h"
+#include "gqlvalue.h"
+#include "graphql.h"
 #include "http.h"
 #include "hook.h"
 #include "log.h"
 #include "page.h"
 #include "pub.h"
+#include "res.h"
+#include "text.h"
 #include "upgraded.h"
 
 #include "server.h"
@@ -34,6 +39,7 @@ agoo_server_setup(agooErr err) {
     memset(&agoo_server, 0, sizeof(struct _agooServer));
     pthread_mutex_init(&agoo_server.up_lock, 0);
     agoo_server.up_list = NULL;
+    agoo_server.gsub_list = NULL;
     agoo_server.max_push_pending = 32;
 
     if (AGOO_ERR_OK != agoo_pages_init(err) ||
@@ -336,3 +342,112 @@ agoo_server_publish(struct _agooPub *pub) {
 	}
     }
 }
+
+void
+agoo_server_add_gsub(gqlSub sub) {
+    pthread_mutex_lock(&agoo_server.up_lock);
+    sub->next = agoo_server.gsub_list;
+    agoo_server.gsub_list = sub;
+    pthread_mutex_unlock(&agoo_server.up_lock);
+}
+
+void
+agoo_server_del_gsub(gqlSub sub) {
+    gqlSub	s;
+    gqlSub	prev = NULL;
+
+    pthread_mutex_lock(&agoo_server.up_lock);
+    for (s = agoo_server.gsub_list; NULL != s; s = s->next) {
+	if (s == sub) {
+	    if (NULL == prev) {
+		agoo_server.gsub_list = s->next;
+	    } else {
+		prev->next = s->next;
+	    }
+	}
+	prev = s;
+    }
+    pthread_mutex_unlock(&agoo_server.up_lock);
+}
+
+static bool
+subject_check(const char *pattern, const char *subject) {
+    for (; '\0' != *pattern && '\0' != *subject; subject++) {
+	if (*subject == *pattern) {
+	    pattern++;
+	} else if ('*' == *pattern) {
+	    for (; '\0' != *subject && '.' != *subject; subject++) {
+	    }
+	    if ('\0' == *subject) {
+		return true;
+	    }
+	    pattern++;
+	} else if ('>' == *pattern) {
+	    return true;
+	} else {
+	    break;
+	}
+    }
+    return '\0' == *pattern && '\0' == *subject;
+}
+
+static agooText
+gpub_eval(agooErr err, gqlDoc query, gqlRef event) {
+    agooText	t = NULL;
+    gqlSel	sel;
+    gqlValue	result;
+
+    if (NULL == query->ops || NULL == query->ops->sels) {
+	agoo_err_set(err, AGOO_ERR_TYPE, "subscription not valid");
+	return NULL;
+    }
+    sel = query->ops->sels;
+    if (NULL != (result = gql_object_create(err))) {
+	struct _gqlField	field;
+
+	memset(&field, 0, sizeof(field));
+	field.type = sel->type;
+	if (AGOO_ERR_OK != gql_eval_sels(err, query, event, &field, sel->sels, result, 0)) {
+	    gql_value_destroy(result);
+	    return NULL;
+	}
+	if (NULL == (t = agoo_text_allocate(1024))) {
+	    AGOO_ERR_MEM(err, "Text");
+	    return NULL;
+	}
+	t = gql_value_json(t, result, 0, 0);
+	gql_value_destroy(result);
+    }
+    return t;
+}
+
+int
+agoo_server_gpublish(agooErr err, const char *subject, gqlRef event) {
+    gqlSub	sub;
+    gqlType	type;
+
+    if (NULL == gql_type_func || NULL == (type = gql_type_func(event))) {
+	return agoo_err_set(err, AGOO_ERR_TYPE, "Not able to determine the type for a GraphQL publish.");
+    }
+    pthread_mutex_lock(&agoo_server.up_lock);
+    for (sub = agoo_server.gsub_list; NULL != sub; sub = sub->next) {
+	if (subject_check(sub->subject, subject)) {
+	    agooRes	res;
+	    agooText	t;
+
+	    if (NULL == (res = agoo_res_create(sub->con))) {
+		AGOO_ERR_MEM(err, "Response");
+		break;
+	    }
+	    if (NULL == (t = gpub_eval(err, sub->query, event))) {
+		break;
+	    }
+	    res->con_kind = AGOO_CON_ANY;
+	    agoo_res_message_push(res, t);
+	    agoo_con_res_append(sub->con, res);
+	}
+    }
+    pthread_mutex_unlock(&agoo_server.up_lock);
+
+    return err->code;
+}

data/ext/agoo/server.h

@@ -9,6 +9,7 @@
 #include "atomic.h"
 #include "bind.h"
 #include "err.h"
+#include "gqleval.h"
 #include "hook.h"
 #include "queue.h"
 
@@ -17,6 +18,8 @@ struct _agooConLoop;
 struct _agooPub;
 struct _agooReq;
 struct _agooUpgraded;
+struct _gqlSub;
+struct _gqlValue;
 
 typedef struct _agooServer {
     volatile bool		inited;
@@ -39,6 +42,7 @@ typedef struct _agooServer {
     atomic_int			con_cnt;
 
     struct _agooUpgraded	*up_list;
+    struct _gqlSub		*gsub_list;
     pthread_mutex_t		up_lock;
     int				max_push_pending;
     void			*env_nil_value;
@@ -66,6 +70,10 @@ extern int	agoo_server_add_func_hook(agooErr	err,
 
 extern void	agoo_server_publish(struct _agooPub *pub);
 
+extern void	agoo_server_add_gsub(struct _gqlSub *sub);
+extern void	agoo_server_del_gsub(struct _gqlSub *sub);
+extern int	agoo_server_gpublish(agooErr err, const char *subject, gqlRef event);
+
 extern struct _agooServer	agoo_server;
 
 extern double	agoo_io_loop_ratio;