agoo 2.8.4 → 2.9.0

data/ext/agoo/page.h

@@ -34,13 +34,13 @@ extern int		agoo_pages_init(agooErr err);
 extern int		agoo_pages_set_root(agooErr err, const char *root);
 extern void		agoo_pages_cleanup();
 
-extern agooGroup	group_create(const char *path);
-extern agooDir		group_add(agooErr err, agooGroup g, const char *dir);
-extern agooPage		group_get(agooErr err, const char *path, int plen);
+extern agooGroup	agoo_group_create(const char *path);
+extern agooDir		agoo_group_add(agooErr err, agooGroup g, const char *dir);
+extern agooPage		agoo_group_get(agooErr err, const char *path, int plen);
 
 extern agooPage		agoo_page_create(const char *path);
 extern agooPage		agoo_page_immutable(agooErr err, const char *path, const char *content, int clen);
-extern agooPage		agoo_page_get(agooErr err, const char *path, int plen);
+extern agooPage		agoo_page_get(agooErr err, const char *path, int plen, const char *root);
 extern int		mime_set(agooErr err, const char *key, const char *value);
 extern int		agoo_header_rule(agooErr err, const char *path, const char *mime, const char *key, const char *value);
 

data/ext/agoo/request.c

@@ -6,6 +6,7 @@
 
 #include "debug.h"
 #include "con.h"
+#include "early_hints.h"
 #include "error_stream.h"
 #include "rack_logger.h"
 #include "request.h"
@@ -17,6 +18,7 @@ static VALUE	connect_val = Qundef;
 static VALUE	content_length_val = Qundef;
 static VALUE	content_type_val = Qundef;
 static VALUE	delete_val = Qundef;
+static VALUE	early_hints_val = Qundef;
 static VALUE	empty_val = Qundef;
 static VALUE	get_val = Qundef;
 static VALUE	head_val = Qundef;
@@ -564,6 +566,11 @@ request_env(agooReq req, VALUE self) {
 	rb_hash_aset(env, rack_hijack_val, self);
 	rb_hash_aset(env, rack_hijack_io_val, Qnil);
 
+	if (agoo_server.rack_early_hints) {
+	    volatile VALUE	eh = agoo_early_hints_new(req);
+
+	    rb_hash_aset(env, early_hints_val, eh);
+	}
 	req->env = (void*)env;
     }
     return (VALUE)req->env;
