wabur 0.6.2 → 0.7.0

data/lib/wab/impl/agoo/handler.rb

@@ -0,0 +1,51 @@
+
+module WAB
+  module Impl
+    module Agoo
+      
+      # Handler for requests that fall under the path assigned to the
+      # Controller. This is used only with the WAB::Impl::Shell.
+      class Handler
+	include Sender
+	
+	def initialize(shell, controller)
+          @shell = shell
+	  @controller = controller
+	end
+
+	def on_request(req, res)
+	  path = (req.script_name + req.path_info).split('/')[1..-1]
+	  query = parse_query(req.query_string)
+          body = req.body
+          unless body.nil?
+	    if body.empty?
+	      body = nil
+	    else
+              body = Data.new(Oj.strict_load(body, symbol_keys: true))
+              body.detect
+	    end
+          end
+	  case req.request_method
+	  when 'GET'
+	    @shell.log_call(@controller, 'read', path, query)
+            send_result(@controller.read(path, query), res, path, query)
+	  when 'PUT'
+	    @shell.log_call(@controller, 'create', path, query, body)
+            send_result(@controller.create(path, query, body), res, path, query)
+	  when 'POST'
+	    @shell.log_call(@controller, 'update', path, query, body)
+            send_result(@controller.update(path, query, body), res, path, query)
+	  when 'DELETE'
+	    @shell.log_call(@controller, 'delete', path, query)
+            send_result(@controller.delete(path, query), res, path, query)
+	  else
+	    raise StandardError.new("#{method} is not a supported method") if op.nil?
+	  end
+	rescue StandardError => e
+          send_error(e, res)
+	end
+
+      end # Handler
+    end # Agoo
+  end # Impl
+end # WAB

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

@@ -0,0 +1,50 @@
+
+module WAB
+  module Impl
+    module Agoo
+
+      # 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.code = 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.code = 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
+
+	# Parses a query string into a Hash.
+	def parse_query(query_string)
+	  query = {}
+          if !query_string.nil? && !query_string.empty?
+            query_string.split('&').each { |opt|
+              k, v = opt.split('=')
+              # TBD convert %xx to char
+              query[k] = v
+            }
+          end
+          # Detect numbers (others later)
+          query.each_pair { |k,v|
+            i = Utils.attempt_key_to_int(v)
+            query[k] = i unless i.nil?
+            # TBD how about float
+          }
+	end
+	
+      end # Sender
+    end # Agoo
+  end # Impl
+end # WAB

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

@@ -0,0 +1,59 @@
+
+require 'agoo'
+
+module WAB
+  module Impl
+    module Agoo
+
+      # The Server module provides a server start method.
+      module Server
+
+	# Start the server and set the mount points.
+	def self.start(shell)
+	  options = {
+	    pedantic: false,
+	    log_dir: '',
+	    thread_count: 0,
+	    log_console: true,
+	    log_classic: true,
+	    log_colorize: true,
+	    log_states: {
+	      INFO: shell.logger.info?,
+	      DEBUG: shell.logger.debug?,
+	      connect: shell.logger.info?,
+	      request: shell.logger.info?,
+	      response: shell.logger.info?,
+	      eval: shell.logger.info?,
+	    }
+	  }
+	  server = ::Agoo::Server.new(shell.http_port, shell.http_dir, options)
+	  
+          shell.mounts.each { |hh|
+	    if hh.has_key?(:type)
+	      handler = WAB::Impl::Agoo::Handler.new(shell, shell.create_controller(hh[:handler]))
+              server.handle(nil, "#{shell.pre_path}/#{hh[:type]}", handler)
+              server.handle(nil, "#{shell.pre_path}/#{hh[:type]}/*", handler)
+	    elsif hh.has_key?(:path)
+	      path = hh[:path]
+	      if path.empty?
+		path = '/**'
+	      elsif  '*' != path[-1]
+		path << '/' unless '/' == path[-1]
+		path << '**'
+	      end
+              server.handle(:POST, path, shell.create_controller(hh[:handler]))
+	    else
+              raise WAB::Error.new("Invalid handle configuration. Missing path or type.")
+	    end
+	  }
+          server.handle(:POST, shell.tql_path, WAB::Impl::Agoo::TqlHandler.new(shell)) unless (shell.tql_path.nil? || shell.tql_path.empty?)
+          server.handle_not_found(WAB::Impl::Agoo::ExportProxy.new(shell)) if shell.export_proxy
+
+          trap 'INT' do server.shutdown end
+          server.start
+	end
+
+      end # Server
+    end # Agoo
+  end # Impl
+end # WAB

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

