agoo 0.9.0

data/ext/agoo/server.h

@@ -0,0 +1,47 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_SERVER_H__
+#define __AGOO_SERVER_H__
+
+#include <pthread.h>
+#include <stdbool.h>
+#include <stdatomic.h>
+
+#include <ruby.h>
+
+#include "hook.h"
+#include "log.h"
+#include "page.h"
+#include "queue.h"
+
+typedef struct _Server {
+    volatile bool	active;
+    int			thread_cnt;
+    int			port;
+    bool		pedantic;
+    char		*root;
+    atomic_int		running;
+    pthread_t		listen_thread;
+    pthread_t		con_thread;
+    struct _Log		log;
+    struct _LogCat	error_cat;
+    struct _LogCat	warn_cat;
+    struct _LogCat	info_cat;
+    struct _LogCat	debug_cat;
+    struct _LogCat	con_cat;
+    struct _LogCat	req_cat;
+    struct _LogCat	resp_cat;
+    struct _LogCat	eval_cat;
+    
+    struct _Queue	con_queue;
+    struct _Cache	pages;
+
+    Hook		hooks;
+    struct _Queue	eval_queue;
+
+    VALUE		*eval_threads; // Qnil terminated
+} *Server;
+
+extern void	server_init(VALUE mod);
+
+#endif // __AGOO_SERVER_H__

data/ext/agoo/text.c

@@ -0,0 +1,66 @@
+// Copyright 2016, 2018 by Peter Ohler, All Rights Reserved
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "text.h"
+
+Text
+text_create(const char *str, int len) {
+    Text	t = (Text)malloc(sizeof(struct _Text) - TEXT_MIN_SIZE + len + 1);
+
+    if (NULL != t) {
+	t->len = len;
+	t->alen = len;
+	atomic_init(&t->ref_cnt, 0);
+	memcpy(t->text, str, len);
+	t->text[len] = '\0';
+    }
+    return t;
+}
+
+Text
+text_allocate(int len) {
+    Text	t = (Text)malloc(sizeof(struct _Text) - TEXT_MIN_SIZE + len + 1);
+
+    if (NULL != t) {
+	t->len = 0;
+	t->alen = len;
+	atomic_init(&t->ref_cnt, 0);
+	*t->text = '\0';
+    }
+    return t;
+}
+
+void
+text_ref(Text t) {
+    atomic_fetch_add(&t->ref_cnt, 1);
+}
+
+void
+text_release(Text t) {
+    if (1 >= atomic_fetch_sub(&t->ref_cnt, 1)) {
+	free(t);
+    }
+}
+
+Text
+text_append(Text t, const char *s, int len) {
+    if (0 >= len) {
+	len = strlen(s);
+    }
+    if (t->alen <= t->len + len) {
+	long	new_len = t->alen + t->alen / 2;
+	size_t	size = sizeof(struct _Text) - TEXT_MIN_SIZE + new_len + 1;
+
+	if (NULL == (t = (Text)realloc(t, size))) {
+	    return NULL;
+	}
+	t->alen = new_len;
+    }
+    memcpy(t->text + t->len, s, len);
+    t->len += len;
+    t->text[t->len] = '\0';
+
+    return t;
+}

data/ext/agoo/text.h

@@ -0,0 +1,24 @@
+// Copyright 2016, 2018 by Peter Ohler, All Rights Reserved
+
+#ifndef __AGOO_TEXT_H__
+#define __AGOO_TEXT_H__
+
+#include <stdatomic.h>
+#include <stdbool.h>
+
+#define TEXT_MIN_SIZE	8
+
+typedef struct _Text {
+    long	len; // length of valid text
+    long	alen; // size of allocated text
+    atomic_int	ref_cnt;
+    char	text[TEXT_MIN_SIZE];
+} *Text;
+
+extern Text	text_create(const char *str, int len);
+extern Text	text_allocate(int len);
+extern void	text_ref(Text t);
+extern void	text_release(Text t);
+extern Text	text_append(Text t, const char *s, int len);
+
+#endif /* __AGOO_TEXT_H__ */

data/ext/agoo/types.h

