wabur 0.6.2 → 0.7.0

data/lib/wab/impl/webrick/sender.rb

@@ -0,0 +1,34 @@
+
+require 'webrick'
+
+module WAB
+  module Impl
+    module WEBrick
+
+      # The Sender module adds support for sending results and errors.
+      module Sender
+
+	# Sends the results from a controller request.
+	def send_result(result, res, path, query)
+          result = @shell.data(result) unless result.is_a?(WAB::Data)
+          response_body = result.json(@shell.indent)
+          res.status = 200
+          res['Content-Type'] = 'application/json'
+          @shell.logger.debug("reply to #{path.join('/')}#{query}: #{response_body}") if @shell.logger.debug?
+          res.body = response_body
+	end
+
+	# Sends an error from a rescued call.
+	def send_error(e, res)
+          res.status = 500
+          res['Content-Type'] = 'application/json'
+          body = { code: -1, error: "#{e.class}: #{e.message}" }
+          body[:backtrace] = e.backtrace
+          res.body = @shell.data(body).json(@shell.indent)
+          @shell.logger.warn(Impl.format_error(e))
+	end
+
+      end # Sender
+    end # WEBrick
+  end # Impl
+end # WAB

data/lib/wab/impl/webrick/server.rb

@@ -0,0 +1,39 @@
+
+require 'webrick'
+
+module WAB
+  module Impl
+    module WEBrick
+
+      # The Server module provides a server start method.
+      module Server
+
+	# Start the WEBrick server and set the mount points.
+	def self.start(shell)
+          mime_types = ::WEBrick::HTTPUtils::DefaultMimeTypes
+          mime_types['es6'] = 'application/javascript'
+          server = ::WEBrick::HTTPServer.new(Port: shell.http_port,
+                                             DocumentRoot: shell.http_dir,
+                                             MimeTypes: mime_types)
+          server.logger.level = 5 - shell.logger.level unless shell.logger.nil?
+
+          shell.mounts.each { |hh|
+	    if hh.has_key?(:type)
+              server.mount("#{shell.pre_path}/#{hh[:type]}", WAB::Impl::WEBrick::Handler, shell, shell.create_controller(hh[:handler]), false)
+	    elsif hh.has_key?(:path)
+              server.mount(hh[:path], WAB::Impl::WEBrick::Handler, shell, shell.create_controller(hh[:handler]), true)
+	    else
+              raise WAB::Error.new("Invalid handle configuration. Missing path or type.")
+	    end
+	  }
+          server.mount(shell.tql_path, TqlHandler, shell) unless (shell.tql_path.nil? || shell.tql_path.empty?)
+          server.mount('/', ExportProxy, shell.http_dir) if shell.export_proxy
+
+          trap 'INT' do server.shutdown end
+          server.start
+	end
+
+      end # Server
+    end # WEBrick
+  end # Impl
+end # WAB

data/lib/wab/impl/webrick/tql_handler.rb

@@ -0,0 +1,58 @@
+
+require 'webrick'
+
+module WAB
+  module Impl
+    module WEBrick
+
+      # Handler for requests that fall under the path assigned to the
+      # Controller. This is used only with the WAB::Impl::Shell.
+      class TqlHandler < ::WEBrick::HTTPServlet::AbstractServlet
+
+	def initialize(server, shell)
+          super(server)
+          @shell = shell
+	end
+
+	def do_POST(req, res)
+          path = req.path.split('/')[1..-1]
+          query = {}
+          req.query.each { |k,v| query[k.to_sym] = v }
+          tql = Oj.load(req.body, mode: :wab)
+          log_request_with_body('TQL', path, query, tql) if @shell.logger.info?
+          send_result(@shell.query(tql), res, path, query)
+	rescue StandardError => e
+          send_error(e, res)
+	end
+
+	private
+
+	def log_request_with_body(caller, path, query, body)
+          body = Data.new(body) unless body.is_a?(WAB::Data)
+          @shell.logger.info("#{caller} #{path.join('/')}#{query}\n#{body.json(@shell.indent)}")
+	end
+
+	# Sends the results from a controller request.
+	def send_result(result, res, path, query)
+          result = @shell.data(result) unless result.is_a?(WAB::Data)
+          response_body = result.json(@shell.indent)
+          res.status = 200
+          res['Content-Type'] = 'application/json'
+          @shell.logger.debug("reply to #{path.join('/')}#{query}: #{response_body}") if @shell.logger.debug?
+          res.body = response_body
+	end
+
+	# Sends an error from a rescued call.
+	def send_error(e, res)
+          res.status = 500
+          res['Content-Type'] = 'application/json'
+          body = { code: -1, error: "#{e.class}: #{e.message}" }
+          body[:backtrace] = e.backtrace
+          res.body = @shell.data(body).json(@shell.indent)
+          @shell.logger.warn(Impl.format_error(e))
+	end
+
+      end # TqlHandler
+    end # WEBrick
+  end # Impl
+end # WAB

