lazy_graph 0.1.3 → 0.2.0

data/lib/lazy_graph/rack_app.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'rack'
+
+module LazyGraph
+  class RackApp
+    ALLOWED_VALUES_VALIDATE = [true, false, nil, 'input', 'context'].to_set.freeze
+    ALLOWED_VALUES_DEBUG = [true, false, nil].to_set.freeze
+
+    attr_reader :routes
+
+    def initialize(routes: {})
+      @routes = routes.transform_keys(&:to_sym).compare_by_identity
+    end
+
+    def call(env)
+      env[:X_REQUEST_TIME_START] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      request = Rack::Request.new(env)
+
+      return routes!(request) if (request.path == '/routes' || request.path == '/') && request.get?
+      return health!(request) if request.path == '/health' && request.get?
+      return not_found!(request) unless (graph_module = @routes[request.path.to_sym])
+      return success!(request, graph_module.usage) if request.get?
+      return not_found!("#{request.request_method} #{request.path}") unless request.post?
+
+      query_lazy_graph!(request, graph_module)
+    end
+
+    def query_lazy_graph!(request, graph_module)
+      body = begin
+        JSON.parse(request.body.read, symbolize_names: true)
+      rescue JSON::ParserError => e
+        return not_acceptable!(request, 'Invalid JSON', e.message)
+      end
+      context, modules, validate, debug, query = body.values_at(:context, :modules, :validate, :debug, :query)
+      unless context.is_a?(Hash) && !context.empty?
+        return not_acceptable!(request, "Invalid 'context' Parameter", 'Should be a non-empty object.')
+      end
+
+      unless (modules.is_a?(Hash) && !modules.empty?) || modules.is_a?(String) || (modules.is_a?(Array) && modules.all? do |m|
+        m.is_a?(String)
+      end)
+        return not_acceptable!(request, "Invalid 'modules' Parameter",
+                               'Should be a string, string-array or non-empty object.')
+      end
+
+      modules = Array(modules).map { |m| [m, {}] }.to_h unless modules.is_a?(Hash)
+
+      unless ALLOWED_VALUES_VALIDATE.include?(validate)
+        return not_acceptable!(
+          request, "Invalid 'validate' Parameter", "Should be nil, bool, or one of 'input', 'context'"
+        )
+      end
+
+      unless ALLOWED_VALUES_DEBUG.include?(debug) || debug.is_a?(String)
+        return not_acceptable!(request, "Invalid 'debug' Parameter", 'Should be nil or bool')
+      end
+
+      debug = Regexp.new(Regexp.escape(debug)) if debug.is_a?(String) && debug != 'exceptions'
+
+      unless query.nil? || query.is_a?(String) || (query.is_a?(Array) && query.all? do |q|
+        q.is_a?(String)
+      end)
+        return not_acceptable!(request, "Invalid 'query' Parameter", 'Should be nil, array or string array')
+      end
+
+      begin
+        result = graph_module.eval!(
+          modules: modules,
+          context: context,
+          validate: validate.nil? ? true : validate,
+          debug: if !debug.nil?
+                   debug
+                 else
+                   LazyGraph::Environment.development? ? 'exceptions' : debug
+                 end,
+          query: query
+        )
+        return not_acceptable!(request, result[:message], result[:detail]) if result[:type] == :error
+
+        success!(request, result)
+      rescue AbortError, ValidationError => e
+        LazyGraph.logger.error(e.message)
+        LazyGraph.logger.error(e.backtrace.join("\n"))
+        error!(request, 400, 'Bad Request', e.message)
+      rescue StandardError => e
+        LazyGraph.logger.error(e.message)
+        LazyGraph.logger.error(e.backtrace.join("\n"))
+
+        error!(request, 500, 'Internal Server Error', e.message)
+      end
+    end
+
+    def routes!(request)
+      success!(request, @routes.keys.map { |k, _v| { route: k.to_s, methods: %i[GET POST] } })
+    end
+
+    def health!(request)
+      success!(request, { status: 'ok' })
+    end
+
+    def not_acceptable!(request, message, details = '')
+      error!(request, 406, message, details)
+    end
+
+    def not_found!(request, details = '')
+      error!(request, 404, 'Not Found', details)
+    end
+
+    def request_ms(request)
+      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - request.env[:X_REQUEST_TIME_START]) * 1000.0).round(3)
+    end
+
+    def success!(request, result, status: 200)
+      req_ms = request_ms(request)
+
+      LazyGraph.logger.info(
+        Logger.build_color_string do
+          "#{bold(request.request_method)}: #{dim(request.path)} => #{green(status)} #{light_gray("#{req_ms}ms")}"
+        end
+      )
+
+      [status, { 'content-type' => 'application/json' }, [JSON.fast_generate(result)]]
+    end
+
+    def error!(request, status, message, details = '')
+      req_ms = request_ms(request)
+
+      LazyGraph.logger.error(
+        Logger.build_color_string do
+          "#{bold(request.request_method)}: #{dim(request.path)} => #{status.to_i >= 500 ? red(status) : orange(status)} #{light_gray("#{req_ms}ms")}"
+        end
+      )
+
+      [status, { 'content-type' => 'application/json' }, [JSON.fast_generate({ 'error': message, 'details': details })]]
+    end
+  end
+end

