itsi-server 0.1.1 → 0.2.3

data/lib/itsi/http_response.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "stringio"
+require "socket"
+
+module Itsi
+  class HttpResponse
+    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)
+
+      if headers
+        headers.each do |key, value|
+          if value.is_a?(Array)
+            value.each { |v| add_header(key, v) }
+          else
+            add_header(key, value)
+          end
+        end
+      end
+
+      if body
+        # Common case. Write a single string body.
+        send_and_close(body)
+      elsif block_given?
+
+        # If you call respond with a block, you get a handle to a stream that you can write to.
+        yield self
+
+        # If you hijack the connection, you are responsible for closing it.
+        # Otherwise, the response will be closed automatically.
+        close unless hijack
+      else
+        close
+      end
+    end
+  end
+end

data/lib/itsi/passfile.rb

@@ -0,0 +1,108 @@
+module Itsi
+  class Server
+    module Passfile
+      require "io/console"
+
+      module_function
+
+      def load(filename)
+        if filename.nil? || filename.strip.empty?
+          puts "Error: a valid filename is required."
+          return nil
+        end
+
+        creds = {}
+        if File.exist?(filename)
+          File.foreach(filename) do |line|
+            line.chomp!
+            next if line.empty?
+
+            user, pass = line.split(":", 2)
+            creds[user] = pass
+          end
+        end
+        creds
+      end
+
+      def save(creds, filename)
+        File.open(filename, "w", 0o600) do |f|
+          creds.each do |u, p|
+            f.puts "#{u}:#{p}"
+          end
+        end
+      end
+
+      def echo(_, algorithm)
+        print "Enter username: "
+        username = $stdin.gets.chomp
+
+        print "Enter password: "
+
+        password = $stdin.noecho(&:gets).chomp
+        puts
+
+        print "Confirm password: "
+        password_confirm = $stdin.noecho(&:gets).chomp
+        puts
+
+        if password != password_confirm
+          puts "Error: Passwords do not match!"
+          exit(1)
+        end
+
+        puts "#{username}:#{Itsi.create_password_hash(password, algorithm)}"
+      end
+
+      def add(filename, algorithm)
+        return unless (creds = load(filename))
+
+        print "Enter username: "
+        username = $stdin.gets.chomp
+
+        print "Enter password: "
+
+        password = $stdin.noecho(&:gets).chomp
+        puts
+
+        print "Confirm password: "
+        password_confirm = $stdin.noecho(&:gets).chomp
+        puts
+
+        if password != password_confirm
+          puts "Error: Passwords do not match!"
+          exit(1)
+        end
+
+        creds[username] = Itsi.create_password_hash(password, algorithm)
+
+        save(creds, filename)
+
+        puts "User '#{username}' added."
+      end
+
+      def remove(filename)
+        return unless (creds = load(filename))
+
+        print "Enter username to remove: "
+        username = $stdin.gets.chomp
+
+        if creds.key?(username)
+          creds.delete(username)
+          save(creds, filename)
+          puts "User '#{username}' removed."
+        else
+          puts "Warning: User '#{username}' not found."
+        end
+      end
+
+      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

@@ -0,0 +1,105 @@
+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')
+
+          listing = [
+            Dir[File.expand_path(File.dirname(__FILE__) + "/#{config_type}/**/*.rb")],
+            Dir[File.expand_path(File.dirname(__FILE__) + "/#{config_type}s/**/*.rb")]
+          ].flatten
+
+          listing.each do |file|
+            current = klass.subclasses
+            require file
+            following = klass.subclasses
+            new_class = (following - current).first
+
+            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 = [])
+          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?
+
+          hash
+        end
+
+        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|
+                @middleware_class_attrs ||= {}
+                if value
+                  @middleware_class_attrs[attr] = value
+                else
+                  @middleware_class_attrs[attr]
+                end
+              end
+
+              base.define_method(attr) do |_value = nil|
+                self.class.send(attr)
+              end
+            end
+
+            def base.schema(value = nil, &blk)
+              @middleware_class_attrs ||= {}
+              if blk
+                @middleware_class_attrs[:schema] = TypedStruct.new(&blk)
+              elsif value
+                @middleware_class_attrs[:schema] = value
+              else
+                @middleware_class_attrs[:schema]
+              end
+            end
+          end
+
+          load_and_register(cls)
+
+          config_type = cls.name.split("::").last.downcase
+
+          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 }
+        end
+
+        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 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
+  end
+end

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

