gloo 3.0.1 → 3.1.0

data/lib/gloo/web_svr/handler.rb

@@ -0,0 +1,120 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 20124 Eric Crane.  All rights reserved.
+#
+# Web application request handler.
+# Takes a request and does what is needed to create a response.
+# 
+
+module Gloo
+  module WebSvr
+    class Handler
+      
+      attr_reader :server_obj
+
+
+      # ---------------------------------------------------------------------
+      #    Initialization
+      # ---------------------------------------------------------------------
+
+      #
+      # Set up the web server.
+      #
+      def initialize( engine, obj )
+        @engine = engine
+        @log = @engine.log
+        @server_obj = obj
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Process Request
+      # ---------------------------------------------------------------------
+
+      #
+      # Process the request and return a result.
+      # 
+      def handle request
+        @request = request
+
+        page = @server_obj.router.page_for_route @request.path
+        if page
+          if page.is_a? Gloo::Objs::FileHandle
+            return handle_file page
+          else
+            return handle_page page
+          end
+        end
+
+        return server_error_result
+      end
+
+      # 
+      # Handle request for a page.
+      # Render the page, with possible redirect.
+      # 
+      def handle_page page
+        result = page.render
+        if redirect_set?
+          page = @engine.running_app.obj.redirect
+          @log.debug "Redirecting to: #{page.pn}"
+          @engine.running_app.obj.redirect = nil
+          result = page.render
+        end
+        return result
+      end
+
+      # 
+      # Handle a request for a static file such as an image.
+      # 
+      def handle_file file
+        pn = @server_obj.asset.path_for_file file
+
+        # Check to make sure it is a valid file
+        # return error if it is not
+        return file_error_result unless File.exist? pn
+
+        return @server_obj.asset.render_file pn
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Errors
+      # ---------------------------------------------------------------------
+
+      # 
+      # Return a server error result.
+      # Use the app's error if there is one, otherwise a generic message.
+      # 
+      def server_error_result
+        err_page = @server_obj.err_page
+        return err_page.render if err_page
+
+        # Last resort, just return a generic error message.
+        return Gloo::WebSvr::Response.text_response( @engine, 
+          "Server error!", Gloo::WebSvr::ResponseCode::SERVER_ERR )
+      end    
+    
+      # 
+      # Get a file not found error result.
+      # 
+      def file_error_result
+        return Gloo::WebSvr::Response.text_response( @engine, 
+          "File not found!", Gloo::WebSvr::ResponseCode::NOT_FOUND )
+      end    
+
+
+      # ---------------------------------------------------------------------
+      #    Helper functions
+      # ---------------------------------------------------------------------
+
+      # 
+      # Is there a redirect page set in the running app?
+      # 
+      def redirect_set?
+        return false unless @engine.app_running?
+        return @engine.running_app.obj.redirect
+      end
+
+    end
+  end
+end

data/lib/gloo/web_svr/request.rb

@@ -0,0 +1,107 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 20124 Eric Crane.  All rights reserved.
+#
+# A web Request for a page, action, or static resource.
+#
+# Kinds of Resources
+#   Web Page
+#   Action - does something and redirects to a page (or returns nothing)
+#   API - returns JSON instead of HTML (but is that different from Web Page?)
+#   Static Resource - File, PDF, Image, etc.
+# 
+
+module Gloo
+  module WebSvr
+    class Request
+
+      REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+      REQUEST_PATH = 'REQUEST_PATH'.freeze
+      HTTP_HOST = 'HTTP_HOST'.freeze
+      QUERY_STRING = 'QUERY_STRING'.freeze
+
+      attr_reader :method, :host, :path, :query
+
+      
+      # ---------------------------------------------------------------------
+      #    Initialization
+      # ---------------------------------------------------------------------
+
+      #
+      # Set up the web server.
+      #
+      def initialize( engine, handler, env = nil )
+        @engine = engine
+        @log = @engine.log
+
+        @handler = handler
+
+        @env = env
+        detect_env
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Process Request
+      # ---------------------------------------------------------------------
+
+      #
+      # Process the request and return a result.
+      # 
+      def process
+        start_timer
+        result = @handler.handle self
+        finish_timer
+        return result
+      end
+
+      # ---------------------------------------------------------------------
+      #    ENV
+      # ---------------------------------------------------------------------
+
+      # 
+      # Write the request information to the log.
+      # 
+      def detect_env
+        @method = @env[ REQUEST_METHOD ]
+        @path = @env[ REQUEST_PATH ]
+        @host = @env[ HTTP_HOST ]
+        @query = @env[ QUERY_STRING ]
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Request timer
+      # ---------------------------------------------------------------------
+
+      # 
+      # Keep track of the request start time.
+      # 
+      def start_timer
+        @start = Time.now
+      end
+    
+      # 
+      # Write the request completion time to the log.
+      # 
+      def finish_timer
+        @finish = Time.now
+        @elapsed = ( ( @finish - @start ) * 1000.0 ).round(2)
+        @log.info "Web request complete.  Elapsed time: #{@elapsed} ms"
+      end
+    
+
+      # ---------------------------------------------------------------------
+      #    Helper functions
+      # ---------------------------------------------------------------------
+
+      # 
+      # Write the request information to the log.
+      # 
+      def log
+        @log.info "#{@method} #{@host}#{@path}"
+        @log.info "Parameters: #{@query}"
+      end
+
+    end
+  end
+end

