agoo 2.12.1 → 2.14.1

data/ext/agoo/req.c

@@ -14,7 +14,7 @@ agooReq
 agoo_req_create(size_t mlen) {
     size_t	size = mlen + sizeof(struct _agooReq) - 7;
     agooReq	req = (agooReq)AGOO_MALLOC(size);
-    
+
     if (NULL != req) {
 	memset(req, 0, size);
 	req->env = agoo_server.env_nil_value;
@@ -56,7 +56,7 @@ agoo_req_port(agooReq r) {
     int		len;
     const char	*host;
     const char	*colon;
-    
+
     if (NULL == (host = agoo_con_header_value(r->header.start, r->header.len, "Host", &len))) {
 	return 0;
     }
@@ -94,7 +94,7 @@ agoo_req_query_value(agooReq r, const char *key, int klen, int *vlenp) {
 static int
 hexVal(int c) {
     int	h = -1;
-    
+
     if ('0' <= c && c <= '9') {
 	h = c - '0';
     } else if ('a' <= c && c <= 'f') {
@@ -110,12 +110,12 @@ agoo_req_query_decode(char *s, int len) {
     char	*sn = s;
     char	*so = s;
     char	*end = s + len;
-    
+
     while (so < end) {
 	if ('%' == *so) {
 	    int	n;
 	    int	c = 0;
-	    
+
 	    so++;
 	    if (0 > (c = hexVal(*so))) {
 		*sn++ = '%';
@@ -133,7 +133,7 @@ agoo_req_query_decode(char *s, int len) {
 	}
     }
     *sn = '\0';
-    
+
     return (int)(sn - s);
 }
 
@@ -145,9 +145,9 @@ agoo_req_header_value(agooReq req, const char *key, int *vlen) {
     const char	*hend = h + req->header.len;
     const char	*value;
     int		klen = (int)strlen(key);
-    
+
     while (h < hend) {
-	if (0 == strncmp(key, h, klen) && ':' == h[klen]) {
+	if (0 == strncasecmp(key, h, klen) && ':' == h[klen]) {
 	    h += klen + 1;
 	    for (; ' ' == *h; h++) {
 	    }
@@ -155,7 +155,7 @@ agoo_req_header_value(agooReq req, const char *key, int *vlen) {
 	    for (; '\r' != *h && '\0' != *h; h++) {
 	    }
 	    *vlen = (int)(h - value);
- 
+
 	    return value;
 	}
 	for (; h < hend; h++) {
@@ -167,4 +167,3 @@ agoo_req_header_value(agooReq req, const char *key, int *vlen) {
     }
     return NULL;
 }
-

data/ext/agoo/req.h

@@ -3,6 +3,7 @@
 #ifndef AGOO_REQ_H
 #define AGOO_REQ_H
 
+#include <arpa/inet.h>
 #include <stdint.h>
 
 #include "hook.h"
@@ -32,6 +33,7 @@ typedef struct _agooReq {
     struct _agooStr		query;
     struct _agooStr		header;
     struct _agooStr		body;
+    char			remote[INET6_ADDRSTRLEN];
     void			*env;
     agooHook			hook;
     size_t			mlen;   // allocated msg length

data/ext/agoo/request.c

@@ -43,6 +43,7 @@ static VALUE	rack_upgrade_val = Qundef;
 static VALUE	rack_url_scheme_val = Qundef;
 static VALUE	rack_version_val = Qundef;
 static VALUE	rack_version_val_val = Qundef;
+static VALUE	remote_addr_val = Qundef;
 static VALUE	request_method_val = Qundef;
 static VALUE	script_name_val = Qundef;
 static VALUE	server_name_val = Qundef;
@@ -96,6 +97,27 @@ method(VALUE self) {
     return req_method((agooReq)DATA_PTR(self));
 }
 
+static VALUE
+req_remote_addr(agooReq r) {
+
+    if (NULL == r) {
+	rb_raise(rb_eArgError, "Request is no longer valid.");
+    }
+    return rb_str_new(r->remote, strlen(r->remote));
+}
+
+/* Document-method: remote_addr
+ *
+ * call-seq: remote_addr()
+ *
+ * Returns the remote address.
+ */
+static VALUE
+remote_addr(VALUE self) {
+    return req_remote_addr((agooReq)DATA_PTR(self));
+}
+
+
 static VALUE
 req_script_name(agooReq r) {
     // The logic is a bit tricky here and for path_info. If the HTTP path is /
@@ -366,14 +388,29 @@ rack_run_once(VALUE self) {
 
 static void
 add_header_value(VALUE hh, const char *key, int klen, const char *val, int vlen) {
+    VALUE	v;
+
     if (sizeof(content_type) - 1 == klen && 0 == strncasecmp(key, content_type, sizeof(content_type) - 1)) {
-	rb_hash_aset(hh, content_type_val, rb_str_new(val, vlen));
+	if (Qnil == (v = rb_hash_lookup2(hh, content_type_val, Qnil))) {
+	    rb_hash_aset(hh, content_type_val, rb_str_new(val, vlen));
+	} else {
+	    volatile VALUE	a = rb_ary_new();
+
+	    rb_ary_push(a, v);
+	    rb_ary_push(a, rb_str_new(val, vlen));
+	    rb_hash_aset(hh, content_type_val, a);
+	}
     } else if (sizeof(content_length) - 1 == klen && 0 == strncasecmp(key, content_length, sizeof(content_length) - 1)) {
-	rb_hash_aset(hh, content_length_val, rb_str_new(val, vlen));
+	if (Qnil == (v = rb_hash_lookup2(hh, content_length_val, Qnil))) {
+	    rb_hash_aset(hh, content_length_val, rb_str_new(val, vlen));
+	} else {
+	    rb_raise(rb_eArgError, "Multiple Content-Length headers.");
+	}
     } else {
 	char		hkey[1024];
 	char		*k = hkey;
 	volatile VALUE	sval = rb_str_new(val, vlen);
+	volatile VALUE	kval;
 
 	strcpy(hkey, "HTTP_");
 	k = hkey + 5;
@@ -392,7 +429,16 @@ add_header_value(VALUE hh, const char *key, int klen, const char *val, int vlen)
 		*k = toupper(*k);
 	    }
 	}
-	rb_hash_aset(hh, rb_str_new(hkey, klen + 5), sval);
+	kval = rb_str_new(hkey, klen + 5);
+	if (Qnil == (v = rb_hash_lookup2(hh, kval, Qnil))) {
+	    rb_hash_aset(hh, kval, sval);
+	} else {
+	    volatile VALUE	a = rb_ary_new();
+
+	    rb_ary_push(a, v);
+	    rb_ary_push(a, sval);
+	    rb_hash_aset(hh, kval, a);
+	}
     }
 }
 
@@ -545,8 +591,9 @@ request_env(agooReq req, VALUE self) {
 	rb_hash_aset(env, script_name_val, req_script_name(req));
 	rb_hash_aset(env, path_info_val, req_path_info(req));
 	rb_hash_aset(env, query_string_val, req_query_string(req));
-	rb_hash_aset(env, server_name_val, req_server_name(req));
+	rb_hash_aset(env, remote_addr_val, req_remote_addr(req));
 	rb_hash_aset(env, server_port_val, req_server_port(req));
+	rb_hash_aset(env, server_name_val, req_server_name(req));
 	fill_headers(req, env);
 	rb_hash_aset(env, rack_version_val, rack_version_val_val);
 	rb_hash_aset(env, rack_url_scheme_val, req_rack_url_scheme(req));
@@ -663,6 +710,7 @@ request_init(VALUE mod) {
     rb_define_method(req_class, "query_string", query_string, 0);
     rb_define_method(req_class, "server_name", server_name, 0);
     rb_define_method(req_class, "server_port", server_port, 0);
+    rb_define_method(req_class, "remote_addr", remote_addr, 0);
     rb_define_method(req_class, "rack_version", rack_version, 0);
     rb_define_method(req_class, "rack_url_scheme", rack_url_scheme, 0);
     rb_define_method(req_class, "rack_input", rack_input, 0);
@@ -713,6 +761,7 @@ request_init(VALUE mod) {
     rack_upgrade_val = rb_str_new_cstr("rack.upgrade?");	rb_gc_register_address(&rack_upgrade_val);
     rack_url_scheme_val = rb_str_new_cstr("rack.url_scheme");	rb_gc_register_address(&rack_url_scheme_val);
     rack_version_val = rb_str_new_cstr("rack.version");		rb_gc_register_address(&rack_version_val);
+    remote_addr_val = rb_str_new_cstr("REMOTE_ADDR");		rb_gc_register_address(&remote_addr_val);
     request_method_val = rb_str_new_cstr("REQUEST_METHOD");	rb_gc_register_address(&request_method_val);
     script_name_val = rb_str_new_cstr("SCRIPT_NAME");		rb_gc_register_address(&script_name_val);
     server_name_val = rb_str_new_cstr("SERVER_NAME");		rb_gc_register_address(&server_name_val);

data/ext/agoo/rgraphql.c

@@ -37,6 +37,9 @@ typedef struct _bhArgs {
 static VALUE		graphql_class = Qundef;
 static VALUE		vroot = Qnil;
 static VALUE		build_headers_func = Qnil;
+static VALUE		arg_clas = Qnil;
+static VALUE		field_clas = Qnil;
+static VALUE		type_clas = Qnil;
 
 static ID		call_id;
 
@@ -101,7 +104,7 @@ call_eval(VALUE x) {
 
 static void*
 protect_eval(void *x) {
-    rb_rescue2(call_eval, (VALUE)x, rescue_error, (VALUE)x, rb_eException, 0);
+    rb_rescue2(call_eval, (VALUE)x, rescue_error, (VALUE)x, rb_eException, (VALUE)0);
 
     return NULL;
 }
@@ -679,7 +682,7 @@ graphql_schema(VALUE self, VALUE root) {
 	printf("*-*-* %s\n", err.msg);
 	exit(6);
     }
-    rb_rescue2(rescue_yield, Qnil, rescue_yield_error, (VALUE)&err, rb_eException, 0);
+    rb_rescue2(rescue_yield, Qnil, rescue_yield_error, (VALUE)&err, rb_eException, (VALUE)0);
     if (AGOO_ERR_OK != err.code) {
 	printf("*-*-* %s\n", err.msg);
 	exit(7);
@@ -774,16 +777,16 @@ graphql_load_file(VALUE self, VALUE path) {
     return Qnil;
 }
 
-/* Document-method: dump_sdl
+/* Document-method: sdl_dump
  *
- * call-seq: dump_sdl()
+ * call-seq: sdl_dump()
  *
  * The preferred method of inspecting a GraphQL schema is to use introspection
  * queries but for debugging and for reviewing the schema a dump of the schema
- * as SDL can be helpful. The _#dump_sdl_ method returns the schema as an SDL
+ * as SDL can be helpful. The _#sdl_dump_ method returns the schema as an SDL
  * string.
  *
- * - *options* [_Hash_] server options
+ * - *options* [_Hash_] options
  *
  *   - *:with_description* [_true_|_false_] if true the description strings are included. If false they are not included.
  *
@@ -817,6 +820,79 @@ graphql_sdl_dump(VALUE self, VALUE options) {
     return dump;
 }
 
+static void
+type_cb(gqlType type, void *ctx) {
+    VALUE	rtypes = (VALUE)ctx;
+    VALUE	t;
+
+    if (GQL_OBJECT != type->kind || type->core) {
+	return;
+    }
+    t = rb_obj_alloc(type_clas);
+    rb_ivar_set(t, rb_intern("@name"), rb_str_new_cstr(type->name));
+    if (NULL != type->desc) {
+	rb_ivar_set(t, rb_intern("@description"), rb_str_new_cstr(type->desc));
+    }
+    if (NULL != type->fields) {
+	VALUE		fields = rb_ary_new();
+	VALUE		field;
+	gqlField	f;
+
+	rb_ivar_set(t, rb_intern("@fields"), fields);
+	for (f = type->fields; NULL != f; f = f->next) {
+	    field = rb_obj_alloc(field_clas);
+	    rb_ary_push(fields, field);
+	    rb_ivar_set(field, rb_intern("@name"), rb_str_new_cstr(f->name));
+	    if (NULL != f->desc) {
+		rb_ivar_set(field, rb_intern("@description"), rb_str_new_cstr(f->desc));
+	    }
+	    if (NULL != f->type) {
+		rb_ivar_set(field, rb_intern("@type_name"), rb_str_new_cstr(f->type->name));
+	    }
+	    if (NULL != f->default_value) {
+		rb_ivar_set(field, rb_intern("@default_value"), gval_to_ruby(f->default_value));
+	    }
+	    if (NULL != f->args) {
+		VALUE	args = rb_ary_new();
+		VALUE	arg;
+		gqlArg	a;
+
+		rb_ivar_set(field, rb_intern("@args"), args);
+		for (a = f->args; NULL != a; a = a->next) {
+		    arg = rb_obj_alloc(arg_clas);
+		    rb_ary_push(args, arg);
+		    rb_ivar_set(arg, rb_intern("@name"), rb_str_new_cstr(a->name));
+		    if (NULL != a->desc) {
+			rb_ivar_set(arg, rb_intern("@description"), rb_str_new_cstr(a->desc));
+		    }
+		    if (NULL != a->type) {
+			rb_ivar_set(arg, rb_intern("@type_name"), rb_str_new_cstr(a->type->name));
+		    }
+		    if (NULL != a->default_value) {
+			rb_ivar_set(arg, rb_intern("@default_value"), gval_to_ruby(a->default_value));
+		    }
+		}
+	    }
+	}
+    }
+    rb_ary_push(rtypes, t);
+}
+
+/* Document-method: sdl_types
+ *
+ * call-seq: sdl_types()
+ *
+ * Returns an array of all SDL types as Ruby objects.
+ */
+static VALUE
+graphql_sdl_types(VALUE self) {
+    VALUE	rtypes = rb_ary_new();
+
+    gql_type_iterate(type_cb, (void*)rtypes);
+
+    return rtypes;
+}
+
 /* Document-method: publish
  *
  * call-seq: publish(subject, event)
@@ -876,7 +952,7 @@ inner_build_headers(VALUE x) {
 
 static void*
 protected_build_headers(void *x) {
-    return (void*)rb_rescue2(inner_build_headers, (VALUE)x, rescue_build_header, (VALUE)x, rb_eException, 0);
+    return (void*)rb_rescue2(inner_build_headers, (VALUE)x, rescue_build_header, (VALUE)x, rb_eException, (VALUE)0);
 }
 
 static agooText
@@ -963,10 +1039,16 @@ graphql_init(VALUE mod) {
 
     rb_define_module_function(graphql_class, "sdl_dump", graphql_sdl_dump, 1);
 
+    rb_define_module_function(graphql_class, "sdl_types", graphql_sdl_types, 0);
+
     rb_define_module_function(graphql_class, "publish", graphql_publish, 2);
 
     rb_define_module_function(graphql_class, "build_headers=", graphql_build_headers, 1);
     rb_define_module_function(graphql_class, "headers", graphql_headers, 1);
 
+    arg_clas = rb_const_get_at(graphql_class, rb_intern("Arg"));
+    field_clas = rb_const_get_at(graphql_class, rb_intern("Field"));
+    type_clas = rb_const_get_at(graphql_class, rb_intern("Type"));
+
     call_id = rb_intern("call");
 }

data/ext/agoo/rserver.c

@@ -103,6 +103,7 @@ configure(agooErr err, int port, const char *root, VALUE options) {
     }
     agoo_server.thread_cnt = 0;
     the_rserver.worker_cnt = 1;
+    the_rserver.uses = NULL;
     atomic_init(&agoo_server.running, 0);
     agoo_server.listen_thread = 0;
     agoo_server.con_loops = NULL;
@@ -384,7 +385,7 @@ handle_base_inner(VALUE x) {
 
 static void*
 handle_base(void *x) {
-    rb_rescue2(handle_base_inner, (VALUE)x, rescue_error, (VALUE)x, rb_eException, 0);
+    rb_rescue2(handle_base_inner, (VALUE)x, rescue_error, (VALUE)x, rb_eException, (VALUE)0);
 
     return NULL;
 }
@@ -613,7 +614,7 @@ handle_rack_inner(VALUE x) {
 static void*
 handle_rack(void *x) {
     //rb_gc_disable();
-    rb_rescue2(handle_rack_inner, (VALUE)x, rescue_error, (VALUE)x, rb_eException, 0);
+    rb_rescue2(handle_rack_inner, (VALUE)x, rescue_error, (VALUE)x, rb_eException, (VALUE)0);
     //rb_gc_enable();
     //rb_gc();
 
@@ -638,7 +639,7 @@ handle_wab_inner(VALUE x) {
 
 static void*
 handle_wab(void *x) {
-    rb_rescue2(handle_wab_inner, (VALUE)x, rescue_error, (VALUE)x, rb_eException, 0);
+    rb_rescue2(handle_wab_inner, (VALUE)x, rescue_error, (VALUE)x, rb_eException, (VALUE)0);
 
     return NULL;
 }
@@ -696,7 +697,7 @@ handle_push_inner(VALUE x) {
 
 static void*
 handle_push(void *x) {
-    rb_rescue2(handle_push_inner, (VALUE)x, rescue_error, (VALUE)x, rb_eException, 0);
+    rb_rescue2(handle_push_inner, (VALUE)x, rescue_error, (VALUE)x, rb_eException, (VALUE)0);
     return NULL;
 }
 
@@ -1014,6 +1015,14 @@ handle(VALUE self, VALUE method, VALUE pattern, VALUE handler) {
 	    }
 	}
     }
+    if (NULL != the_rserver.uses) {
+	RUse	u;
+
+	for (u = the_rserver.uses; NULL != u; u = u->next) {
+	    u->argv[0] = handler;
+	    handler = rb_funcall2(u->clas, rb_intern("new"), u->argc, u->argv);
+	}
+    }
     if (NULL == (hook = rhook_create(meth, pat, handler, &agoo_server.eval_queue))) {
 	rb_raise(rb_eStandardError, "out of memory.");
     } else {
@@ -1195,6 +1204,40 @@ rack_early_hints(VALUE self, VALUE on) {
     return on;
 }
 
+/* Document-method: use
+ *
+ * call-seq: use(middleware, *args)
+ *
+ * The use function must be called before the _handle_ functions. Any
+ * invocations of _use_ apply only to handlers called after the call to use.
+ */
+static VALUE
+use(int argc, VALUE *argv, VALUE self) {
+    VALUE	mc;
+    RUse	u;
+
+    if (argc < 1) { // at least the middleware class must be provided.
+	rb_raise(rb_eArgError, "no middleware class provided");
+    }
+    mc = argv[0];
+    if (T_CLASS != rb_type(mc)) {
+	rb_raise(rb_eArgError, "the first argument to use must be a class");
+    }
+    if (NULL == (u = (RUse)AGOO_MALLOC(sizeof(struct _rUse)))) {
+	rb_raise(rb_eNoMemError, "Failed to allocate memory for a middleware use.");
+    }
+    u->clas = mc;
+    u->argc = argc;
+    if (NULL == (u->argv = (VALUE*)AGOO_MALLOC(sizeof(VALUE) * u->argc))) {
+	rb_raise(rb_eNoMemError, "Failed to allocate memory for a middleware use.");
+    }
+    memcpy(u->argv, argv, argc * sizeof(VALUE));
+    u->next = the_rserver.uses;
+    the_rserver.uses = u;
+
+    return Qnil;
+}
+
 /* Document-class: Agoo::Server
  *
  * An HTTP server that support the rack API as well as some other optimized
@@ -1214,6 +1257,7 @@ server_init(VALUE mod) {
     rb_define_module_function(server_mod, "path_group", path_group, 2);
     rb_define_module_function(server_mod, "header_rule", header_rule, 4);
     rb_define_module_function(server_mod, "domain", domain, 2);
+    rb_define_module_function(server_mod, "use", use, -1);
 
     rb_define_module_function(server_mod, "rack_early_hints", rack_early_hints, 1);