wabur 0.2.0d1 → 0.4.0d1

data/lib/wab/io/engine.rb

@@ -1,8 +1,7 @@
 
-require 'wab'
+require 'oj'
 
 module WAB
-
   module IO
 
     class Engine
@@ -15,26 +14,35 @@ module WAB
         @shell = shell
         @last_rid = 0
         @pending = {}
-        @lock = Thread::Mutex.new()
-        @queue = Queue.new()
+        @lock = Thread::Mutex.new
+        @queue = Queue.new
         tcnt = 1 if 0 >= tcnt
         @tcnt = tcnt
+        @timeout_thread = nil
       end
 
       def start()
+        proc_threads = []
         @tcnt.times {
-          Thread.new {
-            process_msg(@queue.pop)
+          proc_threads << Thread.new {
+            while true
+              begin
+                break unless process_msg(@queue.pop)
+              rescue Exception => e
+                $stderr.puts %|*-*-* #{e.class}: #{e.message}\n#{e.backtrace.join("\n  ")}|
+              end
+            end
           }
         }
+        @timeout_thread = Thread.new { timeout_check }
 
-        # TBD create timeout thread, sync on lock to check timeout in pending, sleep for .5
-
-        Oj.strict_load($stdin, symbol_keys: true) { |msg|
+        Oj.load($stdin, mode: :wab, symbol_keys: true) { |msg|
           api = msg[:api]
-          if 1 == api
+          @shell.info("=> controller #{Oj.dump(msg, mode: :wab)}") if @shell.info?
+          case api
+          when 1
             @queue.push(msg)
-          elsif 4 == api
+          when 4
             rid = msg[:rid]
             call = nil
             @lock.synchronize {
@@ -44,73 +52,142 @@ module WAB
               call.result = msg[:body]
               call.thread.run
             end
+          when -2, -3, -6, -15
+            shutdown(msg)
+            break
+          when -9
+            Thread.kill(@timeout_thread)
+            proc_threads.each { |t| Thread.kill(t) }
+            Process.exit(0)
           else
-            # TBD handle error
+            $stderr.puts "*-*-* Invalid api value (#{api}) in message."
           end
         }
       end
 
+      def shutdown(msg)
+        # TBD kill timeout thread
+        Thread.kill(@timeout_thread)
+        # tell processing threads to shutdown.
+        @tcnt.times { @queue.push(msg) }
+      end
 
       # Send request to the model portion of the system.
       #
       # tql:: the body of the message which should be JSON-TQL as a native Hash
-      def request(tql)
-        call = Call.new() # TBD make timeout seconds a parameter
+      def request(tql, timeout)
+        call = Call.new(timeout)
+
         @lock.synchronize {
           @last_rid += 1
           call.rid = @last_rid.to_s
           @pending[call.rid] = call
         }
-        data = @shell.data({ rid: call.rid, api: 3, body: tql }, true)
+
+        msg = {rid: call.rid, api: 3, body: tql}
+        @shell.info("=> model: #{Oj.dump(msg, mode: :wab)}") if @shell.info?
+        data = @shell.data(msg, true)
         # Send the message. Make sure to flush to assure it gets sent.
-        $stdout.puts(data.json())
-        $stdout.flush()
-        
+        $stdout.puts(data.json)
+        $stdout.flush
+
         # Wait for either the response to arrive or for a timeout. In both
-        # cases #run should be called on the thread.
-        Thread.stop
+        # cases #run should be called on the thread. Sleep is used instead of
+        # stop to avoid a race condition where a response arrives before the
+        # thread is stopped.
+        sleep(0.1) while call.result.nil?
         call.result
       end
 
+      def send_error(rid, msg, bt=nil)
+        body = { code: -1, error: msg }
+        body[:backtrace] = bt unless bt.nil?
+        $stdout.puts(@shell.data({rid: rid, api: 2, body: body}).json)
+        $stdout.flush
+        true
+      end
+
+      # return false to exit loop
       def process_msg(native)
+        # exit loop if an interrupt (api less than 0)
+        return false if native[:api] < 0
+
         rid = native[:rid]
-        api = native[:api]
         body = native[:body]
-        reply = @shell.data({rid: rid, api: 2})
-        if body.nil?
-          reply.set('body.code', -1)
-          reply.set('body.error', 'No body in request.')
-        else
-          data = @shell.data(body, false)
-          data.detect()
-          controller = @shell.controller(data)
-          if controller.nil?
-            reply.set('body.code', -1)
-            reply.set('body.error', 'No handler found.')
+        return send_error(rid, 'No body in request.') if body.nil?
+
+        data = @shell.data(body, false)
+        data.detect
+        controller = @shell.controller(data)
+        return send_error(rid, 'No handler found.') if controller.nil?
+
+        reply_body = nil
+        op = body[:op]
+        path = body[:path]
+        query = body[:query]
+        begin
+          if 'NEW' == op && controller.respond_to?(:create)
+            log_operation_with_body('controller.create', path, query, body) if @shell.info?
+            reply_body = controller.create(path, query, data.get(:content))
+          elsif 'GET' == op && controller.respond_to?(:read)
+            log_operation('controller.read', path, query) if @shell.info?
+            reply_body = controller.read(path, query)
+          elsif 'DEL' == op && controller.respond_to?(:delete)
+            log_operation('controller.delete', path, query) if @shell.info?
+            reply_body = controller.delete(path, query)
+          elsif 'MOD' == op && controller.respond_to?(:update)
+            log_operation_with_body('controller.update', path, query, body) if @shell.info?
+            reply_body = controller.update(path, query, data.get(:content))
           else
-            op = body[:op]
-            begin
-              if 'NEW' == op && controller.respond_to?(:create)
-                reply.set('body', controller.create(body[:path], body[:query], data.get(:content)))
-              elsif 'GET' == op && controller.respond_to?(:read)
-                reply.set('body', controller.read(body[:path], body[:query]))
-              elsif 'DEL' == op && controller.respond_to?(:delete)
-                reply.set('body', controller.delete(body[:path], body[:query]))
-              elsif 'MOD' == op && controller.respond_to?(:update)
-                # Also used for TQL queries
-                reply.set('body', controller.update(body[:path], body[:query], data.get(:content)))
+            reply_body = controller.handle(data)
+          end
+        rescue Exception => e
+          return send_error(rid, "#{e.class}: #{e.message}", e.backtrace)
+        end
+        # If reply_body is nil then it is async.
+        unless reply_body.nil?
+          reply_body = reply_body.native if reply_body.is_a?(WAB::Data)
+          msg = {rid: rid, api: 2, body: reply_body}
+          @shell.info("=> view: #{Oj.dump(msg, mode: :wab)}") if @shell.info?
+          $stdout.puts(@shell.data(msg).json)
+          $stdout.flush
+        end
+        true
+      end
+
+      def timeout_check()
+        while true
+          sleep(0.5)
+          timed_out = []
+          now = Time.now
+          @lock.synchronize {
+            @pending.delete_if { |_rid,call|
+              if call.giveup <= now
+                timed_out << call
+                true
               else
-                reply.set('body', controller.handle(data))
+                false
               end
-            rescue Exception => e
-              reply.set('body.code', -1)
-              reply.set('body.error', e.message)
-              reply.set('body.backtrace', e.backtrace)
+            }
+          }
+          timed_out.each { |call|
+            body = { code: -1, error: "Timed out waiting for #{call.rid}." }
+            unless call.nil?
+              call.result = body
+              call.thread.run
             end
-          end
+          }
         end
-        $stdout.puts(reply.json)
-        $stdout.flush
+      end
+
+      private
+
+      def log_operation(caller, path, query)
+        @shell.info("=> #{caller}(#{path.join('/')}#{query})")
+      end
+
+      def log_operation_with_body(caller, path, query, body)
+        @shell.info("=> #{caller}(#{path.join('/')}#{query}, #{Oj.dump(body[:content], mode: :wab)})")
       end
 
     end # Engine

data/lib/wab/io/shell.rb

@@ -1,35 +1,76 @@
 
 require 'time'
-require 'wab'
+require 'wab/impl'
 
 module WAB
-
   module IO
 
     # A Shell that uses STDIN and STDOUT for all interactions with the View
     # and Model. Since the View and Model APIs are asynchronous and Controller
     # calls are synchronous for simplicity some effort is required to block
     # where needed to achieve the difference in behavior.
-    class Shell < ::WAB::Shell
+    class Shell
+      include WAB::ShellLogger
 
       attr_reader :path_pos
       attr_reader :type_key
-      
+      attr_accessor :timeout
+
       # Sets up the shell with the designated number of processing threads and
       # the type_key.
       #
       # tcnt:: processing thread count
       # type_key:: key to use for the record type
       def initialize(tcnt, type_key='kind', path_pos=0)
-        super(type_key, path_pos)
+        @controllers = {}
+        @type_key = type_key
+        @path_pos = path_pos
         @engine = Engine.new(self, tcnt)
+        @timeout = 2.0
+        @logger = Logger.new(STDERR)
+        logger.level = Logger::WARN
       end
 
       # Starts listening and processing.
       def start()
-        @engine.start()
+        @engine.start
+      end
+
+      # Register a controller for a named type.
+      #
+      # If a request is received for an unregistered type the default controller
+      # will be used. The default controller is registered with a +nil+ key.
+      #
+      # type:: type name
+      # controller:: Controller instance for handling requests for the identified +type+
+      def register_controller(type, controller)
+        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)] || @controllers[nil] unless content.nil?
+
+        @controllers[nil]
+      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]] || @controllers[nil]
       end