data/lib/gloo/web_svr/response.rb

@@ -0,0 +1,118 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 20124 Eric Crane.  All rights reserved.
+#
+# The Response for a web Request.
+#
+
+module Gloo
+  module WebSvr
+    class Response
+
+      # 
+      # SEE: https://stackoverflow.com/questions/23714383/what-are-all-the-possible-values-for-http-content-type-header#48704300
+      #  for a list of content types.
+      # 
+      CONTENT_TYPE = 'Content-Type'.freeze
+      TEXT_TYPE = 'text/plain'.freeze
+      JSON_TYPE = 'application/json'.freeze
+      HTML_TYPE = 'text/html'.freeze
+            
+      attr_reader :code, :type, :data
+      
+
+      # ---------------------------------------------------------------------
+      #    Initialization
+      # ---------------------------------------------------------------------
+
+      #
+      # Set up the web server.
+      #
+      def initialize( engine = nil, 
+        code = Gloo::WebSvr::ResponseCode::SUCCESS, 
+        type = HTML_TYPE, data = nil )
+        
+        @engine = engine
+        @log = @engine.log if @engine
+
+        @code = code
+        @type = type
+        @data = data
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Static Helper Functions
+      # ---------------------------------------------------------------------
+
+      # 
+      # Helper to create a successful JSON response with the given data.
+      # 
+      def self.json_response( engine, data, 
+        code = Gloo::WebSvr::ResponseCode::SUCCESS )
+
+        return Gloo::WebSvr::Response.new( engine, code, JSON_TYPE, data )
+      end
+
+      # 
+      # Helper to create a successful text response with the given data.
+      # 
+      def self.text_response( engine, data, 
+        code = Gloo::WebSvr::ResponseCode::SUCCESS )
+
+        return Gloo::WebSvr::Response.new( engine, code, TEXT_TYPE, data )
+      end
+
+      # 
+      # Helper to create a successful web response with the given data.
+      # 
+      def self.html_response( engine, data, 
+        code = Gloo::WebSvr::ResponseCode::SUCCESS )
+
+        return Gloo::WebSvr::Response.new( engine, code, HTML_TYPE, data )
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Data Functions
+      # ---------------------------------------------------------------------
+
+      # 
+      # Add content to the payload.
+      # 
+      def add content
+        @data = '' if @data.nil?
+        @data << content
+      end
+
+      # 
+      # Get the headers for the response.
+      # 
+      def headers
+        return { CONTENT_TYPE => @type }
+      end
+
+      # 
+      # Get the final result that will be returned as the 
+      # response to the web request.
+      # 
+      def result
+        return [ @code, headers, @data ]
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Helper functions
+      # ---------------------------------------------------------------------
+
+      # 
+      # Write the result information to the log.
+      # 
+      def log
+        return unless @log
+
+        @log.info "Response #{@code} #{@type}"
+      end
+
+    end
+  end
+end

data/lib/gloo/web_svr/response_code.rb

