agoo 1.2.2 → 2.0.0

data/ext/agoo/websocket.h

@@ -0,0 +1,27 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_WEBSOCKET_H__
+#define __AGOO_WEBSOCKET_H__
+
+#define WS_OP_CONT	0x00
+#define WS_OP_TEXT	0x01
+#define WS_OP_BIN	0x02
+#define WS_OP_CLOSE	0x08
+#define WS_OP_PING	0x09
+#define WS_OP_PONG	0x0A
+
+struct _Req;
+struct _Text;
+
+extern struct _Text*	ws_add_headers(struct _Req *req, struct _Text *t);
+extern Text		ws_expand(Text t);
+extern size_t		ws_decode(char *buf, size_t mlen);
+
+extern long		ws_calc_len(Con c, uint8_t *buf, size_t cnt);
+extern bool		ws_create_req(Con c, long mlen);
+extern void		ws_req_close(Con c);
+
+extern void		ws_ping(Con c);
+extern void		ws_pong(Con c);
+
+#endif // __AGOO_WEBSOCKET_H__

data/lib/agoo/version.rb

@@ -1,5 +1,5 @@
 
 module Agoo
   # Agoo version.
-  VERSION = '1.2.2'
+  VERSION = '2.0.0'
 end

data/lib/rack/handler/agoo.rb

@@ -1,7 +1,10 @@
 
 require 'agoo'
 
+# Grand parent for the Agoo rack handler.
 module Rack
+
+  # Parent for the Agoo rack handler.
   module Handler
 
     # The Rack::Handler::Agoo module is a handler for common rack config.rb files.
@@ -33,17 +36,21 @@ module Rack
 	  end
 	}
 	options[:thread_count] = 0
-	server = ::Agoo::Server.new(port, root, options)
+	::Agoo::Server.init(port, root, options)
 	path_map.each { |path,handler|
-	  server.handle(nil, path, handler)
+			::Agoo::Server.handle(nil, path, handler)
 	}
 	unless default_handler.nil?
-	  server.handle(nil, '**', default_handler)
+	  ::Agoo::Server.handle(nil, '**', default_handler)
 	end
-	server.handle_not_found(not_found_handler) unless not_found_handler.nil?
-	server.start
+	::Agoo::Server.handle_not_found(not_found_handler) unless not_found_handler.nil?
+	::Agoo::Server.start
+      end
+
+      def self.shutdown
+	::Agoo::shutdown
       end
-      
+
     end
   end
 end

data/test/base_handler_test.rb

@@ -44,28 +44,30 @@ class BaseHandlerTest < Minitest::Test
 
   def test_base_handler
     begin
-      server = Agoo::Server.new(6470, '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,
-				})
+      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(6470, 'root', thread_count: 1)
+
       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()
+
+      Agoo::Server.handle(:GET, "/tellme", handler)
+      Agoo::Server.handle(:POST, "/makeme", handler)
+      Agoo::Server.handle(:PUT, "/makeme", handler)
+      Agoo::Server.handle(:GET, "/wild/*/one", WildHandler.new('one'))
+      Agoo::Server.handle(:GET, "/wild/all/**", WildHandler.new('all'))
+
+      Agoo::Server.start()
 
       #sleep(100)
       eval_test
@@ -74,7 +76,7 @@ class BaseHandlerTest < Minitest::Test
       wild_one_test
       wild_all_test
     ensure
-      server.shutdown
+      Agoo.shutdown
     end
   end
   

data/test/log_test.rb

@@ -11,271 +11,218 @@ require 'minitest/autorun'
 
 require 'agoo'
 
-class LogStateTest < Minitest::Test
+class LogTest < Minitest::Test
 
-  def test_log_state
+  def test_log
+    `rm -rf log`
     begin
-      server = Agoo::Server.new(6464, '.')
+      Agoo::Log.configure(dir: 'log',
+			     max_files: 2,
+			     max_size: 150,
+			     console: false,
+			     classic: true,
+			     colorize: false,
+			     states: {
+			       INFO: true,
+			       DEBUG: true,
+			       eval: true,
+			     })
+
+      10.times { |i|
+	Agoo::Log.info("my #{i} message")
+      }
+      Agoo::Log.flush(1.0)
+      sleep(0.05)
+      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')
+      }
+
+      error_state_test()
+      warn_state_test()
+      info_state_test()
+      debug_state_test()
+      request_state_test()
+
+      Agoo::Log.max_size = 10000
+
+      Agoo::Log.classic
+      Agoo::Log.set_state('DEBUG', true)
+      Agoo::Log.set_state('eval', true)
+      classic_error_test()
+      classic_warn_test()
+      classic_info_test()
+      classic_debug_test()
+      classic_log_test()
+
+      Agoo::Log.json
+      json_error_test()
+      json_warn_test()
+      json_info_test()
+      json_debug_test()
+      json_log_test()
 