@@ -0,0 +1,35 @@
+
+module WAB
+  module Impl
+    module Agoo
+
+      # Handler for requests that fall under the path assigned to the
+      # Controller. This is used only with the WAB::Impl::Shell.
+      class TqlHandler
+	include Sender
+
+	def initialize(shell)
+          @shell = shell
+	end
+
+	def on_request(req, res)
+	  path = (req.script_name + req.path_info).split('/')[1..-1]
+	  query = parse_query(req.query_string)
+          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
+
+      end # TqlHandler
+    end # Agoo
+  end # Impl
+end # WAB

data/lib/wab/impl/model.rb

@@ -114,11 +114,18 @@ module WAB
         result
       end
 
-      def update(obj, _rid, where, _filter)
+      def update(obj, _rid, where, filter)
         updated = []
         @lock.synchronize {
           if where.is_a?(Expr)
             # TBD must be able to update portions of an object
+            @map.each_pair { |ref, v|
+              if where.eval(v) && (filter.nil? || filter.eval(v))
+                @map[ref] = Data.new(obj, true)
+                updated << ref
+                write_to_file(ref, obj)
+              end
+            }
           else
             # A reference.
             @map[where] = Data.new(obj, true)

data/lib/wab/impl/rack_error.rb

@@ -0,0 +1,27 @@
+
+module WAB
+  module Impl
+
+    # The RackError class is a logger that is used in the Rack env in a
+    # request. It uses the shell logger to log errors.
+    class RackError
+
+      # Create a new instance.
+      def initialize(shell)
+	@shell = shell
+      end
+
+      def puts(message)
+	@shell.logger.error(message).to_s
+      end
+
+      def write(message)
+	@shell.logger.error(message)
+      end
+
+      def flush
+      end
+      
+    end # RackError
+  end # Impl
+end # WAB

data/lib/wab/impl/rack_handler.rb

@@ -0,0 +1,69 @@
+
+require 'webrick'
+
+module WAB
+  module Impl
+
+    # Handler for requests that fall under the path assigned to the rack
+    # Controller. This is used only with the WAB::Impl::Shell.
+    class RackHandler < WEBrick::HTTPServlet::AbstractServlet
+
+      def initialize(server, shell, handler)
+        super(server)
+        @shell = shell
+        case handler
+        when String
+          handler = Object.const_get(handler).new(self)
+        when Class
+          handler = handler.new(self)
+        end
+        handler.shell = self
+	@handler = handler
+      end
+
+      def service(req, res)
+	env = {
+	  'REQUEST_METHOD' => req.request_method,
+	  'SCRIPT_NAME' => req.script_name,
+	  'PATH_INFO' => req.path_info,
+	  'QUERY_STRING' => req.query_string,
+	  'SERVER_NAME' => req.server_name,
+	  'SERVER_PORT' => req.port,
+	  'rack.version' => '1.2',
+	  'rack.url_scheme' => req.ssl? ? 'https' : 'http',
+	  'rack.errors' => '', ## TBD
+	  'rack.multithread' => false,
+	  'rack.multiprocess' => false,
+	  'rack.run_once' => false,
+	}
+	req.each { |k| env['HTTP_' + k] = req[k] }
+	unless req.body.nil?
+	  env['rack.input'] = StringIO.new(req.body)
+	end
+	rres = @handler.call(env)
+        res.status = rres[0]
+	rres[1].each { |a| res[a[0]] = a[1] }
+	unless rres[2].empty?
+	  res.body = ''
+	  rres[2].each { |s| res.body << s }
+	end
+        @shell.logger.debug("reply to #{path.join('/')}#{query}: #{res.body}") if @shell.logger.debug?
+      rescue StandardError => e
+        send_error(e, res)
+      end
+
+      private
+
+      # 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 # RackHandler
+  end # Impl
+end # WAB

data/lib/wab/impl/shell.rb

@@ -1,5 +1,4 @@
 
-require 'wab/impl/handler'
 require 'wab/impl/model'
 
 module WAB
@@ -13,6 +12,12 @@ module WAB
       # Returns the path where a data type is located. The default is 'kind'.
       attr_reader :type_key
       attr_reader :path_pos
+      attr_reader :pre_path
+      attr_reader :mounts
+      attr_reader :http_dir
+      attr_reader :http_port
+      attr_reader :tql_path
+      attr_reader :export_proxy
 
       attr_accessor :indent
       
@@ -26,6 +31,7 @@ module WAB
         @indent       = config[:indent].to_i || 0
         @pre_path     = config[:path_prefix] || '/v1'
         @path_pos     = @pre_path.split('/').length - 1
+        @tql_path     = config[:tql_path] || '/tql'
         base          = config[:base] || '.'
         @model        = Model.new((config['store.dir'] || File.join(base, 'data')).gsub('$BASE', base), indent)
         @type_key     = config[:type_key] || 'kind'
@@ -36,7 +42,8 @@ module WAB
         @export_proxy = config[:export_proxy]
         @export_proxy = true if @export_proxy.nil? # The default is true if not present.
         @controllers  = {}
-
+        @mounts       = config[:handler] || []
+	@server       = config['http.server'].to_s.downcase
         requires      = config[:require]
         case requires
         when Array
@@ -44,26 +51,22 @@ module WAB
         when String
           requires.split(',').each { |r| require r.strip }
         end
-
-        if config[:handler].is_a?(Array)
-          config[:handler].each { |hh| register_controller(hh[:type], hh[:handler]) }
-        end
       end
 
       # Start listening. This should be called after registering Controllers
       # with the Shell.
-      def start()
-        mime_types = WEBrick::HTTPUtils::DefaultMimeTypes
-        mime_types['es6'] = 'application/javascript'
-        server = WEBrick::HTTPServer.new(Port: @http_port,
-                                         DocumentRoot: @http_dir,
-                                         MimeTypes: mime_types)
-        server.logger.level = 5 - @logger.level unless @logger.nil?
-        server.mount(@pre_path, Handler, self)
-        server.mount('/', ExportProxy, @http_dir) if @export_proxy
-
-        trap 'INT' do server.shutdown end
-        server.start
+      def start
+	case @server
+	when 'agoo'
+	  require 'wab/impl/agoo'
+	  WAB::Impl::Agoo::Server::start(self)
+	when 'sinatra'
+	  require 'wab/impl/sinatra'
+	   WAB::Impl::Sinatra::Server::start(self)
+	else
+	  require 'wab/impl/webrick'
+	  WAB::Impl::WEBrick::Server::start(self)
+	end
       end
 
       # Register a controller for a named type.
@@ -76,37 +79,7 @@ module WAB
       #              identified +type+. This can be a Controller, a Controller
       #              class, or a Controller class name.
       def register_controller(type, controller)
-        case controller
-        when String
-          controller = Object.const_get(controller).new(self)
-        when Class
-          controller = controller.new(self)
-        end
-        controller.shell = self
-        @controllers[type] = controller
-      end
-
-      # Returns the controller associated with the type key found in the
-      # data. If a controller has not be registered under that key the default
-      # controller is returned if there is one.
-      #
-      # data:: data to extract the type from for lookup in the controllers
-      def controller(data)
-        path = data.get(:path)
-        path = path.native if path.is_a?(WAB::Data)
-        return path_controller(path) unless path.nil? || (path.length <= @path_pos)
-
-        content = data.get(:content)
-        return @controllers[content.get(@type_key)] || default_controller unless content.nil?
-
-        default_controller
-      end
-
-      # Returns the controller according to the type in the path.
-      #
-      # path: path Array such as from a URL
-      def path_controller(path)
-        @controllers[path[@path_pos]] || default_controller
+	@mount << { type: type, handler: controller }
       end
 
       # Create and return a new data instance with the provided initial value.
@@ -124,10 +97,42 @@ module WAB
         Data.new(value, repair)
       end
 
+      # Helper function that creates a controller instance given either a
+      # class name, a class, or an already created object.
+      def create_controller(controller)
+        case controller
+        when String
+          controller = Object.const_get(controller).new(self)
+        when Class
+          controller = controller.new(self)
+        end
+        controller.shell = self
+        controller
+      end
+
+      def log_call(controller, op, path, query, body=nil)
+	if @logger.debug?
+	  if body.nil?
+	    @logger.debug("#{controller.class}.#{op}(#{path_to_s(path)}#{query})")
+	  else
+	    body = body.json(@indent) unless body.is_a?(String)
+	    @logger.debug("#{controller.class}.#{op}(#{path_to_s(path)}#{query})\n#{body}")
+	  end
+	elsif @logger.info?
+	  @logger.info("#{controller.class}.#{op}(#{path_to_s(path)}#{query})") if @logger.info?
+	end
+      end
+
       private
 
-      def default_controller
-        @default_controller ||= @controllers[nil]
+      def path_to_s(path)
+	if path.is_a?(String)
+	  path
+	elsif path.is_a?(Array)
+	  path.join('/')
+	else
+	  path.to_s
+	end
       end
 
     end # Shell