@@ -0,0 +1,69 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 20124 Eric Crane.  All rights reserved.
+#
+# Standard Response Codes.
+# 
+# See:
+#    https://en.wikipedia.org/wiki/List_of_HTTP_status_codes 
+#    https://www.geeksforgeeks.org/10-most-common-http-status-codes/
+# 
+
+module Gloo
+  module WebSvr
+    class ResponseCode
+
+      # Gloo::WebSvr::ResponseCode::SUCCESS
+      SUCCESS = 200.freeze
+      CODE_200 = 'Success/OK'.freeze
+
+      CREATED = 201.freeze
+      CODE_201 = 'Created'.freeze
+
+      ACCEPTED = 202.freeze
+      CODE_202 = 'Accepted'.freeze
+
+      NO_CONTENT = 204.freeze
+      CODE_204 = 'No Content'.freeze
+
+      PARTIAL_CONTENT = 206.freeze
+      CODE_206 = 'Partial Content'.freeze
+
+      MOVED_PERM = 301.freeze
+      CODE_301 = 'Moved Permanently'.freeze
+      
+      FOUND = 302.freeze
+      CODE_302 = 'Found'.freeze
+
+      SEE_OTHER = 303.freeze
+      CODE_303 = 'See Other'.freeze
+
+      NOT_MODIFIED = 304.freeze
+      CODE_304 = 'Not Modified'.freeze
+
+      TEMP_REDIRECT = 307.freeze
+      CODE_307 = 'Temporary Redirect'.freeze
+
+      PERM_REDIRECT = 307.freeze
+      CODE_308 = 'Permanent Redirect'.freeze
+
+      BAD_REQUEST = 400.freeze
+      CODE_400 = 'Bad Request'.freeze
+
+      UNAUTHORIZED = 401.freeze
+      CODE_401 = 'Unauthorized'.freeze
+
+      FORBIDDEN = 403.freeze
+      CODE_403 = 'Forbidden'.freeze
+
+      NOT_FOUND = 404.freeze
+      CODE_404 = 'Not Found'.freeze
+
+      SERVER_ERR = 500.freeze
+      CODE_500 = 'Internal Server Error'.freeze
+
+      NOT_IMPLEMENTED = 501.freeze
+      CODE_501 = 'Not Implemented'.freeze
+
+    end
+  end
+end

data/lib/gloo/web_svr/router.rb

@@ -0,0 +1,179 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 20124 Eric Crane.  All rights reserved.
+#
+# A helper class for page routing.
+# 
+
+module Gloo
+  module WebSvr
+    class Router
+      
+      PAGE_CONTAINER = 'page'.freeze
+      INDEX = 'index'.freeze
+      SEGMENT_DIVIDER = '/'.freeze
+
+      attr_reader :route_segments
+
+
+      # ---------------------------------------------------------------------
+      #    Initialization
+      # ---------------------------------------------------------------------
+
+      #
+      # Set up the web server.
+      #
+      def initialize( engine, web_svr_obj )
+        @engine = engine
+        @log = @engine.log
+
+        @web_svr_obj = web_svr_obj
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Routing
+      # ---------------------------------------------------------------------
+
+      # 
+      # Find and return the page for the given route.
+      # 
+      def page_for_route path
+        @engine.log.info "routing to #{path}"
+        detect_segments path
+
+        return @web_svr_obj.home_page if is_root_path?
+
+        pages = @web_svr_obj.pages_container
+        return find_route_segment( pages.children ) if pages
+
+        return nil
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Dynamic Add Page Routes
+      # ---------------------------------------------------------------------
+
+      # 
+      # Get the root level page container.
+      #
+      def page_container
+        pn = Gloo::Core::Pn.new( @engine, PAGE_CONTAINER )
+        return pn.resolve
+      end
+
+      # 
+      # Add all page routes to the web server pages (routes).
+      # 
+      def add_page_routes
+        can = page_container
+        return unless can
+
+        @log.debug 'Adding page routes to web server…'
+        @factory = @engine.factory
+
+        add_pages can, @web_svr_obj.pages_container
+      end
+
+      #
+      # Add the pages to the web server pages.
+      # This is a recursive function that will add all
+      # pages in the folder and subfolders.
+      #
+      def add_pages can, parent
+        # for each file in the page container
+        # create a page object and add it to the routes
+        can.children.each do |obj|
+          if obj.class == Gloo::Objs::Container
+            child_can = parent.find_add_child( obj.name, 'container' )
+            add_pages( obj, child_can )
+          elsif obj.class == Gloo::Objs::Page
+            add_route_alias( parent, obj.name, obj.pn )
+          end
+        end
+      end
+
+      # 
+      # Add route alias to the page.
+      # 
+      def add_route_alias( parent, name, pn )
+        name = name.gsub( '.', '_' )
+
+        # First make sure the child doesn't already exist.
+        child = parent.find_child( name )
+        return if child
+
+        @factory.create_alias( name, pn, parent )
+      end
+
+      
+      # ---------------------------------------------------------------------
+      #    Helper funcions
+      # ---------------------------------------------------------------------
+
+      # 
+      # Find the route segment in the object container.
+      # 
+      def find_route_segment objs
+        this_segment = next_segment
+
+        this_segment = INDEX if this_segment.blank?
+
+        objs.each do |o|
+          o = Gloo::Objs::Alias.resolve_alias( @engine, o )
+
+          if o.name == this_segment
+            if o.class == Gloo::Objs::Page
+              @engine.log.debug "found page for route: #{o.pn}"
+              return o
+            elsif o.class == Gloo::Objs::FileHandle
+              @engine.log.debug "found static file for route: #{o.pn}"
+              return o
+            else
+              return nil unless o.child_count > 0
+
+              return find_route_segment( o.children )
+            end
+          end
+        end
+
+        return nil 
+      end
+
+      # 
+      # Get the next segment in the route.
+      # 
+      def next_segment
+        this_segment = @route_segments.shift
+        return nil if this_segment.nil?
+
+        # A URL might include a dot in a name, but we can't do that
+        # because dot is a reserve path thing. So we replace it with
+        # an underscore.
+        this_segment = this_segment.gsub( '.', '_' )
+
+        return this_segment
+      end
+
+      # 
+      # Is this the root path?
+      def is_root_path?
+        return @route_segments.count == 0
+      end
+
+      # 
+      # Create a list of path segments.
+      # 
+      def detect_segments path
+        # Split the path into segments.
+        @route_segments = path.split SEGMENT_DIVIDER
+
+        # Remove the first segment if it is empty.
+        @route_segments.shift if @route_segments.first.blank?
+
+        return @route_segments
+      end
+
+    end
+  end
+end

