itsi-server 0.2.2 → 0.2.4

data/ext/itsi_server/src/services/itsi_http_service.rs

@@ -1,14 +1,15 @@
 use crate::default_responses::{NOT_FOUND_RESPONSE, TIMEOUT_RESPONSE};
 use crate::ruby_types::itsi_server::itsi_server_config::{ItsiServerTokenPreference, ServerParams};
 use crate::server::binds::listener::ListenerInfo;
-use crate::server::http_message_types::{ConversionExt, HttpResponse, RequestExt, ResponseFormat};
+use crate::server::http_message_types::{
+    ConversionExt, HttpRequest, HttpResponse, RequestExt, ResponseFormat,
+};
 use crate::server::lifecycle_event::LifecycleEvent;
 use crate::server::middleware_stack::MiddlewareLayer;
 use crate::server::request_job::RequestJob;
 use crate::server::serve_strategy::single_mode::RunningPhase;
 use crate::server::signal::send_lifecycle_event;
-use chrono;
-use chrono::Local;
+use chrono::{self, DateTime, Local};
 use either::Either;
 use http::header::ACCEPT_ENCODING;
 use http::{HeaderValue, Request};
@@ -18,6 +19,7 @@ use itsi_error::ItsiError;
 use regex::Regex;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::OnceLock;
+use std::time::{Duration, Instant};
 use tracing::error;
 
 use std::{future::Future, ops::Deref, pin::Pin, sync::Arc};
@@ -68,17 +70,16 @@ impl Deref for RequestContextInner {
 }
 
 pub struct RequestContextInner {
-    pub request_id: u128,
+    pub request_id: u64,
     pub service: ItsiHttpService,
     pub accept: ResponseFormat,
     pub matching_pattern: Option<Arc<Regex>>,
     pub origin: OnceLock<Option<String>>,
     pub response_format: OnceLock<ResponseFormat>,
-    pub start_time: chrono::DateTime<chrono::Utc>,
-    pub request: Option<Arc<Request<Incoming>>>,
-    pub request_start_time: OnceLock<chrono::DateTime<Local>>,
+    pub request_start_time: OnceLock<DateTime<Local>>,
+    pub start_instant: Instant,
     pub if_none_match: OnceLock<Option<String>>,
-    pub supported_encoding_set: Vec<HeaderValue>,
+    pub supported_encoding_set: OnceLock<Vec<HeaderValue>>,
     pub is_ruby_request: Arc<AtomicBool>,
 }
 
@@ -87,27 +88,38 @@ impl HttpRequestContext {
         service: ItsiHttpService,
         matching_pattern: Option<Arc<Regex>>,
         accept: ResponseFormat,
-        supported_encoding_set: Vec<HeaderValue>,
         is_ruby_request: Arc<AtomicBool>,
     ) -> Self {
         HttpRequestContext {
             inner: Arc::new(RequestContextInner {
-                request_id: rand::random::<u128>(),
+                request_id: rand::random::<u64>(),
                 service,
                 matching_pattern,
                 accept,
                 origin: OnceLock::new(),
                 response_format: OnceLock::new(),
-                start_time: chrono::Utc::now(),
-                request: None,
                 request_start_time: OnceLock::new(),
+                start_instant: Instant::now(),
                 if_none_match: OnceLock::new(),
-                supported_encoding_set,
+                supported_encoding_set: OnceLock::new(),
                 is_ruby_request,
             }),
         }
     }
 
+    pub fn set_supported_encoding_set(&self, req: &HttpRequest) {
+        let supported_encoding_set = req
+            .headers()
+            .get_all(ACCEPT_ENCODING)
+            .into_iter()
+            .cloned()
+            .collect::<Vec<_>>();
+        self.inner
+            .supported_encoding_set
+            .set(supported_encoding_set)
+            .unwrap();
+    }
+
     pub fn set_origin(&self, origin: Option<String>) {
         self.inner.origin.set(origin).unwrap();
     }
@@ -121,28 +133,29 @@ impl HttpRequestContext {
     }
 
     pub fn short_request_id(&self) -> String {
-        format!("{:016x}", self.inner.request_id & 0xffff_ffff_ffff_ffff)
+        format!("{:08x}", self.inner.request_id & 0xffff_ffff)
     }
 
     pub fn request_id(&self) -> String {
-        format!("{:016x}", self.inner.request_id)
+        format!("{:08x}", self.inner.request_id)
     }
 