data/lib/lazy_graph/rack_server.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module LazyGraph
+  class RackServer
+    def initialize(app)
+      @app       = app
+      @running   = false
+      @threads   = [] #
+      @threads_m = Mutex.new
+    end
+
+    def start(port: 9292, workers: 4)
+      trap_signals
+
+      @port = port
+      @workers = workers
+
+      if workers > 1
+        puts "Starting Raxx server with #{workers} processes on port #{port}..."
+        @server = TCPServer.new(@port)
+        @server.listen(1024)
+
+        workers.times do
+          fork(&method(:run_accept_loop))
+        end
+        Process.waitall
+      else
+        puts "Starting single-process server on port #{port}..."
+        @server = TCPServer.new(@port)
+        @server.listen(1024)
+        run_accept_loop
+      end
+    end
+
+    private
+
+    #
+    # Main accept loop
+    #
+    def run_accept_loop
+      enable_reuse(@server)
+      @running = true
+      puts "[PID #{Process.pid}] Listening on port #{@port}..."
+
+      while @running
+        begin
+          client = @server.accept_nonblock if @running
+        rescue IO::WaitReadable, Errno::EINTR
+          IO.select([@server], nil, nil, 0.1) if @running
+          retry
+        end
+
+        # Handle connection in a new thread
+        next unless client
+
+        thr = Thread.start(client) do |socket|
+          socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+          handle_request(socket)
+          socket.close
+        rescue Errno::ECONNRESET, Errno::EPIPE, IOError, Errno::EINVAL
+          # Connection reset by peer - ignore
+        ensure
+          remove_thread(Thread.current)
+        end
+
+        add_thread(thr)
+      end
+    ensure
+      if @server
+        puts "[PID #{Process.pid}] Shutting down server socket..."
+        @server.close
+      end
+    end
+
+    #
+    # Actually handle requests in a keep-alive loop
+    #
+    def handle_request(socket)
+      while @running
+
+        begin
+          request_line = socket.gets if @running
+        rescue IO::WaitReadable, Errno::EINTR, Errno::EPIPE
+          IO.select([socket], nil, nil, 0.5) if @running
+          retry
+        end
+
+        break if request_line.nil? || request_line.strip.empty?
+
+        method, path, http_version = request_line.split
+
+        # Parse headers
+        headers = {}
+        content_length = 0
+        while (line = socket.gets) && line != "\r\n"
+          key, value = line.split(': ', 2)
+          headers[key.downcase] = value.strip
+          content_length = value.to_i if key == 'Content-Length'
+        end
+
+        body = content_length.positive? ? socket.read(content_length) : (+'').force_encoding('ASCII-8BIT')
+
+        # Build Rack environment
+        env = {
+          'REQUEST_METHOD' => method,
+          'PATH_INFO' => path,
+          'HTTP_VERSION' => http_version,
+          'QUERY_STRING' => path[/\?.*/].to_s,
+          'SERVER_PROTOCOL' => 'HTTP/1.1',
+          'SERVER_NAME' => 'localhost',
+          'rack.url_scheme' => 'http',
+          'rack.request.headers' => headers,
+          'rack.input' => StringIO.new(body),
+          'rack.errors' => StringIO.new('')
+        }
+
+        # Call the Rack app
+        status, response_headers, body_enum = @app.call(env)
+
+        content = body_enum.to_enum(:each).map(&:to_s).join
+
+        response_headers['Connection'] = 'keep-alive'
+        response_headers['Content-Length'] = content.bytesize.to_s
+
+        # Write the response
+        socket.print "HTTP/1.1 #{status} #{http_status_message(status)}\r\n"
+        response_headers.each { |k, v| socket.print "#{k}: #{v}\r\n" }
+        socket.print "\r\n"
+        socket.print content
+      end
+    end
+
+    #
+    # Thread management helpers
+    #
+    def add_thread(thr)
+      @threads_m.synchronize { @threads << thr }
+    end
+
+    def remove_thread(thr)
+      @threads_m.synchronize { @threads.delete(thr) }
+    end
+
+    #
+    # Trap signals, set @running = false, then force-kill leftover threads
+    #
+    def trap_signals
+      %w[INT TERM].each do |signal|
+        trap(signal) do
+          @running = false
+          # Give threads a grace period to finish
+          graceful_shutdown_threads(timeout: 5)
+        end
+      end
+    end
+
+    #
+    # Gracefully wait for each thread to finish; then force-kill if still alive
+    #
+    def graceful_shutdown_threads(timeout:)
+      @threads.each do |thr|
+        next unless thr.alive?
+
+        # Try a graceful join
+        thr.join(timeout)
+        # If still running after timeout, forcibly kill
+        if thr.alive?
+          puts "[PID #{Process.pid}] Force-killing thread #{thr.object_id}"
+          thr.kill
+        end
+      end
+    end
+
+    #
+    # Reuse port if supported
+    #
+    def enable_reuse(server)
+      server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+      begin
+        server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, true)
+      rescue StandardError
+        # Not supported on all systems
+        nil
+      end
+    end
+
+    #
+    # Utility: Convert a status code to reason phrase
+    #
+    def http_status_message(status)
+      {
+        200 => 'OK',
+        404 => 'Not Found'
+      }[status] || 'Unknown'
+    end
+  end
+end