@@ -0,0 +1,18 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_TYPES_H__
+#define __AGOO_TYPES_H__
+
+typedef enum {
+    CONNECT	= 'C',
+    DELETE	= 'D',
+    GET		= 'G',
+    HEAD	= 'H',
+    OPTIONS	= 'O',
+    POST	= 'P',
+    PUT		= 'U',
+    ALL		= 'A',
+    NONE	= '\0',
+} Method;
+
+#endif // __AGOO_TYPES_H__

data/lib/agoo.rb

@@ -0,0 +1,9 @@
+
+# Agoo is the module that includes an HTTP server. The word agoo is a Japanese
+# word for a type of flying fish.
+module Agoo
+end
+
+require 'agoo/version'
+
+require 'agoo/agoo' # C extension

data/lib/agoo/version.rb

@@ -0,0 +1,5 @@
+
+module Agoo
+  # Agoo version.
+  VERSION = '0.9.0'
+end

data/test/base_handler_test.rb

@@ -0,0 +1,170 @@
+#!/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 'oj'
+
+require 'agoo'
+
+class BaseHandlerTest < Minitest::Test
+
+  class TellMeHandler
+    def initialize
+    end
+
+    def on_request(req, res)
+      if 'GET' == req.request_method
+	res.body = Oj.dump(req.to_h, mode: :null)
+      elsif 'POST' == req.request_method
+	res.code = 204
+      elsif 'PUT' == req.request_method
+	res.code = 201
+	res.body = req.body
+      end
+    end
+  end
+
+  class WildHandler
+    def initialize(name)
+      @name = name
+    end
+
+    def on_request(req, res)
+      res.body = "#{@name} - #{req.script_name}"
+    end
+  end
+
+  def test_base_handler
+    begin
+      server = Agoo::Server.new(6464, 'root',
+				pedantic: false,
+				log_dir: '',
+				thread_count: 1,
+				log_console: true,
+				log_classic: true,
+				log_colorize: true,
+				log_states: {
+				  INFO: false,
+				  DEBUG: false,
+				  connect: false,
+				  request: false,
+				  response: false,
+				  eval: true,
+				})
+      handler = TellMeHandler.new
+      server.handle(:GET, "/tellme", handler)
+      server.handle(:POST, "/makeme", handler)
+      server.handle(:PUT, "/makeme", handler)
+      server.handle(:GET, "/wild/*/one", WildHandler.new('one'))
+      server.handle(:GET, "/wild/all/**", WildHandler.new('all'))
+      server.start()
+
+      #sleep(100)
+      eval_test
+      post_test
+      put_test
+      wild_one_test
+      wild_all_test
+    ensure
+      server.shutdown
+    end
+  end
+  
+  def eval_test
+    uri = URI('http://localhost:6464/tellme?a=1')
+    req = Net::HTTP::Get.new(uri)
+    # Set the headers the way we want them.
+    req['Accept-Encoding'] = '*'
+    req['Accept'] = 'application/json'
+    req['User-Agent'] = 'Ruby'
+
+    res = Net::HTTP.start(uri.hostname, uri.port) { |h|
+      h.request(req)
+    }
+    content = res.body
+    obj = Oj.load(content, mode: :strict)
+
+    expect = {
+      "HTTP_Accept" => "application/json",
+      "HTTP_Accept-Encoding" => "*",
+      "HTTP_User-Agent" => "Ruby",
+      "PATH_INFO" => "",
+      "QUERY_STRING" => "a=1",
+      "REQUEST_METHOD" => "GET",
+      "SCRIPT_NAME" => "/tellme",
+      "SERVER_NAME" => "localhost",
+      "SERVER_PORT" => "6464",
+      "rack.errors" => nil,
+      "rack.input" => nil,
+      "rack.multiprocess" => false,
+      "rack.multithread" => false,
+      "rack.run_once" => false,
+      "rack.url_scheme" => "http",
+      "rack.version" => "2.0.3",
+    }
+    expect.each_pair { |k,v|
+      if v.nil?
+	assert_nil(obj[k], k)
+      else
+	assert_equal(v, obj[k], k)
+      end
+    }
+  end
+
+  def post_test
+    uri = URI('http://localhost:6464/makeme')
+    req = Net::HTTP::Post.new(uri)
+    # Set the headers the way we want them.
+    req['Accept-Encoding'] = '*'
+    req['Accept'] = 'application/json'
+    req['User-Agent'] = 'Ruby'
+    
+    res = Net::HTTP.start(uri.hostname, uri.port) { |h|
+      h.request(req)
+    }
+    assert_equal(Net::HTTPNoContent, res.class)
+  end
+  
+  def put_test
+    uri = URI('http://localhost:6464/makeme')
+    req = Net::HTTP::Put.new(uri)
+    # Set the headers the way we want them.
+    req['Accept-Encoding'] = '*'
+    req['Accept'] = 'application/json'
+    req['User-Agent'] = 'Ruby'
+    req.body = 'hello'
+    
+    res = Net::HTTP.start(uri.hostname, uri.port) { |h|
+      h.request(req)
+    }
+    assert_equal(Net::HTTPCreated, res.class)
+    assert_equal('hello', res.body)
+  end
+
+  def wild_one_test
+    uri = URI('http://localhost:6464/wild/abc/one')
+    req = Net::HTTP::Get.new(uri)
+    res = Net::HTTP.start(uri.hostname, uri.port) { |h|
+      h.request(req)
+    }
+    assert_equal('one - /wild/abc/one', res.body)
+  end
+
+  def wild_all_test
+    uri = URI('http://localhost:6464/wild/all/x/y')
+    req = Net::HTTP::Get.new(uri)
+    res = Net::HTTP.start(uri.hostname, uri.port) { |h|
+      h.request(req)
+    }
+    assert_equal('all - /wild/all/x/y', res.body)
+  end
+
+end