data/lib/wab/racker.rb

@@ -0,0 +1,25 @@
+module WAB
+
+  # A Racker or a duck-typed alternative should be created and registered with
+  # a Shell for paths that expected to follow the Ruby rack API. The shell is
+  # included so that queries can be made when responding to requests.
+  class Racker # :doc: all
+    attr_accessor :shell
+
+    # Create a instance.
+    def initialize(shell)
+      @shell = shell
+    end
+
+    # Rack handler for processing rack requests. Implemenation should follow
+    # the rack API described at https://rack.github.io.
+    #
+    # env:: data to be processed
+    #
+    # return:: a rack compliant response.
+    def call(env)
+      [200, {}, ['A WABuR Rack Application']]
+    end
+
+  end
+end

data/lib/wab/version.rb

@@ -1,5 +1,5 @@
 
 module WAB
   # Current version of the module.
-  VERSION = '0.6.2'
+  VERSION = '0.7.0'
 end

data/pages/Architecture.md

@@ -158,12 +158,21 @@ API. From the view perspective a REST over HTTP is used.
 
 #### Just Data
 
-  - just data and data helpers (get, set, inspect, to_s)
-   - nothing like to_json
-   - reasoning it that different uses require different behavior
-    - different stores, view, processing, etc
-   - use of delgate is encouraged
-
+WABuR keeps data and behavior separate. The data portion of a system is
+represented by `WAB::Data` class. Behavior is implemented by support
+classes. This alows extensions to be added without conflict as the `Data`
+class is not modified by adding new features. This avoids the conflicts
+encountered with Rails when it monkey patches core classes to add `to_json`
+which conflicts with the JSON gem and locks out other better performing
+extensions.
+
+The reasoning behind the separation of data and behavior to improve
+extendability is that different features often need similar but different
+features. As an example data might need to be stored in multiple data stores
+or be encoded for a view, external processing, or writing to a file. If the
+behavior is encoded in the data object then care must be taken to avoid using
+the same method names which is difficult if separate authors are contributing
+or open source gems are used.
 
 ### View/Controller
 

data/test/test_client.rb

