wabur 0.6.2 → 0.7.0

data/lib/wab/impl/sinatra.rb

@@ -0,0 +1,18 @@
+
+require 'wab'
+
+module WAB
+  module Impl
+
+    # The Sinatra module contains handlers for the Sinatra web server.
+    module Sinatra
+
+    end # Sinatra
+  end # Impl
+end # WAB
+
+require 'wab/impl/sinatra/sender'
+require 'wab/impl/sinatra/handler'
+require 'wab/impl/sinatra/tql_handler'
+require 'wab/impl/sinatra/export_proxy'
+require 'wab/impl/sinatra/server'

data/lib/wab/impl/sinatra/export_proxy.rb

@@ -0,0 +1,57 @@
+
+module WAB
+  module Impl
+    module Sinatra
+
+      # A handler that provides missing files in an assets directory where the
+      # files are the wab and wab UI files.
+      class ExportProxy
+	include Sender
+
+	def initialize(shell)
+          @shell = shell
+	end
+
+	def call(req)
+	  path = (req.script_name + req.path_info)
+	  query = parse_query(req.query_string)
+          path = '/index.html' if '/' == path
+          mime = nil
+          index = path.rindex('.')
+          unless index.nil?
+	    mime = {
+	      'css' => 'text/css',
+	      'eot' => 'application/vnd.ms-fontobject',
+	      'es5' => 'application/javascript',
+	      'es6' => 'application/javascript',
+	      'gif' => 'image/gif',
+	      'html' => 'text/html',
+	      'ico' => 'image/x-icon',
+	      'jpeg' => 'image/jpeg',
+	      'jpg' => 'image/jpeg',
+	      'js' => 'application/javascript',
+	      'json' => 'application/json',
+	      'png' => 'image/png',
+	      'sse' => 'text/plain',
+	      'svg' => 'image/svg+xml',
+	      'ttf' => 'application/font-sfnt',
+	      'txt' => 'text/plain',
+	      'woff' => 'application/font-woff',
+	      'woff2' => 'font/woff2',
+	    }[path[index + 1..-1].downcase]
+          end
+          mime = 'text/plain' if mime.nil?
+          content = WAB.get_export(path)
+	  [
+	    200,
+            {'Content-Type' => mime},
+	    [content]
+	  ]
+        rescue Exception => e
+          send_error(e, res)
+        end
+	
+      end # ExportProxy
+    end # Sinatra
+  end # Impl
+end # WAB

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

@@ -0,0 +1,50 @@
+
+module WAB
+  module Impl
+    module Sinatra
+      
+      # 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 wab_call(req)
+	  path = (req.script_name + req.path_info).split('/')[1..-1]
+	  query = parse_query(req.query_string)
+          body = nil
+          unless req.body.nil?
+	    content = req.body.read
+	    unless content.empty?
+              body = Data.new(Oj.strict_load(content, 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), path, query)
+	  when 'PUT'
+	    @shell.log_call(@controller, 'create', path, query, body)
+            send_result(@controller.create(path, query, body), path, query)
+	  when 'POST'
+	    @shell.log_call(@controller, 'update', path, query, body)
+            send_result(@controller.update(path, query, body), path, query)
+	  when 'DELETE'
+	    @shell.log_call(@controller, 'delete', path, query)
+            send_result(@controller.delete(path, query), path, query)
+	  else
+	    raise StandardError.new("#{method} is not a supported method") if op.nil?
+	  end
+	rescue StandardError => e
+	  send_error(e)
+	end
+
+      end # Handler
+    end # Sinatra
+  end # Impl
+end # WAB

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

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

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

@@ -0,0 +1,66 @@
+
+require 'sinatra/base'
+
+module WAB
+  module Impl
+    module Sinatra
+
+      # The Server module provides a server start method.
+      class Server < ::Sinatra::Application
+
+	# Start the server and set the mount points.
+	def self.start(shell)
+	  set(:port, shell.http_port)
+	  set(:public_folder, 'public')
+	  set(:public_folder, File.expand_path(shell.http_dir))
+	  set(:static, true)
+	  set(:logging, shell.logger.info?)
+
+          shell.mounts.each { |hh|
+	    if hh.has_key?(:type)
+	      handler = WAB::Impl::Sinatra::Handler.new(shell, shell.create_controller(hh[:handler]))
+	      path = "#{shell.pre_path}/#{hh[:type]}"
+
+	      get(path) { handler.wab_call(request) }
+	      get(path+'/*') { handler.wab_call(request) }
+
+	      put(path) { handler.wab_call(request) }
+	      put(path+'/*') { handler.wab_call(request) }
+
+	      post(path) { handler.wab_call(request) }
+	      post(path+'/*') { handler.wab_call(request) }
+
+	      delete(path) { handler.wab_call(request) }
+	      delete(path+'/*') { handler.wab_call(request) }
+
+	    elsif hh.has_key?(:path)
+	      path = hh[:path]
+	      if path.empty?
+		path = '/**'
+	      elsif  '*' != path[-1]
+		path << '/' unless '/' == path[-1]
+		path << '**'
+	      end
+	      controller = shell.create_controller(hh[:handler])
+	      post(path) { controller.call(request.env) }
+	    else
+              raise WAB::Error.new("Invalid handle configuration. Missing path or type.")
+	    end
+	  }
+	  unless (shell.tql_path.nil? || shell.tql_path.empty?)
+	    tql_handler = WAB::Impl::Sinatra::TqlHandler.new(shell)
+	    post('/tql') { tql_handler.call(request) }
+	  end
+	  if shell.export_proxy
+            exporter = WAB::Impl::Sinatra::ExportProxy.new(shell)
+	    get('/**') { exporter.call(request) }
+	  end
+
+          trap 'INT' do server.shutdown end
+	  run!
+	end
+
+      end # Server
+    end # Sinatra
+  end # Impl
+end # WAB

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