data/test/log_test.rb

@@ -0,0 +1,269 @@
+#!/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 'agoo'
+
+class LogStateTest < Minitest::Test
+
+  def test_log_state
+    begin
+      server = Agoo::Server.new(6464, '.')
+
+      error_state_test(server)
+      warn_state_test(server)
+      info_state_test(server)
+      debug_state_test(server)
+      request_state_test(server)
+      response_state_test(server)
+      eval_state_test(server)
+    ensure
+      server.shutdown
+    end
+  end
+  
+  def error_state_test(server)
+    assert(server.error?)
+    server.set_log_state('ERROR', false)
+    refute(server.error?)
+    server.set_log_state('ERROR', true)
+  end
+
+  def warn_state_test(server)
+    assert(server.warn?)
+    server.set_log_state('WARN', false)
+    refute(server.warn?)
+    server.set_log_state('WARN', true)
+  end
+
+  def info_state_test(server)
+    refute(server.info?)
+    server.set_log_state('INFO', true)
+    assert(server.info?)
+  end
+
+  def debug_state_test(server)
+    refute(server.debug?)
+    server.set_log_state('DEBUG', true)
+    assert(server.debug?)
+    server.set_log_state('DEBUG', false)
+  end
+
+  def request_state_test(server)
+    refute(server.log_state('request'))
+    server.set_log_state('request', true)
+    assert(server.log_state('request'))
+    server.set_log_state('request', false)
+  end
+
+  def response_state_test(server)
+    refute(server.log_state('response'))
+    server.set_log_state('response', true)
+    assert(server.log_state('response'))
+    server.set_log_state('response', false)
+  end
+
+  def eval_state_test(server)
+    refute(server.log_state('eval'))
+    server.set_log_state('eval', true)
+    assert(server.log_state('eval'))
+    server.set_log_state('eval', false)
+  end
+
+  def unknown_state_test(server)
+    assert_raises(ArgumentError) {
+      server.log_state('unknown')
+    }
+    assert_raises(ArgumentError) {
+      server.set_log_state('unknown', true)
+    }
+  end
+
+end
+
+class LogClassicTest < Minitest::Test
+
+  def test_log_classic
+    `rm -rf log`
+    begin
+      server = Agoo::Server.new(6464, '.',
+				log_dir: 'log',
+				log_console: false,
+				log_classic: true,
+				log_colorize: false,
+				log_states: {
+				  INFO: true,
+				  DEBUG: true,
+				  eval: true,
+				})
+      error_test(server)
+      warn_test(server)
+      info_test(server)
+      debug_test(server)
+      log_eval_test(server)
+    ensure
+      server.shutdown
+    end
+  end
+  
+  def error_test(server)
+    server.error('my message')
+    server.log_flush(1.0)
+    content = IO.read('log/agoo.log')
+    assert_match(/ERROR: my message/, content)
+  end
+
+  def warn_test(server)
+    server.warn('my message')
+    server.log_flush(1.0)
+    content = IO.read('log/agoo.log')
+    assert_match(/WARN: my message/, content)
+  end
+
+  def info_test(server)
+    server.info('my message')
+    server.log_flush(1.0)
+    content = IO.read('log/agoo.log')
+    assert_match(/INFO: my message/, content)
+  end
+
+  def debug_test(server)
+    server.debug('my message')
+    server.log_flush(1.0)
+    content = IO.read('log/agoo.log')
+    assert_match(/DEBUG: my message/, content)
+  end
+
+  def log_eval_test(server)
+    server.log_eval('my message')
+    server.log_flush(1.0)
+    content = IO.read('log/agoo.log')
+    assert_match(/eval: my message/, content)
+  end
+
+end
+
+class LogJsonTest < Minitest::Test
+
+  def test_log_json
+    `rm -rf log`
+    begin
+      server = Agoo::Server.new(6464, '.',
+				log_dir: 'log',
+				log_max_files: 2,
+				log_max_size: 10,
+				log_console: false,
+				log_classic: false,
+				log_colorize: false,
+				log_states: {
+				  INFO: true,
+				  DEBUG: true,
+				  eval: true,
+				})
+      error_test(server)
+      warn_test(server)
+      info_test(server)
+      debug_test(server)
+      eval_test(server)
+    ensure
+      server.shutdown
+    end
+  end
+  
+  def error_test(server)
+    server.error('my message')
+    server.log_flush(1.0)
+    content = IO.read('log/agoo.log.1')
+    assert_match(/"where":"ERROR"/, content)
+    assert_match(/"level":1/, content)
+    assert_match(/"what":"my message"/, content)
+  end
+
+  def warn_test(server)
+    server.warn('my message')
+    server.log_flush(1.0)
+    content = IO.read('log/agoo.log.1')
+    assert_match(/"where":"WARN"/, content)
+    assert_match(/"level":2/, content)
+    assert_match(/"what":"my message"/, content)
+  end
+
+  def info_test(server)
+    server.info('my message')
+    server.log_flush(1.0)
+    content = IO.read('log/agoo.log.1')
+    assert_match(/"where":"INFO"/, content)
+    assert_match(/"level":3/, content)
+    assert_match(/"what":"my message"/, content)
+  end
+
+  def debug_test(server)
+    server.debug('my message')
+    server.log_flush(1.0)
+    content = IO.read('log/agoo.log.1')
+    assert_match(/"where":"DEBUG"/, content)
+    assert_match(/"level":4/, content)
+    assert_match(/"what":"my message"/, content)
+  end
+
+  def eval_test(server)
+    server.log_eval('my message')
+    server.log_flush(1.0)
+    content = IO.read('log/agoo.log.1')
+    assert_match(/"where":"eval"/, content)
+    assert_match(/"level":3/, content)
+    assert_match(/"what":"my message"/, content)
+  end
+
+end
+
+class LogRollTest < Minitest::Test
+
+  def setup
+    `rm -rf log`
+    begin
+      server = Agoo::Server.new(6464, '.',
+				 log_dir: 'log',
+				 log_max_files: 2,
+				 log_max_size: 150,
+				 log_console: false,
+				 log_classic: true,
+				 log_colorize: false,
+				 log_states: {
+				   INFO: true,
+				   DEBUG: true,
+				   eval: true,
+				 })
+      10.times { |i|
+	@server.info("my #{i} message")
+      }
+      @server.log_flush(1.0)
+      content = IO.read('log/agoo.log')
+      assert_match(/INFO: my 9 message/, content)
+
+      content = IO.read('log/agoo.log.1')
+      assert_match(/INFO: my 6 message/, content)
+      assert_match(/INFO: my 7 message/, content)
+      assert_match(/INFO: my 8 message/, content)
+
+      content = IO.read('log/agoo.log.2')
+      assert_match(/INFO: my 3 message/, content)
+      assert_match(/INFO: my 4 message/, content)
+      assert_match(/INFO: my 5 message/, content)
+
+      assert_raises() {
+	IO.read('log/agoo.log.3')
+      }
+    ensure
+      @server.shutdown
+    end
+  end
+
+end