data/lib/lazy_graph/stack_pointer.rb

@@ -4,35 +4,38 @@ module LazyGraph
   # Module to provide lazy graph functionalities using stack pointers.
   POINTER_POOL = []
 
-  StackPointer = Struct.new(:parent, :frame, :depth, :key, :root) do
+  StackPointer = Struct.new(:parent, :frame, :depth, :recursion_depth, :key, :root) do
     attr_accessor :pointer_cache
 
-    def shifted_id  = @shifted_id ||= object_id << 28
-
+    # Pushes a new frame onto the stack, creating or reusing a StackPointer.
+    # Frames represent activation contexts; keys are identifiers within those frames.
     def push(frame, key)
-      if (ptr = POINTER_POOL.pop)
-        ptr.parent = self
-        ptr.parent = self
-        ptr.frame = frame
-        ptr.key = key
-        ptr.depth = depth + 1
-        ptr.pointer_cache&.clear
-        ptr
-      else
-        StackPointer.new(parent: self, frame: frame, key: key, depth: depth + 1, root: root || self)
-      end
+      ptr = POINTER_POOL.pop || StackPointer.new
+      ptr.parent = self
+      ptr.root = root || self
+      ptr.frame = frame
+      ptr.key = key
+      ptr.depth = depth + 1
+      ptr.recursion_depth = recursion_depth
+      ptr.pointer_cache&.clear
+      ptr
     end
 
+    # Recycles the current StackPointer by adding it back to the pointer pool.
+    # Once recycled, this instance should no longer be used unless reassigned by push.
     def recycle!
       POINTER_POOL.push(self)
       nil
     end
 
+    # Retrieves the StackPointer at a specific index in the upward chain of parents.
     def ptr_at(index)
       @pointer_cache ||= {}.compare_by_identity
       @pointer_cache[index] ||= depth == index ? self : parent&.ptr_at(index)
     end
 
+    # Handles method calls not explicitly defined in this class by delegating them
+    # first to the frame, then to the parent, recursively up the stack.
     def method_missing(name, *args, &block)
       if frame.respond_to?(name)
         frame.send(name, *args, &block)