@@ -603,7 +610,7 @@ to_s(VALUE self) {
  *
  * call-seq: call()
  *
- * Returns an IO like object and hijacks the connection.
+ * Returns an IO like object and hijack the connection.
  */
 static VALUE
 call(VALUE self) {
@@ -679,6 +686,7 @@ request_init(VALUE mod) {
     content_length_val = rb_str_new_cstr("CONTENT_LENGTH");	rb_gc_register_address(&content_length_val);
     content_type_val = rb_str_new_cstr("CONTENT_TYPE");		rb_gc_register_address(&content_type_val);
     delete_val = rb_str_new_cstr("DELETE");			rb_gc_register_address(&delete_val);
+    early_hints_val = rb_str_new_cstr("early_hints");		rb_gc_register_address(&early_hints_val);
     empty_val = rb_str_new_cstr("");				rb_gc_register_address(&empty_val);
     get_val = rb_str_new_cstr("GET");				rb_gc_register_address(&get_val);
     head_val = rb_str_new_cstr("HEAD");				rb_gc_register_address(&head_val);

data/ext/agoo/res.c

@@ -1,5 +1,6 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -26,9 +27,11 @@ agoo_res_create(agooCon con) {
 	}
     }
     res->next = NULL;
-    atomic_init(&res->message, NULL);
+    res->message = NULL;
+    pthread_mutex_init(&res->lock, NULL);
     res->con = con;
     res->con_kind = AGOO_CON_HTTP;
+    res->final = false;
     res->close = false;
     res->ping = false;
     res->pong = false;
@@ -39,10 +42,8 @@ agoo_res_create(agooCon con) {
 void
 agoo_res_destroy(agooRes res) {
     if (NULL != res) {
-	agooText	message = agoo_res_message(res);
-
-	if (NULL != message) {
-	    agoo_text_release(message);
+	if (NULL != res->message) {
+	    agoo_text_release(res->message);
 	}
 	res->next = NULL;
 	pthread_mutex_lock(&res->con->loop->lock);
@@ -57,10 +58,67 @@ agoo_res_destroy(agooRes res) {
 }
 
 void
-agoo_res_set_message(agooRes res, agooText t) {
+agoo_res_message_push(agooRes res, agooText t, bool final) {
     if (NULL != t) {
 	agoo_text_ref(t);
     }
-    atomic_store(&res->message, t);
+    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 = final;
+    }
+    pthread_mutex_unlock(&res->lock);
+}
+
+static const char	early_103[] = "HTTP/1.1 103 Early Hints\r\n";
+
+void
+agoo_res_add_early(agooRes res, agooEarly early) {
+    agooText	t = agoo_text_allocate(1024);
+
+    t = agoo_text_append(t, early_103, sizeof(early_103) - 1);
+    for (; NULL != early; early = early->next) {
+	t = agoo_text_append(t, "Link: ", 6);
+	t = agoo_text_append(t, early->link, -1);
+	t = agoo_text_append(t, "\r\n", 2);
+    }
+    t = agoo_text_append(t, "\r\n", 2);
+    agoo_res_message_push(res, t, false);
+}
+
+agooText
+agoo_res_message_peek(agooRes res) {
+    agooText	t;
+
+    pthread_mutex_lock(&res->lock);
+    t = res->message;
+    pthread_mutex_unlock(&res->lock);
+
+    return t;
 }
 
+agooText
+agoo_res_message_next(agooRes res) {
+    agooText	t;
+
+    pthread_mutex_lock(&res->lock);
+    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
+	agoo_text_release(t2);
+    }
+    t = res->message;
+    pthread_mutex_unlock(&res->lock);
+
+    return t;
+}

data/ext/agoo/res.h

@@ -3,10 +3,12 @@
 #ifndef AGOO_RES_H
 #define AGOO_RES_H
 
+#include <pthread.h>
 #include <stdbool.h>
 
 #include "atomic.h"
 #include "con.h"
+#include "early.h"
 #include "text.h"
 
 struct _agooCon;
@@ -14,20 +16,21 @@ struct _agooCon;
 typedef struct _agooRes {
     struct _agooRes	*next;
     struct _agooCon	*con;
-    _Atomic(agooText)	message;
+    volatile agooText	message;
+    pthread_mutex_t	lock; // a lock around message changes
+    volatile bool	final;
     agooConKind		con_kind;
     bool		close;
     bool		ping;
     bool		pong;
 } *agooRes;
 
-extern agooRes	agoo_res_create(struct _agooCon *con);
-extern void	agoo_res_destroy(agooRes res);
-extern void	agoo_res_set_message(agooRes res, agooText t);
+extern agooRes		agoo_res_create(struct _agooCon *con);
+extern void		agoo_res_destroy(agooRes res);
 
-static inline agooText
-agoo_res_message(agooRes res) {
-    return atomic_load(&res->message);
-}
+extern void		agoo_res_message_push(agooRes res, agooText t, bool final);
+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);
 
 #endif // AGOO_RES_H

data/ext/agoo/rserver.c

@@ -15,6 +15,7 @@
 #include "bind.h"
 #include "con.h"
 #include "debug.h"
+#include "domain.h"
 #include "dtime.h"
 #include "err.h"
 #include "graphql.h"
@@ -311,7 +312,7 @@ rescue_error(VALUE x) {
 	message = agoo_text_create(buf, cnt);
 
 	req->res->close = true;
-	agoo_res_set_message(req->res, message);
+	agoo_res_message_push(req->res, message, true);
 	agoo_queue_wakeup(&agoo_server.con_queue);
     } else {
 /*
@@ -339,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_set_message(req->res, response_text(rres));
+    agoo_res_message_push(req->res, response_text(rres), true);
     agoo_queue_wakeup(&agoo_server.con_queue);
 
     return Qfalse;
@@ -514,7 +515,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_set_message(req->res, t);
+	    agoo_res_message_push(req->res, t, true);
 	    agoo_queue_wakeup(&agoo_server.con_queue);
 	    return Qfalse;
 	default:
@@ -545,7 +546,7 @@ handle_rack_inner(void *x) {
 	    rb_iterate(rb_each, bv, body_append_cb, (VALUE)&t);
 	}
     }
-    agoo_res_set_message(req->res, t);
+    agoo_res_message_push(req->res, t, true);
     agoo_queue_wakeup(&agoo_server.con_queue);
 
     return Qfalse;
@@ -571,7 +572,7 @@ handle_wab_inner(void *x) {
 	rb_funcall((VALUE)req->hook->handler, on_request_id, 2, rr, rres);
     }
     DATA_PTR(rr) = NULL;
-    agoo_res_set_message(req->res, response_text(rres));
+    agoo_res_message_push(req->res, response_text(rres), true);
     agoo_queue_wakeup(&agoo_server.con_queue);
 
     return Qfalse;
@@ -685,7 +686,7 @@ handle_protected(agooReq req, bool gvi) {
 	agooText	message = agoo_text_create(buf, cnt);
 
 	req->res->close = true;
-	agoo_res_set_message(req->res, message);
+	agoo_res_message_push(req->res, message, true);
 	agoo_queue_wakeup(&agoo_server.con_queue);
 	break;
     }
@@ -1023,7 +1024,7 @@ path_group(VALUE self, VALUE path, VALUE dirs) {
     rb_check_type(path, T_STRING);
     rb_check_type(dirs, T_ARRAY);
 
-    if (NULL != (g = group_create(StringValuePtr(path)))) {
+    if (NULL != (g = agoo_group_create(StringValuePtr(path)))) {
 	int	i;
 	int	dcnt = (int)RARRAY_LEN(dirs);
 	VALUE	entry;
@@ -1033,7 +1034,7 @@ path_group(VALUE self, VALUE path, VALUE dirs) {
 	    if (T_STRING != rb_type(entry)) {
 		entry = rb_funcall(entry, rb_intern("to_s"), 0);
 	    }
-	    if (NULL == group_add(&err, g, StringValuePtr(entry))) {
+	    if (NULL == agoo_group_add(&err, g, StringValuePtr(entry))) {
 		rb_raise(rb_eStandardError, "%s", err.msg);
 	    }
 	}
@@ -1072,6 +1073,69 @@ header_rule(VALUE self, VALUE path, VALUE mime, VALUE key, VALUE value) {
     return Qnil;
 }
 
+/* Document-method: domain
+ *
+ * call-seq: domain(host, path)
+ *
+ * Sets up a sub-domain. The first argument, _host_ should be either a String
+ * or a Regexp that includes variable replacement elements. The _path_
+ * argument should also be a string. If the _host_ argument is a Regex then
+ * the $(n) sequence will be replaced by the matching variable in the Regex
+ * result. The _path_ is the root of the sub-domain.
+ */
+static VALUE
+domain(VALUE self, VALUE host, VALUE path) {
+    struct _agooErr	err = AGOO_ERR_INIT;
+
+    switch(rb_type(host)) {
+    case RUBY_T_STRING:
+	rb_check_type(path, T_STRING);
+	if (AGOO_ERR_OK != agoo_domain_add(&err, rb_string_value_ptr((VALUE*)&host), rb_string_value_ptr((VALUE*)&path))) {
+	    rb_raise(rb_eArgError, "%s", err.msg);
+	}
+	break;
+    case RUBY_T_REGEXP: {
+	volatile VALUE	v = rb_funcall(host, rb_intern("inspect"), 0);
+	char		rx[1024];
+
+	if (sizeof(rx) <= RSTRING_LEN(v)) {
+	    rb_raise(rb_eArgError, "host Regex limited to %ld characters", sizeof(rx));
+	}
+	strcpy(rx, rb_string_value_ptr((VALUE*)&v) + 1);
+	rx[RSTRING_LEN(v) - 2] = '\0';
+	if (AGOO_ERR_OK != agoo_domain_add_regex(&err, rx, rb_string_value_ptr((VALUE*)&path))) {
+	    rb_raise(rb_eArgError, "%s", err.msg);
+	}
+	break;
+    }
+    default:
+	rb_raise(rb_eArgError, "host must be a String or Regex");
+	break;
+    }
+    return Qnil;
+}
+
+/* Document-method: rack_early_hints
+ *
+ * call-seq: rack_early_hints(on)
+ *
+ * Turns on or off the inclusion of a early_hints object in the rack call env
+ * Hash. If the argument is nil then the current value is returned.
+ */
+static VALUE
+rack_early_hints(VALUE self, VALUE on) {
+    if (Qtrue == on) {
+	agoo_server.rack_early_hints = true;
+    } else if (Qfalse == on) {
+	agoo_server.rack_early_hints = false;
+    } else if (Qnil == on) {
+	on = agoo_server.rack_early_hints ? Qtrue : Qfalse;
+    } else {
+	rb_raise(rb_eArgError, "rack_early_hints can only be set to true or false");
+    }
+    return on;
+}
+
 /* Document-class: Agoo::Server
  *
  * An HTTP server that support the rack API as well as some other optimized
@@ -1090,6 +1154,9 @@ server_init(VALUE mod) {
     rb_define_module_function(server_mod, "add_mime", add_mime, 2);
     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, "rack_early_hints", rack_early_hints, 1);
 
     call_id = rb_intern("call");
     each_id = rb_intern("each");

data/ext/agoo/server.c

@@ -10,6 +10,7 @@
 #include <unistd.h>
 
 #include "con.h"
+#include "domain.h"
 #include "dtime.h"
 #include "http.h"
 #include "hook.h"
@@ -247,6 +248,7 @@ agoo_server_shutdown(const char *app_name, void (*stop)()) {
 
 	agoo_pages_cleanup();
 	agoo_http_cleanup();
+	agoo_domain_cleanup();
     }
 }
 

data/ext/agoo/server.h

@@ -24,6 +24,7 @@ typedef struct _agooServer {
     int				thread_cnt;
     bool			pedantic;
     bool			root_first;
+    bool			rack_early_hints;
     pthread_t			listen_thread;
     struct _agooQueue		con_queue;
     agooHook			hooks;

data/ext/agoo/text.c

@@ -47,6 +47,7 @@ agoo_text_create(const char *str, int len) {
     agooText	t = (agooText)AGOO_MALLOC(sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + len + 1);
 
     if (NULL != t) {
+	t->next = NULL;
 	t->len = len;
 	t->alen = len;
 	t->bin = false;
@@ -63,6 +64,7 @@ agoo_text_dup(agooText t0) {
 
     if (NULL != t0) {
 	if (NULL != (t = (agooText)AGOO_MALLOC(sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + t0->alen + 1))) {
+	    t->next = NULL;
 	    t->len = t0->len;
 	    t->alen = t0->alen;
 	    t->bin = false;
@@ -78,6 +80,7 @@ agoo_text_allocate(int len) {
     agooText	t = (agooText)AGOO_MALLOC(sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + len + 1);
 
     if (NULL != t) {
+	t->next = NULL;
 	t->len = 0;
 	t->alen = len;
 	t->bin = false;

data/ext/agoo/text.h

@@ -10,11 +10,12 @@
 #define AGOO_TEXT_MIN_SIZE	8
 
 typedef struct _agooText {
-    long	len;  // length of valid text
-    long	alen; // size of allocated text
-    atomic_int	ref_cnt;
-    bool	bin;
-    char	text[AGOO_TEXT_MIN_SIZE];
+    struct _agooText	*next;
+    long		len;  // length of valid text
+    long		alen; // size of allocated text
+    atomic_int		ref_cnt;
+    bool		bin;
+    char		text[AGOO_TEXT_MIN_SIZE];
 } *agooText;
 
 extern agooText	agoo_text_create(const char *str, int len);

data/lib/agoo/version.rb

@@ -1,5 +1,5 @@
 
 module Agoo
   # Agoo version.
-  VERSION = '2.8.4'
+  VERSION = '2.9.0'
 end

data/test/domain_test.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+$: << File.dirname(__FILE__)
+$root_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
+%w(lib ext).each do |dir|
+  $: << File.join($root_dir, dir)
+end
+
+require 'minitest'
+require 'minitest/autorun'
+require 'net/http'
+
+require 'agoo'
+
+class StaticTest < Minitest::Test
+  @@server_started = false
+
+  def start_server
+    Agoo::Log.configure(dir: '',
+			console: true,
+			classic: true,
+			colorize: true,
+			states: {
+			  INFO: false,
+			  DEBUG: false,
+			  connect: false,
+			  request: false,
+			  response: false,
+			  eval: true,
+			})
+
+    Agoo::Server.init(6474, 'root', thread_count: 1)
+    Agoo::Server.domain('domain1.ohler.com', './domain1')
+    Agoo::Server.domain(/^domain([0-9]+).ohler.com$/, './domain$(1)')
+    Agoo::Server.start()
+
+    @@server_started = true
+  end
+
+  def setup
+    unless @@server_started
+      start_server
+    end
+  end
+
+  Minitest.after_run {
+    GC.start
+    Agoo::shutdown
+  }
+
+  def test_one
+    uri = URI('http://localhost:6474/name.txt')
+    req = Net::HTTP::Get.new(uri)
+    req['Host'] = 'domain1.ohler.com'
+    res = Net::HTTP.start(uri.hostname, uri.port) { |h|
+      h.request(req)
+    }
+    content = res.body
+    assert_equal('domain one
+', content)
+  end
+
+  def test_two
+    uri = URI('http://localhost:6474/name.txt')
+    req = Net::HTTP::Get.new(uri)
+    req['Host'] = 'domain2.ohler.com'
+    res = Net::HTTP.start(uri.hostname, uri.port) { |h|
+      h.request(req)
+    }
+    content = res.body
+    assert_equal('domain two
+', content)
+  end
+
+  def test_nothing
+    uri = URI('http://localhost:6474/name.txt')
+    req = Net::HTTP::Get.new(uri)
+    res = Net::HTTP.start(uri.hostname, uri.port) { |h|
+      h.request(req)
+    }
+    assert_equal("404", res.code)
+  end
+
+end