agoo 2.9.0 → 2.10.0

data/ext/agoo/debug.c

@@ -53,7 +53,7 @@ agoo_malloc(size_t size, const char *file, int line) {
 
     if (NULL != ptr) {
 	Rec	r = (Rec)malloc(sizeof(struct _rec));
-	
+
 	if (NULL != r) {
 	    strcpy(((char*)ptr) + size, mem_pad);
 	    r->ptr = ptr;
@@ -79,7 +79,7 @@ agoo_calloc(size_t count, size_t size, const char *file, int line) {
     size *= count;
     if (NULL != (ptr = malloc(size + sizeof(mem_pad)))) {
 	Rec	r = (Rec)malloc(sizeof(struct _rec));
-	
+
 	if (NULL != r) {
 	    memset(ptr, 0, size);
 	    strcpy(((char*)ptr) + size, mem_pad);
@@ -103,7 +103,7 @@ void*
 agoo_realloc(void *orig, size_t size, const char *file, int line) {
     void	*ptr = realloc(orig, size + sizeof(mem_pad));
     Rec		r;
-    
+
     if (NULL != ptr) {
 	strcpy(((char*)ptr) + size, mem_pad);
 	pthread_mutex_lock(&lock);
@@ -131,7 +131,7 @@ agoo_strdup(const char *str, const char *file, int line) {
 
     if (NULL != ptr) {
 	Rec	r = (Rec)malloc(sizeof(struct _rec));
-	
+
 	if (NULL != r) {
 	    strcpy(ptr, str);
 	    strcpy(((char*)ptr) + size, mem_pad);
@@ -158,7 +158,7 @@ agoo_strndup(const char *str, size_t len, const char *file, int line) {
 
     if (NULL != ptr) {
 	Rec	r = (Rec)malloc(sizeof(struct _rec));
-	
+
 	if (NULL != r) {
 	    memcpy(ptr, str, len);
 	    ptr[len] = '\0';
@@ -183,7 +183,7 @@ void
 agoo_mem_check(void *ptr, const char *file, int line) {
     if (NULL != ptr) {
 	Rec	r = NULL;
-    
+
 	pthread_mutex_lock(&lock);
 	for (r = recs; NULL != r; r = r->next) {
 	    if (ptr == r->ptr) {
@@ -199,7 +199,7 @@ agoo_mem_check(void *ptr, const char *file, int line) {
 	    if (0 != strcmp(mem_pad, pad)) {
 		uint8_t	*p;
 		uint8_t	*end = (uint8_t*)pad + sizeof(mem_pad);
-		
+
 		printf("Check - Memory at %s:%d (%p) write outside allocated.\n", file, line, ptr);
 		for (p = (uint8_t*)pad; p < end; p++) {
 		    if (0x20 < *p && *p < 0x7f) {
@@ -219,7 +219,7 @@ agoo_freed(void *ptr, const char *file, int line) {
     if (NULL != ptr) {
 	Rec	r = NULL;
 	Rec	prev = NULL;
-    
+
 	pthread_mutex_lock(&lock);
 	for (r = recs; NULL != r; r = r->next) {
 	    if (ptr == r->ptr) {
@@ -241,7 +241,7 @@ agoo_freed(void *ptr, const char *file, int line) {
 	    if (0 != strcmp(mem_pad, pad)) {
 		uint8_t	*p;
 		uint8_t	*end = (uint8_t*)pad + sizeof(mem_pad);
-		
+
 		printf("Memory at %s:%d (%p) write outside allocated.\n", file, line, ptr);
 		for (p = (uint8_t*)pad; p < end; p++) {
 		    if (0x20 < *p && *p < 0x7f) {

data/ext/agoo/debug.h

@@ -3,6 +3,7 @@
 #ifndef AGOO_DEBUG_H
 #define AGOO_DEBUG_H
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 

data/ext/agoo/error_stream.c

@@ -30,9 +30,8 @@ error_stream_new() {
 	rb_raise(rb_eNoMemError, "Failed to allocate memory for the error stream.");
     }
     es->server = NULL;
-    if (NULL == (es->text = agoo_text_allocate(1024))) {
-	rb_raise(rb_eNoMemError, "Failed to allocate memory for the error stream.");
-    }
+    es->text = NULL;
+
     return Data_Wrap_Struct(es_class, NULL, es_free, es);
 }
 
@@ -50,6 +49,10 @@ es_puts(VALUE self, VALUE str) {
     if (NULL == es) {
 	rb_raise(rb_eIOError, "error stream has been closed.");
     }
+    if (NULL == es->text &&
+	NULL == (es->text = agoo_text_allocate(1024))) {
+	rb_raise(rb_eNoMemError, "Failed to allocate memory for the error stream buffer.");
+    }
     es->text = agoo_text_append(es->text, StringValuePtr(str), (int)RSTRING_LEN(str));
     es->text = agoo_text_append(es->text, "\n", 1);
     if (NULL == es->text) {
@@ -72,6 +75,10 @@ es_write(VALUE self, VALUE str) {
     if (NULL == es) {
 	rb_raise(rb_eIOError, "error stream has been closed.");
     }
+    if (NULL == es->text &&
+	NULL == (es->text = agoo_text_allocate(1024))) {
+	rb_raise(rb_eNoMemError, "Failed to allocate memory for the error stream buffer.");
+    }
     if (NULL == (es->text = agoo_text_append(es->text, StringValuePtr(str), cnt))) {
 	rb_raise(rb_eNoMemError, "Failed to allocate memory for the error stream puts.");
     }
@@ -91,9 +98,10 @@ es_flush(VALUE self) {
     if (NULL == es) {
 	rb_raise(rb_eIOError, "error stream has been closed.");
     }
-    agoo_log_cat(&agoo_error_cat, "%s", es->text->text);
-    es->text->len = 0;
-
+    if (NULL != es->text) {
+	agoo_log_cat(&agoo_error_cat, "%s", es->text->text);
+	es->text->len = 0;
+    }
     return self;
 }
 

data/ext/agoo/gqleval.c

@@ -7,6 +7,7 @@
 #include "gqleval.h"
 #include "gqlintro.h"
 #include "gqljson.h"
+#include "gqlsub.h"
 #include "gqlvalue.h"
 #include "graphql.h"
 #include "http.h"
@@ -15,7 +16,9 @@
 #include "res.h"
 #include "sdl.h"
 #include "sectime.h"
+#include "sse.h"
 #include "text.h"
+#include "websocket.h"
 
 #define MAX_RESOLVE_ARGS	16
 
@@ -30,6 +33,7 @@ static const char	indent_str[] = "indent";
 static const char	json_content_type[] = "application/json";
 static const char	operation_name_str[] = "operationName";
 static const char	query_str[] = "query";
+static const char	subscription_str[] = "subscription";
 static const char	variables_str[] = "variables";
 
 
@@ -38,7 +42,7 @@ gqlValue	(*gql_doc_eval_func)(agooErr err, gqlDoc doc) = NULL;
 // TBD errors should have message, location, and path
 static void
 err_resp(agooRes res, agooErr err, int status) {
-    char		buf[256];
+    char		buf[1024];
     int			cnt;
     int64_t		now = agoo_now_nano();
     time_t		t = (time_t)(now / 1000000000LL);
@@ -54,11 +58,14 @@ err_resp(agooRes res, agooErr err, int status) {
 		   code,
 		   at.year, at.mon, at.day, at.hour, at.min, at.sec, frac);
 
-    agoo_res_message_push(res, agoo_text_create(buf, cnt), true);
+    agoo_res_message_push(res, agoo_text_create(buf, cnt));
 }
 
+static char	ws_up[] = "HTTP/1.1 101 Switching Protocols\r\n";
+
 static void
-value_resp(agooRes res, gqlValue result, int status, int indent) {
+value_resp(agooReq req, gqlValue result, int status, int indent) {
+    agooRes		res = req->res;
     char		buf[256];
     struct _agooErr	err = AGOO_ERR_INIT;
     int			cnt;
@@ -71,6 +78,27 @@ value_resp(agooRes res, gqlValue result, int status, int indent) {
 	gql_value_destroy(result);
 	return;
     }
+    if (NULL == result) {
+	switch (status) {
+	case 101:
+	    if (NULL == (text = agoo_text_append(text, ws_up, sizeof(ws_up) - 1)) ||
+		NULL == (text = agoo_ws_add_headers(req, text)) ||
+		NULL == (text = agoo_text_append(text, "\r\n", 2))) {
+
+		agoo_log_cat(&agoo_error_cat, "Failed to allocate memory for a response.");
+		return;
+	    }
+	    break;
+	case 200:
+	    text = agoo_sse_upgrade(req, text);
+	    break;
+	default:
+	    agoo_log_cat(&agoo_error_cat, "Did not expect an HTTP status of %d.", status);
+	    return;
+	}
+	agoo_res_message_push(res, text);
+	return;
+    }
     if (AGOO_ERR_OK != gql_object_set(&err, msg, "data", result)) {
 	err_resp(res, &err, 500);
 	gql_value_destroy(result);
@@ -84,7 +112,7 @@ value_resp(agooRes res, gqlValue result, int status, int indent) {
     if (NULL == (text = agoo_text_prepend(text, buf, cnt))) {
 	agoo_log_cat(&agoo_error_cat, "Failed to allocate memory for a response.");
     }
-    agoo_res_message_push(res, text, true);
+    agoo_res_message_push(res, text);
 }
 
 gqlValue
@@ -361,13 +389,17 @@ gql_eval_get_hook(agooReq req) {
     gqlDoc		doc;
     gqlValue		result;
     gqlVar		vars = NULL;
+    gqlOpKind		default_kind = GQL_QUERY;
 
     if (NULL != (gq = agoo_req_query_value(req, indent_str, sizeof(indent_str) - 1, &qlen))) {
 	indent = (int)strtol(gq, NULL, 10);
     }
     if (NULL == (gq = agoo_req_query_value(req, query_str, sizeof(query_str) - 1, &qlen))) {
-	err_resp(req->res, &err, 500);
-	return;
+	if (NULL == (gq = agoo_req_query_value(req, subscription_str, sizeof(subscription_str) - 1, &qlen))) {
+	    err_resp(req->res, &err, 500);
+	    return;
+	}
+	default_kind = GQL_SUBSCRIPTION;
     }
     op_name = agoo_req_query_value(req, operation_name_str, sizeof(operation_name_str) - 1, &oplen);
     var_json = agoo_req_query_value(req, variables_str, sizeof(variables_str) - 1, &vlen);
@@ -380,7 +412,7 @@ gql_eval_get_hook(agooReq req) {
     }
     // Only call after extracting the variables as it terminates the string with a \0.
     qlen = agoo_req_query_decode((char*)gq, qlen);
-    if (NULL == (doc = sdl_parse_doc(&err, gq, qlen, vars))) {
+    if (NULL == (doc = sdl_parse_doc(&err, gq, qlen, vars, default_kind))) {
 	err_resp(req->res, &err, 500);
 	return;
     }
@@ -391,12 +423,55 @@ gql_eval_get_hook(agooReq req) {
     } else {
 	result = gql_doc_eval_func(&err, doc);
     }
-    gql_doc_destroy(doc);
     if (NULL == result) {
+	gql_doc_destroy(doc);
 	err_resp(req->res, &err, 500);
 	return;
     }
-    value_resp(req->res, result, 200, indent);
+    if (GQL_SUBSCRIPTION == doc->op->kind) {
+	int		status = 200;
+	gqlValue	sv;
+	const char	*subject;
+	gqlSub		sub;
+
+	switch (req->res->con_kind) {
+	case AGOO_CON_WS:
+	    status = 101;
+	    break;
+	case AGOO_CON_SSE:
+	    break;
+	default:
+	    gql_doc_destroy(doc);
+	    agoo_err_set(&err, AGOO_ERR_NETWORK, "An upgrade to Websockets or SSE is required for a GraphQL subscription.");
+	    err_resp(req->res, &err, 426);
+	    return;
+	}
+	if (NULL == (sv = gql_object_get(result, "subject"))) {
+	    struct _agooErr	e;
+
+	    agoo_err_set(&e, AGOO_ERR_TYPE, "subscription did not return a subject");
+	    err_resp(req->res, &e, 400);
+	    gql_doc_destroy(doc);
+	    return;
+	}
+	subject = gql_string_get(sv);
+
+	if (AGOO_CON_WS == req->res->con_kind) {
+	    status = 101;
+	}
+	doc->op->kind = GQL_QUERY; // need so eval does the right thing
+	if (NULL == (sub = gql_sub_create(&err, req->res->con, subject, doc))) {
+	    err_resp(req->res, &err, 400);
+	    return;
+	}
+	agoo_server_add_gsub(sub);
+
+	value_resp(req, NULL, status, indent);
+
+	return;
+    }
+    gql_doc_destroy(doc);
+    value_resp(req, result, 200, indent);
 }
 
 static gqlValue
@@ -429,7 +504,7 @@ eval_post(agooErr err, agooReq req) {
 	return NULL;
     }
     if (0 == strncmp(graphql_content_type, s, sizeof(graphql_content_type) - 1)) {
-	if (NULL == (doc = sdl_parse_doc(err, req->body.start, req->body.len, vars))) {
+	if (NULL == (doc = sdl_parse_doc(err, req->body.start, req->body.len, vars, GQL_QUERY))) {
 	    return NULL;
 	}
     } else if (0 == strncmp(json_content_type, s, sizeof(json_content_type) - 1)) {
@@ -474,7 +549,7 @@ eval_post(agooErr err, agooReq req) {
 		    }
 		}
 	    }
-	    if (NULL == (doc = sdl_parse_doc(err, query, qlen, vars))) {
+	    if (NULL == (doc = sdl_parse_doc(err, query, qlen, vars, GQL_QUERY))) {
 		goto DONE;
 	    }
 	} else {
@@ -491,7 +566,9 @@ eval_post(agooErr err, agooReq req) {
     } else {
 	result = gql_doc_eval_func(err, doc);
     }
-
+    if (GQL_SUBSCRIPTION == doc->op->kind) {
+	result = NULL;
+    }
 DONE:
     gql_doc_destroy(doc);
     gql_value_destroy(j);
@@ -510,10 +587,12 @@ gql_eval_post_hook(agooReq req) {
     if (NULL != (s = agoo_req_query_value(req, indent_str, sizeof(indent_str) - 1, &len))) {
 	indent = (int)strtol(s, NULL, 10);
     }
-    if (NULL == (result = eval_post(&err, req))) {
+    if (NULL == (result = eval_post(&err, req)) && AGOO_ERR_OK != err.code) {
 	err_resp(req->res, &err, 400);
+    } else if (NULL == result) {
+	value_resp(req, result, 200, indent);
     } else {
-	value_resp(req->res, result, 200, indent);
+	value_resp(req, result, 200, indent);
     }
 }
 

data/ext/agoo/gqlsub.c

@@ -0,0 +1,37 @@
+// Copyright (c) 2019, Peter Ohler, All rights reserved.
+
+#include "con.h"
+#include "debug.h"
+#include "gqlsub.h"
+#include "graphql.h"
+
+gqlSub
+gql_sub_create(agooErr err, agooCon con, const char *subject, struct _gqlDoc *query) {
+    gqlSub	sub = (gqlSub)AGOO_MALLOC(sizeof(struct _gqlSub));
+
+    if (NULL == sub) {
+	AGOO_ERR_MEM(err, "gqlSub");
+	return NULL;
+    }
+    if (NULL == (sub->subject = AGOO_STRDUP(subject))) {
+	AGOO_ERR_MEM(err, "strdup()");
+	AGOO_FREE(sub);
+	return NULL;
+    }
+    sub->next = NULL;
+    sub->con = con;
+    con->gsub = sub;
+    sub->query = query;
+
+    return sub;
+
+}
+
+void
+gql_sub_destroy(gqlSub sub) {
+    AGOO_FREE(sub->subject);
+    if (NULL != sub->query) {
+	gql_doc_destroy(sub->query);
+    }
+    AGOO_FREE(sub);
+}

data/ext/agoo/gqlsub.h

@@ -0,0 +1,24 @@
+// Copyright (c) 2019, Peter Ohler, All rights reserved.
+
+#ifndef AGOO_GQL_SUB_H
+#define AGOO_GQL_SUB_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "err.h"
+
+struct _agooCon;
+struct _gqlDoc;
+
+typedef struct _gqlSub {
+    struct _gqlSub	*next;
+    struct _agooCon	*con;
+    char		*subject;
+    struct _gqlDoc	*query;
+} *gqlSub;
+
+extern gqlSub	gql_sub_create(agooErr err, struct _agooCon *con, const char *subject, struct _gqlDoc *query);
+extern void	gql_sub_destroy(gqlSub sub);
+
+#endif // AGOO_GQL_SUB_H

data/ext/agoo/gqlvalue.c

@@ -993,6 +993,20 @@ gql_object_set(agooErr err, gqlValue obj, const char *key, gqlValue item) {
     return AGOO_ERR_OK;
 }
 
+gqlValue
+gql_object_get(gqlValue obj, const char *key) {
+    if (NULL != obj && obj->type == &object_type) {
+	gqlLink	link = obj->members;
+
+	for (; NULL != link; link = link->next) {
+	    if (0 == strcmp(link->key, key)) {
+		return link->value;
+	    }
+	}
+    }
+    return NULL;
+}
+
 /// create functions //////////////////////////////////////////////////////////
 
 static gqlValue

data/ext/agoo/gqlvalue.h

@@ -74,6 +74,7 @@ extern gqlValue	gql_object_create(agooErr err);
 extern int	gql_list_append(agooErr err, gqlValue list, gqlValue item);
 extern int	gql_list_preend(agooErr err, gqlValue list, gqlValue item);
 extern int	gql_object_set(agooErr err, gqlValue obj, const char *key, gqlValue item);
+extern gqlValue	gql_object_get(gqlValue obj, const char *key);
 
 extern void	gql_int_set(gqlValue value, int32_t i);
 extern void	gql_i64_set(gqlValue value, int64_t i);

data/ext/agoo/graphql.c

@@ -1556,7 +1556,18 @@ static agooText
 op_sdl(agooText text, gqlOp op) {
     gqlSel	sel;
 
-    text = agoo_text_append(text, "query", 5);
+    switch (op->kind) {
+    case GQL_MUTATION:
+	text = agoo_text_append(text, "mutation", 8);
+	break;
+    case GQL_SUBSCRIPTION:
+	text = agoo_text_append(text, "subscription", 12);
+	break;
+    case GQL_QUERY:
+    default:
+	text = agoo_text_append(text, "query", 5);
+	break;
+    }
     if (NULL != op->name) {
 	text = agoo_text_append(text, " ", 1);
 	text = agoo_text_append(text, op->name, -1);
@@ -1647,7 +1658,7 @@ gql_dump_hook(agooReq req) {
     if (NULL == (text = agoo_text_prepend(text, buf, cnt))) {
 	agoo_log_cat(&agoo_error_cat, "Failed to allocate memory for a GraphQL dump.");
     }
-    agoo_res_message_push(req->res, text, true);
+    agoo_res_message_push(req->res, text);
 }
 
 gqlField