@@ -43,20 +46,25 @@ module LazyGraph
       end
     end
 
+    # Returns the key associated with this stack pointer's frame.
     def index
       key
     end
 
+    # Logs debugging information related to this stack pointer in the root frame's DEBUG section.
     def log_debug(**log_item)
       root.frame[:DEBUG] = [] if !root.frame[:DEBUG] || root.frame[:DEBUG].is_a?(MissingValue)
       root.frame[:DEBUG] << { **log_item, location: to_s }
       nil
     end
 
+    # Determines if the stack pointer can respond to a missing method by mimicking the behavior
+    # of the frame or any parent stack pointers recursively.
     def respond_to_missing?(name, include_private = false)
       frame.respond_to?(name, include_private) || parent.respond_to?(name, include_private)
     end
 
+    # Returns a string representation of the stacking path of keys up to this pointer.
     def to_s
       if parent
         "#{parent}#{key.to_s =~ /\d+/ ? "[#{key}]" : ".#{key}"}"

data/lib/lazy_graph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LazyGraph
-  VERSION = '0.1.3'
+  VERSION = '0.2.0'
 end

data/lib/lazy_graph.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'logger'
-
 # LazyGraph is a library which allows you to define a strictly typed hierarchical Graph structure.
 # Within this graph you can annotate certain nodes as derived nodes, which compute their outputs based
 # on input dependencies on other nodes in the graph structure (can be relative and absolute references).
@@ -12,11 +10,7 @@ require 'logger'
 #
 module LazyGraph
   class AbortError < StandardError; end
-  class << self
-    attr_accessor :logger
-  end
-
-  self.logger = Logger.new($stdout)
+  class ValidationError < StandardError; end
 end
 
 require_relative 'lazy_graph/context'
@@ -29,4 +23,8 @@ require_relative 'lazy_graph/hash_utils'
 require_relative 'lazy_graph/builder'
 require_relative 'lazy_graph/builder_group'
 require_relative 'lazy_graph/stack_pointer'
-require_relative 'lazy_graph/server'
+require_relative 'lazy_graph/cli'
+require_relative 'lazy_graph/rack_server'
+require_relative 'lazy_graph/rack_app'
+require_relative 'lazy_graph/logger'
+require_relative 'lazy_graph/environment'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: lazy_graph
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Wouter Coppieters
 bindir: exe
 cert_chain: []
-date: 2024-12-25 00:00:00.000000000 Z
+date: 2025-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -52,13 +52,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -66,7 +66,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ostruct
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: fiddle
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -80,7 +94,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: listen
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,7 +108,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: fiddle
+  name: memory_profiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -108,19 +122,61 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: debug
+  name: observer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -135,6 +191,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: solargraph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vernier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: JSON Driven, Stateless Rules Engine for JIT and efficient evaluation
   of complex rules and computation graphs.
 email:
@@ -148,15 +246,20 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/converter.rb
 - examples/performance_tests.rb
+- examples/shopping_cart_totals.rb
 - lib/lazy_graph.rb
 - lib/lazy_graph/builder.rb
 - lib/lazy_graph/builder/dsl.rb
 - lib/lazy_graph/builder_group.rb
+- lib/lazy_graph/cli.rb
 - lib/lazy_graph/context.rb
+- lib/lazy_graph/environment.rb
 - lib/lazy_graph/graph.rb
 - lib/lazy_graph/hash_utils.rb
 - lib/lazy_graph/lazy-graph.json
+- lib/lazy_graph/logger.rb
 - lib/lazy_graph/missing_value.rb
 - lib/lazy_graph/node.rb
 - lib/lazy_graph/node/array_node.rb
@@ -168,7 +271,8 @@ files:
 - lib/lazy_graph/path_parser/path.rb
 - lib/lazy_graph/path_parser/path_group.rb
 - lib/lazy_graph/path_parser/path_part.rb
-- lib/lazy_graph/server.rb
+- lib/lazy_graph/rack_app.rb
+- lib/lazy_graph/rack_server.rb
 - lib/lazy_graph/stack_pointer.rb
 - lib/lazy_graph/version.rb
 - logo.png