RubyGems - itsi-server - Versions diffs - 0.1.1 → 0.1.13 - Mend

itsi-server 0.1.1 → 0.1.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of itsi-server might be problematic. Click here for more details.

Files changed (143) hide show

data/lib/itsi/server/default_app/index.html ADDED Viewed

@@ -0,0 +1,91 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <title>Itsi - Default</title>
+  <style>
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+    body {
+      font-family: "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      background-color: #f4f4f4;
+      color: #333;
+      line-height: 1.6;
+    }
+    .container {
+      max-width: 700px;
+      margin: 3rem auto;
+      background: #fff;
+      border-radius: 8px;
+      box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);
+      padding: 2rem;
+    }
+    h1 {
+      font-size: 1.8rem;
+      margin-bottom: 1rem;
+      text-align: center;
+      color: #444;
+    }
+    p {
+      margin-bottom: 1rem;
+      text-align: center;
+      color: #666;
+    }
+    ul.fields {
+      list-style: none;
+      margin-top: 1.5rem;
+      padding: 0;
+    }
+    ul.fields li {
+      background: #fafafa;
+      border: 1px solid #eee;
+      border-radius: 5px;
+      padding: 0.75rem;
+      margin-bottom: 0.75rem;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+    .label {
+      font-weight: bold;
+      margin-right: 1rem;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>You're running on Itsi!</h1>
+    <p>RACK environment:</p>
+    <ul class="fields">
+      <li>
+        <span class="label">REQUEST_METHOD:</span>
+        <span>%{REQUEST_METHOD}</span>
+      </li>
+      <li>
+        <span class="label">PATH_INFO:</span>
+        <span>%{PATH_INFO}</span>
+      </li>
+      <li>
+        <span class="label">SERVER_NAME:</span>
+        <span>%{SERVER_NAME}</span>
+      </li>
+      <li>
+        <span class="label">SERVER_PORT:</span>
+        <span>%{SERVER_PORT}</span>
+      </li>
+      <li>
+        <span class="label">REMOTE_ADDR:</span>
+        <span>%{REMOTE_ADDR}</span>
+      </li>
+      <li>
+        <span class="label">HTTP_USER_AGENT:</span>
+        <span>%{HTTP_USER_AGENT}</span>
+      </li>
+    </ul>
+  </div>
+</body>
+</html>

data/lib/itsi/server/grpc_interface.rb ADDED Viewed

@@ -0,0 +1,213 @@
+module Itsi
+  class Server
+    class GrpcActiveCall
+      attr_reader :stream, :method_rpc, :output_metadata, :method_name
+      def initialize(stream, method_rpc, service_class, method_name)
+        @stream = stream
+        @method_rpc = method_rpc
+        @service_class = service_class
+        @output_metadata = {}
+        @method_name = method_name
+      end
+    end
+    class GrpcInterface
+      def self.for(services)
+        interface = new(services)
+        lambda do |request|
+          interface.handle_request(request)
+        end
+      end
+      def initialize(services = [])
+        @services = {}
+        register_services(services)
+      end
+      def register_services(services)
+        services.each do |service|
+          service_class = service.class
+          @services[service_class.service_name] = {
+            implementation: service,
+            class: service_class
+          }
+        end
+      end
+      def handle_request(request)
+        service_info = @services[request.service_name]
+        raise "Unknown service: #{request.service_name}" unless service_info
+        service_impl = service_info[:implementation]
+        service_class = service_info[:class]
+        method_rpc = RpcDescWrapper.new(service_class, request.content_type, request.method_name)
+        active_call = GrpcActiveCall.new(request.stream, method_rpc, service_class, request.method_name)
+        if method_rpc.bidi_streamer?
+          puts "Calling bidirectional streaming handler"
+          handle_bidi_streaming(active_call, service_impl)
+        elsif method_rpc.client_streamer?
+          puts "Calling client streaming handler"
+          handle_client_streaming(active_call, service_impl)
+        elsif method_rpc.server_streamer?
+          puts "Calling server streaming handler"
+          handle_server_streaming(active_call, service_impl)
+        elsif method_rpc.request_response?
+          handle_unary(active_call, service_impl)
+        end
+        active_call.stream.send_trailers({ "grpc-status" => "0" })
+      rescue StandardError => e
+        active_call.stream.send_trailers({ "grpc-status" => "13", "grpc-message" => e.message })
+      end
+      private
+      # Read a framed message from the stream
+      def read_message(stream)
+        # Read the gRPC frame header (5 bytes)
+        header = stream.read(5)
+        return nil if header.nil? || header.bytesize < 5
+        compressed = header.bytes[0] == 1
+        length = header[1..4].unpack1("N")
+        # Read the message body
+        stream.read(length)
+      end
+      # Send a response
+      def send_response(active_call, response)
+        response_data = active_call.method_rpc.marshal_response(response)
+        send_framed_message(active_call.stream, response_data)
+      end
+      # Send a framed message
+      def send_framed_message(stream, message_data, compressed = false)
+        compressed_flag = compressed ? 1 : 0
+        header = [compressed_flag, message_data.bytesize].pack("CN")
+        stream.write(header)
+        stream.write(message_data)
+        stream.flush
+      end
+      # Create an enumerator for client streaming requests
+      def create_request_enum(active_call)
+        Enumerator.new do |yielder|
+          loop do
+            message_data = read_message(active_call.stream)
+            break if message_data.nil?
+            request = active_call.method_rpc.unmarshal_request(message_data)
+            yielder << request
+          end
+        end
+      end
+      # Handlers for different RPC types
+      def handle_unary(active_call, service)
+        # Read the request message
+        message_data = read_message(active_call.stream)
+        request = active_call.method_rpc.unmarshal_request(message_data)
+        # Call the service implementation
+        underscore_method = GRPC::GenericService.underscore(active_call.method_name)
+        response = service.send(underscore_method, request, active_call)
+        # Send response
+        send_response(active_call, response)
+      end
+      def handle_client_streaming(active_call, service)
+        # Create an enumerable to read the incoming stream
+        request_enum = create_request_enum(active_call)
+        # Call the service implementation
+        underscore_method = GRPC::GenericService.underscore(active_call.method_name)
+        response = service.send(underscore_method, request_enum, active_call)
+        # Send response
+        send_response(active_call, response)
+      end
+      def handle_server_streaming(active_call, service)
+        # Read the request message
+        message_data = read_message(active_call.stream)
+        request = active_call.method_rpc.unmarshal_request(message_data)
+        # Call the service implementation with a block to handle streaming
+        underscore_method = GRPC::GenericService.underscore(active_call.method_name)
+        service.send(underscore_method, request, active_call) do |response|
+          send_response(active_call, response)
+        end
+      end
+      def handle_bidi_streaming(active_call, service)
+        # Create an enumerable to read the incoming stream
+        request_enum = create_request_enum(active_call)
+        # Call the service implementation with a block
+        underscore_method = GRPC::GenericService.underscore(active_call.method_name)
+        service.send(underscore_method, request_enum, active_call) do |response|
+          send_response(active_call, response)
+        end
+      end
+    end
+    class RpcDescWrapper
+      def initialize(service_class, content_type, method_name)
+        rpc_descs = service_class.rpc_descs
+        @rpc_desc = rpc_descs[method_name.to_sym]
+        raise "Method not found: #{method_name}" unless @rpc_desc
+        @input_type = @rpc_desc.input
+        @content_type = content_type
+        @input_is_stream = @input_type.is_a?(GRPC::RpcDesc::Stream)
+        @input_type = @input_type.type if @input_is_stream
+        @output_type = @rpc_desc.output
+        @output_is_stream = @output_type.is_a?(GRPC::RpcDesc::Stream)
+        @output_type = @output_type.type if @output_is_stream
+        @client_streamer = @input_is_stream
+        @server_streamer = @output_is_stream
+      end
+      def client_streamer?
+        @client_streamer
+      end
+      def server_streamer?
+        @server_streamer
+      end
+      def bidi_streamer?
+        @client_streamer && @server_streamer
+      end
+      def request_response?
+        !@client_streamer && !@server_streamer
+      end
+      def unmarshal_request(data)
+        if @content_type == "application/json"
+          @input_type.decode_json(data)
+        else
+          @input_type.decode(data)
+        end
+      end
+      def marshal_response(response)
+        if @content_type == "application/json"
+          response.to_json
+        else
+          response.to_proto
+        end
+      end
+    end
+  end
+end

data/lib/itsi/server/rack/handler/itsi.rb ADDED Viewed

@@ -0,0 +1,27 @@
+return unless defined?(::Rackup::Handler) || defined?(Rack::Handler)
+module Rack
+  module Handler
+    module Itsi
+      def self.run(app, options = {})
+        host = options.fetch(:host, "127.0.0.1")
+        port = options.fetch(:Port, 3001)
+        Itsi::Server.start(
+          {
+            app: app,
+            binds: ["http://#{host}:#{port}"]
+          },
+          Itsi::Server::Config.config_file_path
+        )
+      end
+    end
+  end
+end
+if defined?(Rackup)
+  ::Rackup::Handler.register("itsi", Rack::Handler::Itsi)
+  ::Rackup::Handler.register("Itsi", Rack::Handler::Itsi)
+elsif defined?(Rack)
+  ::Rack::Handler.register("itsi", Rack::Handler::Itsi)
+  ::Rack::Handler.register("Itsi", Rack::Handler::Itsi)
+end

data/lib/itsi/server/rack_interface.rb ADDED Viewed

@@ -0,0 +1,94 @@
+module Itsi
+  class Server
+    module RackInterface
+      # Builds a handler proc that is compatible with Rack applications.
+      def self.for(app)
+        require "rack"
+        if app.is_a?(String)
+          dir = File.expand_path(File.dirname(app))
+          Dir.chdir(dir) do
+            loaded_app = ::Rack::Builder.parse_file(app)
+            app = loaded_app.is_a?(Array) ? loaded_app.first : loaded_app
+          end
+        end
+        lambda do |request|
+          Server.respond(request, app.call(request.to_rack_env))
+        end
+      end
+      # Interface to Rack applications.
+      # Here we build the env, and invoke the Rack app's call method.
+      # We then turn the Rack response into something Itsi server understands.
+      def call(app, request)
+        respond request, app.call(request.to_rack_env)
+      end
+      # Itsi responses are asynchronous and can be streamed.
+      # Response chunks are sent using response.send_frame
+      # and the response is finished using response.close_write.
+      # If only a single chunk is written, you can use the #send_and_close method.
+      def respond(request, (status, headers, body))
+        response = request.response
+        # Don't try and respond if we've been hijacked.
+        # The hijacker is now responsible for this.
+        return if request.hijacked
+        # 1. Set Status
+        response.status = status
+        # 2. Set Headers
+        body_streamer = streaming_body?(body) ? body : headers.delete("rack.hijack")
+        headers.each do |key, value|
+          unless value.is_a?(Array)
+            response[key] = value
+            next
+          end
+          value.each do |v|
+            response[key] = v
+          end
+        end
+        # 3. Set Body
+        # As soon as we start setting the response
+        # the server will begin to stream it to the client.
+        # If we're partially hijacked or returned a streaming body,
+        # stream this response.
+        if body_streamer
+          body_streamer.call(response)
+        # If we're enumerable with more than one chunk
+        # also stream, otherwise write in a single chunk
+        elsif body.respond_to?(:each) || body.respond_to?(:to_ary)
+          unless body.respond_to?(:each)
+            body = body.to_ary
+            raise "Body #to_ary didn't return an array" unless body.is_a?(Array)
+          end
+          # We offset this iteration intentionally,
+          # to optimize for the case where there's only one chunk.
+          buffer = nil
+          body.each do |part|
+            response << buffer.to_s if buffer
+            buffer = part
+          end
+          response.send_and_close(buffer.to_s)
+        else
+          response.send_and_close(body.to_s)
+        end
+      ensure
+        response.close_write
+        body.close if body.respond_to?(:close)
+      end
+      # A streaming body is one that responds to #call and not #each.
+      def streaming_body?(body)
+        body.respond_to?(:call) && !body.respond_to?(:each)
+      end
+    end
+  end
+end

data/lib/itsi/server/scheduler_interface.rb ADDED Viewed

@@ -0,0 +1,21 @@
+module Itsi
+  class Server
+    module SchedulerInterface
+      # Simple wrapper to instantiate a scheduler, start it,
+      # and immediate have it invoke a scheduler proc
+      def start_scheduler_loop(scheduler_class, scheduler_task)
+        scheduler = scheduler_class.new
+        Fiber.set_scheduler(scheduler)
+        [scheduler, Fiber.schedule(&scheduler_task)]
+      end
+      # When running in scheduler mode,
+      # each request is wrapped in a Fiber.
+      def schedule(app, request)
+        Fiber.schedule do
+          app.call(request)
+        end
+      end
+    end
+  end
+end

data/lib/itsi/server/scheduler_mode.rb ADDED Viewed

@@ -0,0 +1,10 @@
+# Running with a Fiber scheduler enabled but with an ActiveSupport isolation_level set to Thread
+# can be dangerous. A thread isolation level means that all fibers sharing a thread can content
+# for the same resources, which can lead to race conditions.
+# This hook should *only* be disabled if you know there are no such shared resources.
+if defined?(ActiveSupport::IsolatedExecutionState) && !ENV["ITSI_DISABLE_AS_AUTO_FIBER_ISOLATION_LEVEL"]
+  Itsi.log_info \
+    "ActiveSupport Isolated Execution state detected. Automatically switching to :fiber mode. "\
+    "Set ITSI_DISABLE_AS_AUTO_FIBER_ISOLATION_LEVEL to disable this behavior"
+  ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
+end

data/lib/itsi/server/signal_trap.rb ADDED Viewed

@@ -0,0 +1,29 @@
+module Itsi
+  # This trap is necessary for debuggers and similar which intercept certain signals
+  # then attempt to restore these to the previous signal when finished.
+  # If the previous signal handler was registered in native code, this restoration doesn't
+  # work as expected and the native signal handler is lost.
+  # We intercept restored signals here and reinstate the Itsi server signal handlers
+  # (if the server is still running).
+  module SignalTrap
+    DEFAULT_SIGNALS = ["DEFAULT", "", nil].freeze
+    INTERCEPTED_SIGNALS = ["INT"].freeze
+    def trap(signal, *args, &block)
+      unless INTERCEPTED_SIGNALS.include?(signal.to_s) && block.nil? && Itsi::Server.running?
+        return super(signal, *args, &block)
+      end
+      Itsi::Server.reset_signal_handlers
+      nil
+    end
+  end
+end
+[Kernel, Signal].each do |receiver|
+  receiver.singleton_class.prepend(Itsi::SignalTrap)
+end
+[Object].each do |receiver|
+  receiver.include(Itsi::SignalTrap)
+end

data/lib/itsi/server/version.rb CHANGED Viewed

@@ -2,6 +2,6 @@
 module Itsi
   class Server
-    VERSION = "0.1.1"
+    VERSION = "0.1.13"
   end
 end

data/lib/itsi/server.rb CHANGED Viewed

@@ -2,19 +2,100 @@
 require_relative "server/version"
 require_relative "server/itsi_server"
+require_relative "server/rack_interface"
+require_relative "server/grpc_interface"
+require_relative "server/scheduler_interface"
+require_relative "server/signal_trap"
+require_relative "server/rack/handler/itsi"
+require_relative "server/config"
+require_relative "standard_headers"
+require_relative "http_request"
+require_relative "http_response"
 module Itsi
   class Server
-    # Call our Rack app with our request ENV.
-    def self.call(app, request)
-      app.call(request.to_env)
-    end
+    extend RackInterface
+    extend SchedulerInterface
+    class << self
+      def running?
+        !!@running
+      end
+      def start_in_background_thread(cli_params={}, itsi_file = Itsi::Server::Config.config_file_path, &blk)
+        @background_thread = start(cli_params, itsi_file, background: true, &blk)
+      end
+      def start(cli_params, itsi_file = Itsi::Server::Config.config_file_path, background: false, &blk)
+        server = new(cli_params, itsi_file, blk)
+        previous_handler = Signal.trap(:INT, :DEFAULT)
+        run = lambda do
+          write_pid
+          @running = server
+          server.start
+          Signal.trap(:INT, previous_handler)
+          server
+        end
+        background ? Thread.new(&run) : run[]
+      end
+      def stop_background_thread
+        @running&.stop
+        @running = nil
+        @background_thread&.join
+      end
+      def write_pid
+        File.write(Itsi::Server::Config.pid_file_path, Process.pid)
+      end
+      def get_pid
+        pid = File.read(Itsi::Server::Config.pid_file_path).to_i
+        if Process.kill(0, pid)
+          pid
+        else
+          nil
+        end
+      rescue StandardError
+        nil
+      end
+      def reload
+        return unless pid = get_pid
+        Process.kill(:USR2, pid)
+      end
+      def restart
+        return unless pid = get_pid
+        Process.kill(:USR1, pid)
+      end
+      def down
+        puts :down
+      end
+      def up
+        puts :up
+      end
+      def add_worker
+        return unless pid = get_pid
+        Process.kill(:TTIN, pid)
+      end
+      def remove_worker
+        return unless pid = get_pid
+        Process.kill(:TTOU, pid)
+      end
+      def status
+        return unless pid = get_pid
-    # If scheduler is enabled
-    # Each request is wrapped in a Fiber.
-    def self.schedule(app, request)
-      Fiber.schedule do
-        call(app, request)
+        Process.kill(:INFO, pid)
       end
     end
   end

data/lib/itsi/standard_headers.rb ADDED Viewed

@@ -0,0 +1,86 @@
+module Itsi
+  module StandardHeaders
+    ALL = [
+      ACCEPT = "accept",
+      ACCEPT_CHARSET = "accept-charset",
+      ACCEPT_ENCODING = "accept-encoding",
+      ACCEPT_LANGUAGE = "accept-language",
+      ACCEPT_RANGES = "accept-ranges",
+      ACCESS_CONTROL_ALLOW_CREDENTIALS = "access-control-allow-credentials",
+      ACCESS_CONTROL_ALLOW_HEADERS = "access-control-allow-headers",
+      ACCESS_CONTROL_ALLOW_METHODS = "access-control-allow-methods",
+      ACCESS_CONTROL_ALLOW_ORIGIN = "access-control-allow-origin",
+      ACCESS_CONTROL_EXPOSE_HEADERS = "access-control-expose-headers",
+      ACCESS_CONTROL_MAX_AGE = "access-control-max-age",
+      ACCESS_CONTROL_REQUEST_HEADERS = "access-control-request-headers",
+      ACCESS_CONTROL_REQUEST_METHOD = "access-control-request-method",
+      AGE = "age",
+      ALLOW = "allow",
+      ALT_SVC = "alt-svc",
+      AUTHORIZATION = "authorization",
+      CACHE_CONTROL = "cache-control",
+      CACHE_STATUS = "cache-status",
+      CDN_CACHE_CONTROL = "cdn-cache-control",
+      CONNECTION = "connection",
+      CONTENT_DISPOSITION = "content-disposition",
+      CONTENT_ENCODING = "content-encoding",
+      CONTENT_LANGUAGE = "content-language",
+      CONTENT_LENGTH = "content-length",
+      CONTENT_LOCATION = "content-location",
+      CONTENT_RANGE = "content-range",
+      CONTENT_SECURITY_POLICY_REPORT_ONLY = "content-security-policy-report-only",
+      CONTENT_TYPE = "content-type",
+      COOKIE = "cookie",
+      DNT = "dnt",
+      DATE = "date",
+      ETAG = "etag",
+      EXPECT = "expect",
+      EXPIRES = "expires",
+      FORWARDED = "forwarded",
+      FROM = "from",
+      HOST = "host",
+      IF_MATCH = "if-match",
+      IF_MODIFIED_SINCE = "if-modified-since",
+      IF_NONE_MATCH = "if-none-match",
+      IF_RANGE = "if-range",
+      IF_UNMODIFIED_SINCE = "if-unmodified-since",
+      LAST_MODIFIED = "last-modified",
+      LINK = "link",
+      LOCATION = "location",
+      MAX_FORWARDS = "max-forwards",
+      ORIGIN = "origin",
+      PRAGMA = "pragma",
+      PROXY_AUTHENTICATE = "proxy-authenticate",
+      PROXY_AUTHORIZATION = "proxy-authorization",
+      PUBLIC_KEY_PINS = "public-key-pins",
+      PUBLIC_KEY_PINS_REPORT_ONLY = "public-key-pins-report-only",
+      RANGE = "range",
+      REFERER = "referer",
+      REFERRER_POLICY = "referrer-policy",
+      REFRESH = "refresh",
+      RETRY_AFTER = "retry-after",
+      SEC_WEBSOCKET_ACCEPT = "sec-websocket-accept",
+      SEC_WEBSOCKET_EXTENSIONS = "sec-websocket-extensions",
+      SEC_WEBSOCKET_KEY = "sec-websocket-key",
+      SEC_WEBSOCKET_PROTOCOL = "sec-websocket-protocol",
+      SEC_WEBSOCKET_VERSION = "sec-websocket-version",
+      SERVER = "server",
+      SET_COOKIE = "set-cookie",
+      STRICT_TRANSPORT_SECURITY = "strict-transport-security",
+      TE = "te",
+      TRAILER = "trailer",
+      TRANSFER_ENCODING = "transfer-encoding",
+      USER_AGENT = "user-agent",
+      UPGRADE = "upgrade",
+      UPGRADE_INSECURE_REQUESTS = "upgrade-insecure-requests",
+      VARY = "vary",
+      VIA = "via",
+      WARNING = "warning",
+      WWW_AUTHENTICATE = "www-authenticate",
+      X_CONTENT_TYPE_OPTIONS = "x-content-type-options",
+      X_DNS_PREFETCH_CONTROL = "x-dns-prefetch-control",
+      X_FRAME_OPTIONS = "x-frame-options",
+      X_XSS_PROTECTION = "x-xss-protection",
+    ]
+  end
+end