-      
+
       # Create and return a new data instance with the provided initial value.
       # The value must be a Hash or Array. The members of the Hash or Array
       # must be nil, boolean, String, Integer, Float, BigDecimal, Array, Hash,
@@ -42,24 +83,16 @@ module WAB
       # value:: initial value
       # repair:: flag indicating invalid value should be repaired if possible
       def data(value={}, repair=false)
-        ::WAB::Impl::Data.new(value, repair)
+        WAB::Impl::Data.new(value, repair)
       end
-      
+
       ### View related methods.
 
       # Push changed data to the view if it matches one of the subscription
       # filters.
       #
       # data: Wab::Data to push to the view if subscribed
-      def changed(data)
-        raise NotImplementedError.new
-      end
-
-      # Reply asynchronously to a view request.
-      #
-      # rid:: request identifier the reply is associated with
-      # data:: content of the reply to be sent to the view
-      def reply(rid, data)
+      def changed(_data)
         raise NotImplementedError.new
       end
 
@@ -70,34 +103,22 @@ module WAB
       #
       # ref:: object reference
       def get(ref)
-        tql = { where: ref.to_i, select: '$' }
-        result = @engine.request(tql)
-        if result.nil? || 0 != result[:code]
-          if result.nil?
-            raise ::WAB::Error.new("nil result get of #{ref}.")
-          else
-            raise ::WAB::Error.new("error on get of #{ref}. #{result[:error]}")
-          end
-        end
-        result[:results]
+        result = query(where: ref.to_i, select: '$')
+        raise WAB::Error.new("nil result get of #{ref}.") if result.nil?
+        raise WAB::Error.new("error on get of #{ref}. #{result[:error]}") if 0 != result[:code]
+
+        ra = result[:results]
+        return nil if (ra.nil? || 0 == ra.length)
+        ra[0]
       end
 
       # Evaluates the JSON TQL query. The TQL should be native Ruby objects
       # that correspond to the TQL JSON format but using Symbol keys instead
       # of strings.
       #