data/lib/gloo/web_svr/server.rb

@@ -0,0 +1,97 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 20124 Eric Crane.  All rights reserved.
+# 
+# Starting work on web server inside gloo.
+# 
+#  UNDER CONSTRUCTION!
+# 
+# Simple tests:
+#   > curl http://localhost:8087/test/
+#   > curl http://localhost:8087/web/
+#   > curl http://localhost:8087/test/1
+#   > curl http://localhost:8087/test?param=123
+# 
+# Run in loop:
+#  for i in {1..99}; do curl http://localhost:8087/; done
+# 
+# Links:
+#   https://github.com/rack/rack
+#   https://github.com/rack/rack/blob/main/lib/rack/builder.rb
+#   https://thoughtbot.com/blog/ruby-rack-tutorial
+#   https://www.rubydoc.info/gems/rack/1.5.5/Rack/Runtime
+# 
+
+require 'rack'
+
+module Gloo
+  module WebSvr
+    class Server
+    
+      # ---------------------------------------------------------------------
+      #    Initialization
+      # ---------------------------------------------------------------------
+
+      #
+      # Set up the web server.
+      #
+      def initialize( engine, handler, config = nil )
+        @config = config ? config : Gloo::WebSvr::Config.new
+        @engine = engine
+        @log = @engine.log
+        @handler = handler
+
+        @log.debug 'Gloo web server intialized…'
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Start and Stop the server.
+      # ---------------------------------------------------------------------
+
+      # 
+      # Start the web server.
+      # 
+      def start
+        opts = {
+          :Port => @config.port,
+          :Host => @config.host
+        }
+        Thread.abort_on_exception = true
+        @server_thread = Thread.new { Rack::Handler::Thin.run( self, **options=opts ) }
+        @log.debug 'Web server has started.'
+      end
+
+      # 
+      # Stop the web server
+      # 
+      def stop
+        @log.debug 'Stopping the web server…'
+
+        @server_thread.kill
+
+        @log.debug 'The web server has been stopped.'
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Handle events
+      # ---------------------------------------------------------------------
+
+      # 
+      # Handle a request for a resource.
+      # 
+      def call( env )
+        request = Gloo::WebSvr::Request.new( @engine, @handler, env )
+        request.log
+
+        response = request.process
+        response.log if response
+
+        return response ? response.result : nil
+      end
+
+    
+    end
+  end
+end
+