@@ -0,0 +1,282 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << __dir__
+$LOAD_PATH << File.expand_path('../lib', __dir__)
+
+require 'minitest'
+require 'minitest/autorun'
+require 'fileutils'
+require 'open3'
+require 'uri'
+
+require 'wab'
+
+class TestClient < Minitest::Test
+
+  # All tests must leave the DB state of the server unchanged.
+
+  def run_wabur(port)
+    store_dir = "#{__dir__}/client_test/data#{port}"
+    FileUtils.remove_dir(store_dir, true)
+    _, @out, wt = Open3.popen2e("ruby", "#{__dir__}/../bin/wabur", '-I', "#{__dir__}/../lib", '-c', "#{__dir__}/client_test/wabur.conf", '--http.port', port.to_s, '--store.dir', store_dir)
+    20.times {
+      begin
+        Net::HTTP.get_response(URI("http://localhost:#{port}"))
+        break
+      rescue Exception => e
+        sleep(0.1)
+      end
+    }
+    wt.pid
+  end
+  
+  def shutdown_wabur(pid)
+    Process.kill('HUP', pid)
+    # Uncomment to get verbose output from the server.
+    #puts @out.read
+    Process.wait
+  rescue
+    # ignore
+  end
+
+  def test_simple
+    port = 6371
+    pid = run_wabur(port)
+    client = WAB::Client.new('localhost', port)
+    result = client.create({kind: 'Test', value: 123})
+    assert_equal(0, result[:code], 'create result code mismatch')
+    ref = result[:ref]
+
+    result = client.read('Test', ref)
+    assert_equal(0, result[:code], 'read result code mismatch')
+    assert_equal(1, result[:results].length, 'read result wrong length')
+    rec = result[:results][0]
+    assert_equal('Test', rec[:data][:kind], 'read kind mismatch')
+    assert_equal(123, rec[:data][:value], 'read value mismatch')
+
+    result = client.delete('Test', ref)
+    assert_equal(0, result[:code], 'delete result code mismatch')
+    assert_equal([ref], result[:deleted], 'delete list mismatch')
+
+    result = client.read('Test', ref)
+    assert_equal(0, result[:code], 'read after delete result code mismatch')
+    assert_equal(0, result[:results].length, 'read after delete result wrong length')
+
+    ensure
+    shutdown_wabur(pid)
+  end
+
+  def test_types
+    port = 6372
+    pid = run_wabur(port)
+    client = WAB::Client.new('localhost', port)
+    t = Time.now
+    uuid = WAB::UUID.new('b0ca922d-372e-41f4-8fea-47d880188ba3')
+    uri = URI("http://wab.systems/sample")
+    obj = {
+      kind: 'Test',
+      num: 123,
+      bool: true,
+      null: nil,
+      str: "string",
+      dub: 1.23,
+      time: t,
+      uuid: uuid,
+      uri: uri
+    }
+    result = client.create(obj)
+    assert_equal(0, result[:code], 'create result code mismatch')
+    ref = result[:ref]
+
+    result = client.read('Test', ref)
+    assert_equal(0, result[:code], 'read result code mismatch')
+    assert_equal(1, result[:results].length, 'read result wrong length')
+    rec = result[:results][0]
+    assert_equal('Test', rec[:data][:kind], 'read kind mismatch')
+    assert_equal(obj, rec[:data], 'read data mismatch')
+
+    result = client.delete('Test', ref)
+    assert_equal(0, result[:code], 'delete result code mismatch')
+    assert_equal([ref], result[:deleted], 'delete list mismatch')
+
+    ensure
+    shutdown_wabur(pid)
+  end
+
+  def test_create_query
+    port = 6373
+    pid = run_wabur(port)
+    client = WAB::Client.new('localhost', port)
+
+    result = client.create({kind: 'Test', value: 123}, 'Test', {value: 123})
+    assert_equal(0, result[:code], 'create result code mismatch')
+    ref = result[:ref]
+
+    result = client.read('Test', ref)
+    assert_equal(0, result[:code], 'read result code mismatch')
+    assert_equal(1, result[:results].length, 'read result wrong length')
+
+    # Same again should fail.
+    assert_raises('should fail to create a duplicate') {
+      result = client.create({kind: 'Test', value: 123}, 'Test', {value: 123})
+    }
+
+    result = client.delete('Test', ref)
+    assert_equal(0, result[:code], 'delete result code mismatch')
+    assert_equal([ref], result[:deleted], 'delete list mismatch')
+
+    ensure
+    shutdown_wabur(pid)
+  end
+
+  def test_delete_all
+    port = 6374
+    pid = run_wabur(port)
+    client = WAB::Client.new('localhost', port)
+    refs = []
+    3.times { |i|
+      result = client.create({kind: 'Test', value: i})
+      assert_equal(0, result[:code], "create #{i} result code mismatch")
+      refs << result[:ref]
+    }
+
+    result = client.read('Test')
+    assert_equal(0, result[:code], 'read result code mismatch')
+    assert_equal(3, result[:results].length, 'read result wrong length')
+
+    result = client.delete('Test')
+    assert_equal(0, result[:code], 'delete result code mismatch')
+    assert_equal(3, result[:deleted].length, 'delete list length mismatch')
+
+    ensure
+    shutdown_wabur(pid)
+  end
+
+  def test_update_ref
+    port = 6375
+    pid = run_wabur(port)
+    client = WAB::Client.new('localhost', port)
+
+    result = client.create({kind: 'Test', value: 123})
+    assert_equal(0, result[:code], 'create result code mismatch')
+    ref = result[:ref]
+
+    result = client.update('Test', {kind: 'Test', value: 321}, ref)
+    assert_equal(0, result[:code], 'create result code mismatch')
+    
+    result = client.read('Test', ref)
+    assert_equal(0, result[:code], 'read result code mismatch')
+    assert_equal(1, result[:results].length, 'read result wrong length')
+    rec = result[:results][0]
+    assert_equal('Test', rec[:data][:kind], 'read kind mismatch')
+    assert_equal(321, rec[:data][:value], 'read value mismatch')
+
+    result = client.delete('Test', ref)
+    assert_equal(0, result[:code], 'delete result code mismatch')
+    assert_equal([ref], result[:deleted], 'delete list mismatch')
+
+    ensure
+    shutdown_wabur(pid)
+  end
+
+  def test_update_query
+    port = 6376
+    pid = run_wabur(port)
+    client = WAB::Client.new('localhost', port)
+    refs = []
+    3.times { |i|
+      result = client.create({kind: 'Test', value: i})
+      assert_equal(0, result[:code], "create #{i} result code mismatch")
+      refs << result[:ref]
+    }
+
+    result = client.update('Test', {kind: 'Test', value: 111}, {value: 1})
+    assert_equal(0, result[:code], 'create result code mismatch')
+    assert_equal(1, result[:updated].length, 'updated wrong length')
+
+    result = client.read('Test', refs[1])
+    assert_equal(0, result[:code], 'read result code mismatch')
+    assert_equal(1, result[:results].length, 'read result wrong length')
+    rec = result[:results][0]
+    assert_equal('Test', rec[:data][:kind], 'read kind mismatch')
+    assert_equal(111, rec[:data][:value], 'read value mismatch')
+
+    result = client.delete('Test')
+    assert_equal(0, result[:code], 'delete result code mismatch')
+
+    ensure
+    shutdown_wabur(pid)
+  end
+
+  def test_delete_query
+    port = 6377
+    pid = run_wabur(port)
+    client = WAB::Client.new('localhost', port)
+    refs = []
+    3.times { |i|
+      result = client.create({kind: 'Test', value: i})
+      assert_equal(0, result[:code], "create #{i} result code mismatch")
+      refs << result[:ref]
+    }
+
+    result = client.delete('Test', {value: 1})
+    assert_equal(0, result[:code], 'create result code mismatch')
+    assert_equal(1, result[:deleted].length, 'updated wrong length')
+
+    result = client.read('Test')
+    assert_equal(0, result[:code], 'read result code mismatch')
+    assert_equal(2, result[:results].length, 'read result wrong length')
+
+    result = client.delete('Test')
+    assert_equal(0, result[:code], 'delete result code mismatch')
+
+    ensure
+    shutdown_wabur(pid)
+  end
+
+  def test_read_query
+    port = 6378
+    pid = run_wabur(port)
+    client = WAB::Client.new('localhost', port)
+    3.times { |i|
+      result = client.create({kind: 'Test', value: i})
+      assert_equal(0, result[:code], "create #{i} result code mismatch")
+    }
+
+    result = client.read('Test', {value: 1})
+    assert_equal(0, result[:code], 'read result code mismatch')
+    assert_equal(1, result[:results].length, 'read wrong length')
+
+    result = client.delete('Test')
+    assert_equal(0, result[:code], 'delete result code mismatch')
+
+    ensure
+    shutdown_wabur(pid)
+  end
+
+  def test_tql
+    port = 6379
+    pid = run_wabur(port)
+    client = WAB::Client.new('localhost', port)
+    3.times { |i|
+      result = client.create({kind: 'Test', value: i})
+      assert_equal(0, result[:code], "create #{i} result code mismatch")
+    }
+
+    result = client.find({
+                           where: ['LT', 'value', 2],
+                           select: '$ref'
+                         })
+
+    assert_equal(0, result[:code], 'read result code mismatch')
+    assert_equal(2, result[:results].length, 'results wrong length')
+
+    result = client.delete('Test')
+    assert_equal(0, result[:code], 'delete result code mismatch')
+
+    ensure
+    shutdown_wabur(pid)
+  end
+
+end
+