-      # If a +handler+ is provided the call is evaluated asynchronously and
-      # the handler is called with the result of the query. If a +handler+ is
-      # supplied the +tql+ must contain an +:rid+ element that is unique
-      # across all handlers.
-      #
       # tql:: query to evaluate
-      # handler:: callback handler that implements the #on_result() method
-      def query(tql, handler=nil)
-
-        # TBD handle async, maybe just send and leave it at that
-
-        @engine.request(tql)
+      def query(tql)
+        @engine.request(tql, @timeout)
       end
 
       # Subscribe to changes in stored data and push changes to the controller
@@ -108,34 +129,10 @@ module WAB
       #
       # controller:: the controller to notify of changed
       # filter:: the filter to apply to the data. Syntax is that TQL uses for the FILTER clause.
-      def subscribe(controller, filter)
+      def subscribe(_controller, _filter)
         raise NotImplementedError.new
       end
 
-      private
-      
-      def form_where_eq(key, value)
-        value_class = value.class
-        x = ['EQ', key.to_s]
-        if value.is_a?(String)
-          x << "'" + value
-        elsif Time == value_class
-          x << value.utc.iso8601(9)
-        elsif value.nil? ||
-            TrueClass == value_class ||
-            FalseClass == value_class ||
-            Integer == value_class ||
-            Float == value_class ||
-            String == value_class
-          x << value
-        elsif 2 == RbConfig::CONFIG['MAJOR'] && 4 > RbConfig::CONFIG['MINOR'] && Fixnum == value_class
-          x << value
-        else
-          x << value.to_s
-        end
-        x
-      end
-
     end # Shell
   end # IO
 end # WAB