-    pub fn track_start_time(&self) {
+    pub fn init_logging_params(&self) {
         self.inner
             .request_start_time
             .get_or_init(chrono::Local::now);
     }
 
-    pub fn start_time(&self) -> Option<chrono::DateTime<Local>> {
+    pub fn start_instant(&self) -> Instant {
+        self.inner.start_instant
+    }
+
+    pub fn start_time(&self) -> Option<DateTime<Local>> {
         self.inner.request_start_time.get().cloned()
     }
 
-    pub fn get_response_time(&self) -> Option<chrono::TimeDelta> {
-        self.inner
-            .request_start_time
-            .get()
-            .map(|instant| Local::now() - instant)
+    pub fn get_response_time(&self) -> Duration {
+        self.inner.start_instant.elapsed()
     }
 
     pub fn set_response_format(&self, format: ResponseFormat) {
@@ -152,6 +165,10 @@ impl HttpRequestContext {
     pub fn response_format(&self) -> &ResponseFormat {
         self.inner.response_format.get().unwrap()
     }
+
+    pub fn supported_encoding_set(&self) -> Option<&Vec<HeaderValue>> {
+        self.inner.supported_encoding_set.get()
+    }
 }
 
 const SERVER_TOKEN_VERSION: HeaderValue =
@@ -170,12 +187,7 @@ impl Service<Request<Incoming>> for ItsiHttpService {
         let accept: ResponseFormat = req.accept().into();
         let accept_clone = accept.clone();
         let is_single_mode = self.server_params.workers == 1;
-        let supported_encoding_set = req
-            .headers()
-            .get_all(ACCEPT_ENCODING)
-            .into_iter()
-            .cloned()
-            .collect::<Vec<_>>();
+
         let request_timeout = self.server_params.request_timeout;
         let is_ruby_request = Arc::new(AtomicBool::new(false));
         let irr_clone = is_ruby_request.clone();
@@ -187,7 +199,6 @@ impl Service<Request<Incoming>> for ItsiHttpService {
                 self_clone,
                 matching_pattern,
                 accept_clone.clone(),
-                supported_encoding_set,
                 irr_clone,
             );
             let mut depth = 0;
@@ -229,8 +240,8 @@ impl Service<Request<Incoming>> for ItsiHttpService {
             Ok(resp)
         };
 
-        Box::pin(async move {
-            if let Some(timeout_duration) = request_timeout {
+        if let Some(timeout_duration) = request_timeout {
+            Box::pin(async move {
                 match timeout(timeout_duration, service_future).await {
                     Ok(result) => result,
                     Err(_) => {
@@ -249,9 +260,9 @@ impl Service<Request<Incoming>> for ItsiHttpService {
                         Ok(TIMEOUT_RESPONSE.to_http_response(accept).await)
                     }
                 }
-            } else {
-                service_future.await
-            }
-        })
+            })
+        } else {
+            Box::pin(service_future)
+        }
     }
 }

data/ext/itsi_server/src/services/static_file_server.rs

@@ -51,6 +51,10 @@ pub static ROOT_STATIC_FILE_SERVER: LazyLock<StaticFileServer> = LazyLock::new(|
         not_found_behavior: NotFoundBehavior::Error(ErrorResponse::not_found()),
         serve_hidden_files: false,
         allowed_extensions: vec!["html".to_string(), "css".to_string(), "js".to_string()],
+        miss_cache: Cache::builder()
+            .max_capacity(1000)
+            .time_to_live(Duration::from_secs(1))
+            .build(),
     })
     .unwrap()
 });
@@ -85,6 +89,7 @@ pub struct StaticFileServerConfig {
     pub headers: Option<HashMap<String, String>>,
     pub serve_hidden_files: bool,
     pub allowed_extensions: Vec<String>,
+    pub miss_cache: Cache<String, NotFoundBehavior>,
 }
 
 #[derive(Debug, Clone)]
@@ -389,6 +394,29 @@ impl StaticFileServer {
         abs_path: &str,
         accept: ResponseFormat,
     ) -> std::result::Result<ResolvedAsset, NotFoundBehavior> {
+        let ext_opt = Path::new(key)
+            .extension()
+            .and_then(|e| e.to_str())
+            .map(|s| s.to_lowercase());
+
+        // If the allowed list is non-empty, enforce membership
+        if !self.allowed_extensions.is_empty() {
+            match ext_opt {
+                Some(ref ext)
+                    if self
+                        .allowed_extensions
+                        .iter()
+                        .any(|ae| ae.eq_ignore_ascii_case(ext)) => {}
+                None if self.config.try_html_extension => {}
+                _ => {
+                    return Err(self.config.not_found_behavior.clone());
+                }
+            }
+        }
+
+        if let Some(cached_nf) = self.miss_cache.get(key) {
+            return Err(cached_nf.clone());
+        }
         // First check if we have a cached mapping for this key
         if let Some(path) = self.key_to_path.lock().await.get(key) {
             // Check if the cached entry is still valid
@@ -449,7 +477,6 @@ impl StaticFileServer {
 
         let mut full_path = self.config.root_dir.clone();
         full_path.push(normalized_path);
-        debug!("Resolving path {:?}", full_path);
         // Check if path exists and is a file
         match tokio::fs::metadata(&full_path).await {
             Ok(metadata) => {
@@ -561,7 +588,6 @@ impl StaticFileServer {
             }
             Err(_) => {
                 // Path doesn't exist, try with .html extension if configured
-                debug!("Path doesn't exist");
                 if self.config.try_html_extension {
                     let mut html_path = full_path.clone();
                     html_path.set_extension("html");
@@ -592,7 +618,9 @@ impl StaticFileServer {
         }
 
         // If we get here, we couldn't resolve the key to a file
-        Err(self.config.not_found_behavior.clone())
+        let nf = self.config.not_found_behavior.clone();
+        self.miss_cache.insert(key.to_string(), nf.clone());
+        Err(nf)
     }
 
     async fn stream_file_range(

data/lib/itsi/http_request.rb

@@ -3,7 +3,7 @@
 require "stringio"
 require "socket"
 require "uri"
-require_relative 'http_request/response_status_shortcodes'
+require_relative "http_request/response_status_shortcodes"
 
 module Itsi
   class HttpRequest
@@ -22,7 +22,7 @@ module Itsi
                   end
       [header, rack_form]
     end.to_h.tap do |hm|
-      hm.default_proc = proc { |hsh, key| "HTTP_#{key.upcase.gsub(/-/, "_")}" }
+      hm.default_proc = proc { |_, key| "HTTP_#{key.upcase.gsub(/-/, "_")}" }
     end
 
     def to_rack_env
@@ -78,7 +78,7 @@ module Itsi
     end
 
     def respond(
-      _body = nil, _status = 200, _headers = nil,
+      _body = nil, _status = 200, _headers = nil, # rubocop:disable Lint/UnderscorePrefixedVariableName
       json: nil,
       html: nil,
       text: nil,
@@ -90,13 +90,12 @@ module Itsi
       body: _body,
       &blk
     )
-
       if json
         if as
           begin
             validate!(json, as: as)
           rescue ValidationError => e
-            json = {type: 'error', message: "Validation Error: #{e.message}"}
+            json = { type: "error", message: "Validation Error: #{e.message}" }
             status = 400
           end
         end
@@ -118,15 +117,13 @@ module Itsi
       end
 
       response.respond(status: status, headers: headers, body: body, hijack: hijack, &blk)
-
-
     end
 
     def hijack
       self.hijacked = true
       UNIXSocket.pair.yield_self do |(server_sock, app_sock)|
         server_sock.autoclose = false
-        self.response.hijack(server_sock.fileno)
+        response.hijack(server_sock.fileno)
         server_sock.sync = true
         app_sock.sync = true
         app_sock
@@ -150,37 +147,37 @@ module Itsi
       as ? apply_schema!(params, as) : params
     end
 
-    def params(schema=nil)
-      params = case
-      when url_encoded? then URI.decode_www_form(build_input_io.read).to_h
-      when json? then JSON.parse(build_input_io.read)
-      when multipart?
-        Rack::Multipart::Parser.parse(
-          build_input_io,
-          content_length,
-          content_type,
-          Rack::Multipart::Parser::TEMPFILE_FACTORY,
-          Rack::Multipart::Parser::BUFSIZE,
-          Rack::Utils.default_query_parser
-        ).params
-      else
-        {}
-      end
+    def params(schema = nil)
+      params = if url_encoded?
+                 URI.decode_www_form(build_input_io.read).to_h
+               elsif json?
+                 JSON.parse(build_input_io.read)
+               elsif multipart?
+                 Rack::Multipart::Parser.parse(
+                   build_input_io,
+                   content_length,
+                   content_type,
+                   Rack::Multipart::Parser::TEMPFILE_FACTORY,
+                   Rack::Multipart::Parser::BUFSIZE,
+                   Rack::Utils.default_query_parser
+                 ).params
+               else
+                 {}
+               end
 
       params.merge!(query_params).merge!(url_params)
       validated = schema ? apply_schema!(params, schema) : params
-      unless block_given?
-        if multipart?
-          raise "#params must take a block for multipart requests"
-        else
-          return validated
-        end
-      else
+      if block_given?
         yield validated
+      else
+        raise "#params must take a block for multipart requests" if multipart?
+
+        validated
+
       end
     rescue ValidationError => e
       if response.json?
-        respond(json: {error: e.message}, status: 400)
+        respond(json: { error: e.message }, status: 400)
       else
         respond(e.message, 400)
       end
@@ -191,7 +188,7 @@ module Itsi
       # Unexpected error.
       # Don't reveal potential sensitive information to client.
       if response.json?
-        respond(json: {error: "Internal Server Error"}, status: 500)
+        respond(json: { error: "Internal Server Error" }, status: 500)
       else
         respond("Internal Server Error", 500)
       end
@@ -205,7 +202,7 @@ module Itsi
         if params.key?(:tempfile)
           params[:tempfile].unlink
         else
-        params.each_value { |v| clean_temp_files(v) }
+          params.each_value { |v| clean_temp_files(v) }
         end
       when Array then params.each { |v| clean_temp_files(v) }
       end

data/lib/itsi/http_response.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
-require 'forwardable'
+
+require "forwardable"
 require "stringio"
 require "socket"
 
 module Itsi
-
   class HttpResponse
-
-    def respond _body=nil, _status=200, _header=nil, status: _status, headers: _header, body: _body, hijack: false, &blk
-
-      self.status = status.kind_of?(Symbol) ? HTTP_STATUS_NAME_TO_CODE_MAP.fetch(status) : status.to_i
+    def respond(
+      _body = nil, _status = 200, _header = nil, # rubocop:disable Lint/UnderscorePrefixedVariableName
+      status: _status, headers: _header, body: _body,
+      hijack: false
+    )
+      self.status = status.is_a?(Symbol) ? HTTP_STATUS_NAME_TO_CODE_MAP.fetch(status) : status.to_i
 
       body = body.to_s unless body.is_a?(String)
 
@@ -33,9 +35,9 @@ module Itsi
 
         # If you hijack the connection, you are responsible for closing it.
         # Otherwise, the response will be closed automatically.
-        self.close unless hijack
+        close unless hijack
       else
-        self.close
+        close
       end
     end
   end

data/lib/itsi/passfile.rb

@@ -1,8 +1,7 @@
 module Itsi
   class Server
-
     module Passfile
-      require 'io/console'
+      require "io/console"
 
       module_function
 
@@ -18,7 +17,7 @@ module Itsi
             line.chomp!
             next if line.empty?
 
-            user, pass = line.split(':', 2)
+            user, pass = line.split(":", 2)
             creds[user] = pass
           end
         end
@@ -26,14 +25,14 @@ module Itsi
       end
 
       def save(creds, filename)
-        File.open(filename, 'w', 0o600) do |f|
+        File.open(filename, "w", 0o600) do |f|
           creds.each do |u, p|
             f.puts "#{u}:#{p}"
           end
         end
       end
 
-      def echo(filename, algorithm)
+      def echo(_, algorithm)
         print "Enter username: "
         username = $stdin.gets.chomp
 
@@ -56,6 +55,7 @@ module Itsi
 
       def add(filename, algorithm)
         return unless (creds = load(filename))
+
         print "Enter username: "
         username = $stdin.gets.chomp
 
@@ -98,11 +98,11 @@ module Itsi
       def list(filename)
         puts "Current credentials in '#{filename}':"
         return unless (creds = load(filename))
+
         creds.each do |u, p|
           puts "#{u}:#{p}"
         end
       end
-
     end
   end
 end

data/lib/itsi/server/config/config_helpers.rb

@@ -2,7 +2,6 @@ module Itsi
   class Server
     module Config
       module ConfigHelpers
-
         def self.load_and_register(klass)
           config_type = klass.name.split("::").last.downcase.gsub(/([a-z]()[A-Z])/, '\1_\2')
 
@@ -17,35 +16,35 @@ module Itsi
             following = klass.subclasses
             new_class = (following - current).first
 
-            documentation_file = "#{file[/(.*)\.rb/,1]}.md"
-            if ! File.exist?(documentation_file)
-              documentation_file =  "#{file[/(.*)\/[^\/]+\.rb/,1]}/_index.md"
-            end
-            if File.exist?(documentation_file) && new_class
-              new_class.documentation IO.read(documentation_file)
-                .gsub(/^---.*?\n.*?-+/m,'') # Strip frontmatter
-                .gsub(/^(```.*?)\{.*?\}.*$/, "\\1") # Strip filename from code blocks
-                .gsub(/^\{\{[^\}]+\}\}/, "") # Strip Hugo blocks
-            end
+            documentation_file = "#{file[/(.*)\.rb/, 1]}.md"
+            documentation_file = "#{file[%r{(.*)/[^/]+\.rb}, 1]}/_index.md" unless File.exist?(documentation_file)
+            next unless File.exist?(documentation_file) && new_class
+
+            new_class.documentation IO.read(documentation_file)
+                                      .gsub(/^---.*?\n.*?-+/m, "") # Strip frontmatter
+                                      .gsub(/^(```.*?)\{.*?\}.*$/, "\\1") # Strip filename from code blocks
+                                      .gsub(/^\{\{[^}]+\}\}/, "") # Strip Hugo blocks
           end
         end
 
-        def normalize_keys!(hash, expected=[])
+        def normalize_keys!(hash, expected = [])
           hash.keys.each do |key|
             value = hash.delete(key)
             key = key.to_s.downcase.to_sym
             hash[key] = value
             raise "Unexpected key: #{key}" unless expected.include?(key)
+
             expected -= [key]
           end
-          raise "Missing required keys: #{expected.join(', ')}" unless expected.empty?
+          raise "Missing required keys: #{expected.join(", ")}" unless expected.empty?
+
           hash
         end
 
-        def self.included(cls)
-          def cls.inherited(base)
+        def self.included(cls) # rubocop:disable Metrics/PerceivedComplexity,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+          def cls.inherited(base) # rubocop:disable Metrics/MethodLength,Lint/MissingSuper,Metrics/PerceivedComplexity
             %i[detail documentation insert_text schema].each do |attr|
-              base.define_singleton_method(attr) do |value=nil|
+              base.define_singleton_method(attr) do |value = nil|
                 @middleware_class_attrs ||= {}
                 if value
                   @middleware_class_attrs[attr] = value
@@ -54,12 +53,12 @@ module Itsi
                 end
               end
 
-              base.define_method(attr) do |value=nil|
+              base.define_method(attr) do |_value = nil|
                 self.class.send(attr)
               end
             end
 
-            def base.schema(value=nil, &blk)
+            def base.schema(value = nil, &blk)
               @middleware_class_attrs ||= {}
               if blk
                 @middleware_class_attrs[:schema] = TypedStruct.new(&blk)
@@ -75,29 +74,30 @@ module Itsi
 
           config_type = cls.name.split("::").last.downcase
 
-          cls.define_singleton_method("#{config_type}_name") do |name=self.name|
+          cls.define_singleton_method("#{config_type}_name") do |name = self.name|
             @config_name ||= name.split("::").last.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
           end
-          cls.define_method(:opt_name){ self.class.send("#{config_type}_name") }
-          cls.define_method(:location){ @location }
+          cls.define_method(:opt_name) { self.class.send("#{config_type}_name") }
+          cls.define_method(:location) { @location }
         end
 
-        def initialize(location, params={})
+        def initialize(location, params = {})
           if !self.class.ancestors.include?(Middleware) && !location.parent.nil?
             raise "#{opt_name} must be set at the top level"
           end
+
           @location = location
-          @params = case self.schema
-          when TypedStruct::Validation
-            self.schema.validate!(params)
-          when Array
-            default, validation = self.schema
-            params ? validation.validate!(params) : default
-          when nil
-            nil
-          else
-            self.schema.new(params).to_h
-          end
+          @params = case schema
+                    when TypedStruct::Validation
+                      schema.validate!(params)
+                    when Array
+                      default, validation = schema
+                      params ? validation.validate!(params) : default
+                    when nil
+                      nil
+                    else
+                      schema.new(params).to_h
+                    end
         end
       end
     end