@@ -0,0 +1,35 @@
+
+module WAB
+  module Impl
+    module Sinatra
+
+      # 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 call(req)
+	  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), 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 # Sinatra
+  end # Impl
+end # WAB

data/lib/wab/impl/templates/wabur.conf.template

@@ -33,7 +33,7 @@ export_proxy = true
 # JSON sent as a response to View requests.
 indent = 0
 
-# Handlers for each type of record and for the UI shich are Ruby generated UI
+# Handlers for each type of record and for the UI which are Ruby generated UI
 # configuration records.
 handler.0.type = ui
 handler.0.handler = UIController%{handlers}

data/lib/wab/impl/webrick.rb

@@ -0,0 +1,18 @@
+
+require 'wab'
+
+module WAB
+  module Impl
+
+    # The WEBrick module contains handlers for the WEBrick web server.
+    module WEBrick
+
+    end # WEBrick
+  end # Impl
+end # WAB
+
+require 'wab/impl/webrick/export_proxy'
+require 'wab/impl/webrick/sender'
+require 'wab/impl/webrick/handler'
+require 'wab/impl/webrick/tql_handler'
+require 'wab/impl/webrick/server'

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

@@ -0,0 +1,41 @@
+
+require 'webrick'
+
+module WAB
+  module Impl
+    module WEBrick
+
+      # A handler that provides missing files in an assets directory where the
+      # files are the wab and wab UI files.
+      class ExportProxy < ::WEBrick::HTTPServlet::FileHandler
+
+	def initialize(server, path)
+          super
+	end
+
+	def do_GET(req, res)
+          super
+	rescue Exception => e
+          path = req.path
+          path = '/index.html' if '/' == path
+          begin
+            mime = nil
+            index = path.rindex('.')
+            unless index.nil?
+              mime = WEBrick::HTTPUtils::DefaultMimeTypes[path[index + 1..-1]]
+            end
+            mime = 'text/plain' if mime.nil?
+            content = WAB.get_export(path)
+            res.status = 200
+            res['Content-Type'] = mime
+            res.body = content
+          rescue Exception
+            # raise the original error for a normal not found error
+            raise e
+          end
+	end
+	
+      end # ExportProxy
+    end # WEBrick
+  end # Impl
+end # WAB

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

@@ -0,0 +1,116 @@
+
+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 Handler < ::WEBrick::HTTPServlet::AbstractServlet
+	include Sender
+	
+	def initialize(server, shell, controller, is_rack)
+          super(server)
+          @shell = shell
+	  @controller = controller
+	  @is_rack = is_rack
+	end
+
+	def service(req, res)
+	  if @is_rack
+	    rack_call(req, res)
+	  else
+            path, query, body = extract_path_query(req)
+	    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
+	  end
+	rescue StandardError => e
+          send_error(e, res)
+	end
+
+	private
+
+	def rack_call(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' => WAB::Impl::RackError.new(@shell),
+	    'rack.multithread' => false,
+	    'rack.multiprocess' => false,
+	    'rack.run_once' => false,
+	  }
+	  path = req.script_name + req.path_info
+	  
+	  @shell.log_call(@controller, 'call', path, req.query_string, req.body)
+	  req.each { |k| env['HTTP_' + k] = req[k] }
+	  env['rack.input'] = StringIO.new(req.body) unless req.body.nil?
+	  rres = @controller.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}#{req.query_string}: #{res.body}") if @shell.logger.debug?
+	rescue StandardError => e
+          send_error(e, res)
+	end
+
+	# Pulls and converts the request path, query, and body.
+	def extract_path_query(req)
+          path = req.path.split('/')[1..-1]
+          query = {}
+          if !req.query_string.nil? && !req.query_string.empty? && req.query.empty?
+            # WEBRick does not parse queries on PUT and some others so do it
+            # manually.
+            req.query_string.split('&').each { |opt|
+              k, v = opt.split('=')
+              # TBD convert %xx to char
+              query[k] = v
+            }
+          else
+            req.query.each { |k,v| query[k.to_sym] = 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
+          }
+          request_body = req.body
+          if request_body.nil?
+            body = nil
+          else
+            body = Data.new(
+              Oj.strict_load(request_body, symbol_keys: true)
+            )
+            body.detect
+          end
+          [path, query, body]
+	end
+
+      end # Handler
+    end # WEBrick
+  end # Impl
+end # WAB