data/lib/wab/io.rb

@@ -9,5 +9,3 @@ end
 require 'wab/io/shell'
 require 'wab/io/engine'
 require 'wab/io/call'
-
-

data/lib/wab/open_controller.rb

@@ -0,0 +1,43 @@
+
+module WAB
+
+  # This controller exposes all possible methods expected in a WAB::Controller
+  # subclass, as public methods.
+  #
+  # Since those methods are private in the superclass, they need to be redefined
+  # as public methods to enable the concerned functionality.
+  #
+  # For example, if a controller is intented to provide only read-access, then
+  # just the +read+ method would need to be exposed as a public method. The
+  # remaining methods may remain private.
+  class OpenController < Controller
+
+    def initialize(shell)
+      super(shell)
+    end
+
+    # Catch requests that are not one of the below CRUD methods.
+    #
+    # Raises as it has to be handled specially.
+    def handle(data)
+      raise NotImplementedError.new
+    end
+
+    def create(path, query, data)
+      super
+    end
+
+    def read(path, query)
+      super
+    end
+
+    def update(path, query, data)
+      super
+    end
+
+    def delete(path, query)
+      super
+    end
+
+  end # OpenController
+end # WAB

data/lib/wab/shell.rb

@@ -8,7 +8,7 @@ module WAB
   # As the View conduit the Shell usually makes calls to the controller. The
   # exception to this control flow direction is when data changes and is
   # pushed out to the view.
-  # 
+  #
   # As the Model, the Shell must respond to request to update the store using
   # either the CRUD type operations that match the controller.
   #
@@ -17,51 +17,14 @@ module WAB
   # the methods remain the same.
   class Shell
 
-    # Sets up the shell with a type_key and path position.
-    #
-    # type_key:: key for the type associated with a record
-    # path_pos:: position in a URL path that is the class or type
-    def initialize(type_key='kind', path_pos=0)
-      @controllers = {}
-      @type_key = type_key
-      @path_pos = path_pos
-    end
-
-    # Starts the shell.
-    def start()
-    end
-
     # Returns the path where a data type is located. The default is 'kind'.
     def type_key()
-      @type_key
-    end
-
-    # Register a controller for a named type.
-    #
-    # If a request is received for an unregistered type the default controller
-    # will be used. The default controller is registered with a +nil+ key.
-    #
-    # type:: type name
-    # controller:: Controller instance for handling requests for the identified +type+
-    def register_controller(type, controller)
-      controller.shell = self
-      @controllers[type] = controller
+      raise NotImplementedError.new
     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)
-      if path.nil? || @path_pos <= path.length
-        content = data.get(:content)
-        if content.is_a?(::WAB::Data)
-          @controllers[content.get(@type_key)] || @controllers[nil]
-        end
-      end
-      @controllers[nil]
+    # Returns the position of the type in a path.
+    def path_pos()
+      raise NotImplementedError.new
     end
 
     # Create and return a new data instance with the provided initial value.
@@ -75,7 +38,7 @@ module WAB
     #
     # value:: initial value
     # repair:: flag indicating invalid value should be repaired if possible
-    def data(value=nil, repair=false)
+    def data(_value=nil, _repair=false)
       raise NotImplementedError.new
     end
 