-      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
+      Agoo::Log.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)
+  def error_state_test()
+    assert(Agoo::Log.error?)
+    Agoo::Log.set_state('ERROR', false)
+    refute(Agoo::Log.error?)
+    Agoo::Log.set_state('ERROR', true)
   end
 
-  def info_state_test(server)
-    assert(server.info?)
-    server.set_log_state('INFO', false)
-    refute(server.info?)
-    server.set_log_state('INFO', true)
+  def warn_state_test()
+    assert(Agoo::Log.warn?)
+    Agoo::Log.set_state('WARN', false)
+    refute(Agoo::Log.warn?)
+    Agoo::Log.set_state('WARN', true)
   end
 
-  def debug_state_test(server)
-    refute(server.debug?)
-    server.set_log_state('DEBUG', true)
-    assert(server.debug?)
-    server.set_log_state('DEBUG', false)
+  def info_state_test()
+    assert(Agoo::Log.info?)
+    Agoo::Log.set_state('INFO', false)
+    refute(Agoo::Log.info?)
+    Agoo::Log.set_state('INFO', true)
   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)
+  def debug_state_test()
+    Agoo::Log.set_state('DEBUG', false)
+    refute(Agoo::Log.debug?)
+    Agoo::Log.set_state('DEBUG', true)
+    assert(Agoo::Log.debug?)
+    Agoo::Log.set_state('DEBUG', 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)
+  def request_state_test()
+    Agoo::Log.set_state('request', false)
+    refute(Agoo::Log.state('request'))
+    Agoo::Log.set_state('request', true)
+    assert(Agoo::Log.state('request'))
+    Agoo::Log.set_state('request', 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)
+  def unknown_state_test()
     assert_raises(ArgumentError) {
-      server.log_state('unknown')
+      Agoo::Log.state('unknown')
     }
     assert_raises(ArgumentError) {
-      server.set_log_state('unknown', true)
+      Agoo::Log.set_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)
-    sleep(0.01) # seems to be needed to assure writes actually happened even though flush was called.
+  def classic_error_test()
+    Agoo::Log.rotate
+    Agoo::Log.error('my message')
+    Agoo::Log.flush(1.0)
+    sleep(0.05) # seems to be needed to assure writes actually happened even though flush was called.
     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)
-    sleep(0.01)
+  def classic_warn_test()
+    Agoo::Log.rotate
+    Agoo::Log.warn('my message')
+    Agoo::Log.flush(1.0)
+    sleep(0.05)
     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)
-    sleep(0.01)
+  def classic_info_test()
+    Agoo::Log.rotate
+    Agoo::Log.info('my message')
+    Agoo::Log.flush(1.0)
+    sleep(0.05)
     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)
-    sleep(0.01)
+  def classic_debug_test()
+    Agoo::Log.rotate
+    Agoo::Log.debug('my message')
+    Agoo::Log.flush(1.0)
+    sleep(0.05)
     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)
-    sleep(0.01)
+  def classic_log_test()
+    Agoo::Log.rotate
+    Agoo::Log.log('eval', 'my message')
+    Agoo::Log.flush(1.0)
+    sleep(0.05)
     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)
-    sleep(0.01)
-    content = IO.read('log/agoo.log.1')
+  def json_error_test()
+    Agoo::Log.rotate
+    Agoo::Log.error('my message')
+    Agoo::Log.flush(1.0)
+    sleep(0.05)
+    content = IO.read('log/agoo.log')
     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)
-    sleep(0.01)
-    content = IO.read('log/agoo.log.1')
+  def json_warn_test()
+    Agoo::Log.rotate
+    Agoo::Log.warn('my message')
+    Agoo::Log.flush(1.0)
+    sleep(0.05)
+    content = IO.read('log/agoo.log')
     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)
-    sleep(0.01)
-    content = IO.read('log/agoo.log.1')
+  def json_info_test()
+    Agoo::Log.rotate
+    Agoo::Log.info('my message')
+    Agoo::Log.flush(1.0)
+    sleep(0.05)
+    content = IO.read('log/agoo.log')
     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)
-    sleep(0.01)
-    content = IO.read('log/agoo.log.1')
+  def json_debug_test()
+    Agoo::Log.rotate
+    Agoo::Log.debug('my message')
+    Agoo::Log.flush(1.0)
+    sleep(0.05)
+    content = IO.read('log/agoo.log')
     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)
-    sleep(0.01)
-    content = IO.read('log/agoo.log.1')
+  def json_log_test()
+    Agoo::Log.rotate
+    Agoo::Log.log('eval', 'my message')
+    Agoo::Log.flush(1.0)
+    sleep(0.05)
+    content = IO.read('log/agoo.log')
     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)
-      sleep(0.01)
-      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