@@ -0,0 +1,206 @@
+module Itsi
+  class Server
+    module Config
+      class DSL
+        require_relative "config_helpers"
+        require_relative "option"
+        require_relative "middleware"
+
+        attr_reader :parent, :children, :middleware, :controller, :routes, :http_methods, :protocols,
+                    :hosts, :ports, :extensions, :content_types, :accepts, :options
+
+        def self.evaluate(config = Itsi::Server::Config.config_file_path, &blk) # rubocop:disable Metrics/MethodLength
+          config = new(routes: ["/"]) do
+            if blk
+              instance_exec(&blk)
+            else
+              code = IO.read(config)
+              instance_eval(code, config.to_s, 1)
+            end
+            location("*") {}
+          end
+          [config.options, config.errors]
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          [{}, [[e, e.backtrace[0]]]]
+        end
+
+        def initialize( # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity
+          parent = nil,
+          routes: [],
+          methods: [],
+          protocols: [],
+          hosts: [],
+          ports: [],
+          extensions: [],
+          content_types: [],
+          accepts: [],
+          controller: self,
+          &block
+        )
+          @parent           = parent
+          @children         = []
+          @middleware       = {}
+
+          @controller = controller
+          @routes = Array(routes).flatten
+          @http_methods = methods.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @protocols = protocols.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @hosts = hosts.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @ports = ports.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @extensions = extensions.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @content_types = content_types.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @accepts = accepts.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+
+          @options = {
+            middleware_loaders: [],
+            middleware_loader: lambda do
+              @options[:middleware_loaders].each(&:call)
+              @middleware[:app] ||= {}
+              @middleware[:app][:app_proc] = @middleware[:app]&.[](:preloader)&.call || DEFAULT_APP[]
+              [flatten_routes, Config.errors_to_error_lines(errors)]
+            end
+          }
+
+          @errors = []
+          instance_exec(&block)
+        end
+
+        def errors
+          @children.map(&:errors).flatten(1) + @errors
+        end
+
+        Option.subclasses.each do |option|
+          option_name = option.option_name
+          define_method(option_name) do |*args, **kwargs, &blk|
+            option.new(self, *args, **kwargs, &blk).build!
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            @errors << [e, caller[1]]
+          end
+        end
+
+        Middleware.subclasses.each do |middleware|
+          middleware_name = middleware.middleware_name
+          define_method(middleware_name) do |*args, **kwargs, &blk|
+            middleware.new(self, *args, **kwargs, &blk).build!
+          rescue Config::Endpoint::InvalidHandlerException => e
+            @errors << [e, "#{e.backtrace[0]}:in #{e.message}"]
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            @errors << [e, caller[1]]
+          end
+        end
+
+        def grpc_reflection(handlers)
+          @grpc_reflected_services ||= []
+          @grpc_reflected_services.concat(handlers)
+
+          location("grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo",
+                   "grpc.reflection.v1.ServerReflection/ServerReflectionInfo") do
+            @middleware[:app] = { preloader: lambda {
+              Itsi::Server::GrpcInterface.reflection_for(handlers)
+            }, request_type: "grpc" }
+          end
+        end
+
+        def file_server(**args)
+          Itsi.log_info "Note: file_server is an alias for static_assets"
+          static_assets(**args)
+        end
+
+        def flatten_routes
+          result = []
+          result.concat(@children.flat_map(&:flatten_routes))
+          route_options = paths_from_parent
+          if route_options
+            result << deep_stringify_keys(
+              {
+                route: Regexp.new("^#{route_options}/?$"),
+                methods: @http_methods.any? ? @http_methods : nil,
+                protocols: @protocols.any? ? @protocols : nil,
+                hosts: @hosts.any? ? @hosts : nil,
+                ports: @ports.any? ? @ports : nil,
+                extensions: @extensions.any? ? @extensions : nil,
+                content_types: @content_types.any? ? @content_types : nil,
+                accepts: @accepts.any? ? @accepts : nil,
+                middleware: effective_middleware
+              }
+            )
+          end
+          result
+        end
+
+        def paths_from_parent
+          return nil unless @routes.any?
+
+          route_or_str = @routes.map do |seg|
+            case seg
+            when Regexp
+              seg.source
+            else
+              parts = seg.split("/")
+              parts.map do |part|
+                case part
+                when /^:([A-Za-z_]\w*)(?:\(([^)]*)\))?$/
+                  param_name = Regexp.last_match(1)
+                  custom     = Regexp.last_match(2)
+                  if custom && !custom.empty?
+                    "(?<#{param_name}>#{custom})"
+                  else
+                    "(?<#{param_name}>[^/]+)"
+                  end
+                when /\*/
+                  part.gsub(/\*/, ".*")
+                else
+                  Regexp.escape(part)
+                end
+              end.join("/")
+            end
+          end.join("|")
+          if parent && parent.paths_from_parent && parent.paths_from_parent != "(?:/)"
+            "#{parent.paths_from_parent}#{route_or_str != "" ? "(?:#{route_or_str})" : ""}"
+          else
+            route_or_str = "/#{route_or_str}" unless route_or_str.start_with?("/")
+            "(?:#{route_or_str})"
+          end
+        end
+
+        def effective_middleware
+          chain = []
+          node = self
+          while node
+            if node.middleware[:app]&.[](:preloader)
+              node.middleware[:app][:app_proc] = node.middleware[:app].delete(:preloader).call
+            end
+            chain << node
+            node = node.parent
+          end
+          chain.reverse!
+
+          merged = {}
+
+          chain.each do |n|
+            n.middleware.each do |k, v|
+              merged[k] = if v[:combine]
+                            ([merged[k] || []] + [v]).flatten
+                          else
+                            v
+                          end
+            end
+          end
+          deep_stringify_keys(merged)
+        end
+
+        def deep_stringify_keys(obj)
+          case obj
+          when Hash
+            obj.transform_keys!(&:to_s)
+            obj.transform_values! { |v| deep_stringify_keys(v) }
+          when Array
+            obj.map { |v| deep_stringify_keys(v) }
+          else
+            obj
+          end
+        end
+      end
+    end
+  end
+end