@@ -85,15 +48,7 @@ module WAB
     # filters.
     #
     # data: Wab::Data to push to the view if subscribed
-    def changed(data)
-      raise NotImplementedError.new
-    end
-
-    # Reply asynchronously to a view request.
-    #
-    # rid:: request identifier the reply is associated with
-    # data:: content of the reply to be sent to the view
-    def reply(rid, data)
+    def changed(_data)
       raise NotImplementedError.new
     end
 
@@ -103,7 +58,7 @@ module WAB
     # is no match.
     #
     # ref:: object reference
-    def get(ref)
+    def get(_ref)
       raise NotImplementedError.new
     end
 
@@ -111,14 +66,8 @@ module WAB
     # that correspond to the TQL JSON format but using Symbol keys instead
     # of strings.
     #
-    # If a +handler+ is provided the call is evaluated asynchronously and
-    # the handler is called with the result of the query. If a +handler+ is
-    # supplied the +tql+ must contain an +:rid+ element that is unique
-    # across all handlers.
-    #
     # tql:: query to evaluate
-    # handler:: callback handler that implements the #on_result() method
-    def query(tql, handler=nil)
+    def query(_tql)
       raise NotImplementedError.new
     end
 
@@ -130,7 +79,43 @@ module WAB
     #
     # controller:: the controller to notify of changed
     # filter:: the filter to apply to the data. Syntax is that TQL uses for the FILTER clause.
-    def subscribe(controller, filter)
+    def subscribe(_controller, _filter)
+      raise NotImplementedError.new
+    end
+
+    # Returns true if error logging is turned on.
+    def error?
+      raise NotImplementedError.new
+    end
+
+    # Returns true if warn logging is turned on.
+    def warn?
+      raise NotImplementedError.new
+    end
+
+    # Returns true if info logging is turned on.
+    def info?
+      raise NotImplementedError.new
+    end
+
+    # Logs an error with the shell logger.
+    #
+    # message:: message to log
+    def error(_message)
+      raise NotImplementedError.new
+    end
+
+    # Logs a warning with the shell logger.
+    #
+    # message:: message to log
+    def warn(_message)
+      raise NotImplementedError.new
+    end
+
+    # Logs an info with the shell logger.
+    #
+    # message:: message to log
+    def info(_message)
       raise NotImplementedError.new
     end
 

data/lib/wab/shell_logger.rb

@@ -0,0 +1,13 @@
+require 'forwardable'
+require 'logger'
+
+module WAB
+  # mixin module meant to be 'included' into `WAB::Shell`, `WAB::IO::Shell`
+  # and `WAB::Impl::Shell`
+  module ShellLogger
+    attr_accessor :logger
+
+    extend Forwardable
+    def_delegators :@logger, :info?, :warn?, :error?, :info, :warn, :error
+  end
+end

data/lib/wab/utils.rb

@@ -0,0 +1,36 @@
+module WAB
+  module Utils
+    class << self
+      UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+      TIME_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}\:\d{2}\:\d{2}\.\d{9}Z$/
+
+      def ruby_series
+        RbConfig::CONFIG.values_at('MAJOR', 'MINOR').join.to_i
+      end
+
+      # Detect if `obj` is an instance of `Fixnum` from Ruby older than 2.4.x
+      def pre_24_fixnum?(obj)
+        24 > ruby_series && obj.is_a?(Fixnum)
+      end
+
+      # Determine if a given object is not an empty Hash
+      def populated_hash?(obj)
+        obj.is_a?(Hash) && !obj.empty?
+      end
+
+      # Detect if given string matches ISO/IEC UUID format:
+      # "123e4567-e89b-12d3-a456-426655440000"
+      def uuid_format?(str)
+        return false unless 36 == str.length
+        !UUID_REGEX.match(str).nil?
+      end
+
+      # Detect if given string matches a Time format as encoded by WAB components:
+      # "2017-09-01T12:45:15.123456789Z"
+      def wab_time_format?(str)
+        return false unless 30 == str.length
+        !TIME_REGEX.match(str).nil?
+      end
+    end
+  end
+end