itsi-server 0.1.1 → 0.2.2

data/lib/itsi/server/default_config/Itsi.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+# This is the default Itsi configuration file, installed when you run `itsi init`
+# It contains a sane starting point for configuring your Itsi server.
+# You can use this file in both development and production environments.
+# Most of the options in this file can be overridden by command line options.
+# Check out itsi -h to learn more about the command line options available to you.
+
+env = ENV.fetch("APP_ENV") { ENV.fetch("RACK_ENV", "development") }
+
+# Number of worker processes to spawn
+# If more than 1, Itsi will be booted in Cluster mode
+workers ENV.fetch("ITSI_WORKERS") {
+  require "etc"
+  env == "development" ? 1 : nil
+}
+
+# Number of threads to spawn per worker process
+# For pure CPU bound applicationss, you'll get the best results keeping this number low
+# Setting a value of 1 is great for superficial benchmarks, but in reality
+# it's better to set this a bit higher to allow expensive requests to get overtaken and minimize head-of-line blocking
+threads ENV.fetch("ITSI_THREADS", 3)
+
+# If your application is IO bound (e.g. performing a lot of proxied HTTP requests, or heavy queries etc)
+# you can see *substantial* benefits from enabling this option.
+# To set this option, pass a string, not a class (as we will not have loaded the class yet)
+# E.g.
+# `fiber_scheduler "Itsi::Scheduler"` - The default fast and light-weight scheduler that comes with Itsi
+# `fiber_scheduler "Async::Scheduler"` - Bring your own scheduler!
+fiber_scheduler nil
+
+# If you bind to https, without specifying a certificate, Itsi will use a self-signed certificate.
+# The self-signed certificate will use a CA generated for your host and stored inside `ITSI_LOCAL_CA_DIR` (Defaults to ~/.itsi)
+# bind "https://localhost:3000"
+# bind "https://localhost:3000?domains=dev.itsi.fyi"
+#
+# If you want to use let's encrypt to generate you a real certificate you and pass cert=acme and an acme_email address to generate one.
+# bind "https://itsi.fyi?cert=acme&acme_email=admin@itsi.fyi"
+# You can generate certificates for multiple domains at once, by passing a comma-separated list of domains
+# bind "https://0.0.0.0?domains=foo.itsi.fyi,bar.itsi.fyi&cert=acme&acme_email=admin@itsi.fyi"
+#
+# If you already have a certificate you can specify it using the cert and key parameters
+# bind "https://itsi.fyi?cert=/path/to/cert.pem&key=/path/to/key.pem"
+#
+# You can also bind to a unix socket or a tls unix socket. E.g.
+# bind "unix:///tmp/itsi.sock"
+# bind "tls:///tmp/itsi.secure.sock"
+
+if env == "development"
+  bind "http://localhost:3000"
+else
+  bind "https://0.0.0.0?domains=#{ENV["PRODUCTION_DOMAINS"]}&cert=acme&acme_email=admin@itsi.fyi"
+end
+
+# If you want to preload the application, set preload to true
+# to load the entire rack-app defined in rack_file_name before forking.
+# Alternatively, you can preload just a specific set of gems in a group in your gemfile,
+# by providing the group name here.
+# E.g.
+#
+# preload :preload # Load gems inside the preload group
+# preload false # Don't preload.
+#
+# If you want to be able to perform zero-downtime deploys using a single itsi process,
+# you should disable preloads, so that the application is loaded fresh each time a new worker boots
+preload true
+
+# Set the maximum memory limit for each worker process in bytes
+# When this limit is reached, the worker will be gracefully restarted.
+# Only one worker is restarted at a time to ensure we don't take down
+# all of them at once, if they reach the threshold simultaneously.
+worker_memory_limit 1024 * 1024 * 1024
+
+# You can provide an optional block of code to run, when a worker hits its memory threshold (Use this to send yourself an alert,
+# write metrics to disk etc. etc.)
+after_memory_limit_reached do |pid|
+  puts "Worker #{pid} has reached its memory threshold and will restart"
+end
+
+# Do clean up of any non-threadsafe resources before forking a new worker here.
+before_fork {}
+
+# Reinitialize any non-threadsafe resources after forking a new worker here.
+after_fork {}
+
+# Shutdown timeout
+# Number of seconds to wait for workers to gracefully shutdown before killing them.
+shutdown_timeout 5
+
+# Set this to false for application environments that require rack.input to be a rewindable body
+# (like Rails). For rack applications that can stream inputs, you can set this to true for a more memory-efficient approach.
+stream_body false
+
+# OOB GC responses threshold
+# Specifies how frequently OOB gc should be triggered during periods where there is a gap in queued requests.
+# Setting this too low can substantially worsen performance
+oob_gc_responses_threshold 512
+
+# Log level
+# Set this to one of the following values: debug, info, warn, error, fatal
+# Can also be set using the ITSI_LOG environment variable
+log_level :info
+
+# Log Format
+# Set this to be either :plain or :json. If you leave it blank Itsi will try
+# and auto-detect the format based on the TTY environment.
+log_format :plain

data/lib/itsi/server/grpc/grpc_call.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Itsi
+  class GrpcCall
+    attr_accessor :rpc_desc
+
+    def input_stream?
+      @input_stream ||= @rpc_desc&.input&.is_a?(GRPC::RpcDesc::Stream) || false
+    end
+
+    def output_stream?
+      @output_stream ||= @rpc_desc&.output&.is_a?(GRPC::RpcDesc::Stream) || false
+    end
+
+    def input_type
+      @input_type ||= input_stream? ? rpc_desc.input.type : rpc_desc.input
+    end
+
+    def output_type
+      @output_type ||= output_stream? ? rpc_desc.output.type : rpc_desc.output
+    end
+
+    def reader
+      @reader ||= IO.open(stream.reader_fileno, "rb")
+    end
+
+    def close
+      if output_stream? && content_type == "application/json"
+        stream.write("[") unless @opened
+        stream.write("]")
+      end
+
+      @reader&.close
+      stream.close
+    end
+
+    def deadline
+      return @deadline if defined?(@deadline)
+      return @deadline = nil unless timeout
+
+      @deadline = Time.now + timeout
+    end
+
+    def parse_from_json_stream(json_stream)
+      first_char = nil
+      loop do
+        char = json_stream.read(1)
+        break if char.nil?
+        if char =~ /\s/
+          next
+        elsif ["[", ","].include?(char)
+          first_char = char
+          break
+        elsif char == "]"
+          return nil
+        else
+          # If the first non-whitespace character is not '[' or comma, return nil.
+          return nil
+        end
+      end
+
+      return nil if first_char.nil?
+
+      # Step 2: Process objects until we hit the end of the JSON stream or array.
+      loop do
+        # Skip any whitespace or commas preceding an object.
+        char = nil
+        loop do
+          char = json_stream.read(1)
+          break if char.nil?
+          next if char =~ /\s/
+
+          break
+        end
+        # The next non-whitespace, non-comma character should be the start of an object.
+        return nil unless char == "{"
+
+        # Step 3: Start buffering the JSON object.
+        buffer = "{".dup
+        stack = ["{"]
+        in_string = false
+        escape = false
+
+        while stack.any?
+          ch = json_stream.read(1)
+          return nil if ch.nil? # premature end of stream
+
+          buffer << ch
+
+
+          if in_string
+            if escape
+              escape = false
+              next
+            end
+            if ch == "\\"
+              escape = true
+            elsif ch == '"'
+              in_string = false
+            end
+          elsif ch == '"'
+            in_string = true
+          elsif ["{", "["].include?(ch)
+            stack.push(ch)
+          elsif ["}", "]"].include?(ch)
+            expected = (ch == "}" ? "{" : "[")
+            # Check for matching bracket.
+            return nil unless stack.last == expected
+
+            stack.pop
+          end
+        end
+        # Yield the complete JSON object (as a string).
+        return buffer
+      end
+    end
+
+    def remote_read
+      if content_type == "application/json"
+        if input_stream?
+          if next_item = parse_from_json_stream(reader)
+            input_type.decode_json(next_item)
+          end
+        else
+          input_type.decode_json(reader.read)
+        end
+      else
+        header = reader.read(5)
+        return nil if header.nil? || header.bytesize < 5
+
+        compressed = header.bytes[0] == 1
+        length = header[1..4].unpack1("N")
+
+        data = reader.read(length)
+        return nil if data.nil?
+
+        data = decompress_input(data) if compressed
+
+        input_type.decode(data)
+      end
+    end
+
+    def send_framed_message(message_data, compressed = nil)
+      if content_type == "application/json"
+        if output_stream?
+          if @opened
+            stream.write(",\n")
+          else
+            stream.write("[")
+            @opened = true
+          end
+        end
+        message_data = output_type.encode_json(message_data)
+        stream.write(message_data)
+      else
+        message_data = output_type.encode(message_data)
+        should_compress = compressed.nil? ? should_compress_output?(message_data.bytesize) : compressed
+
+        if should_compress
+          message_data = compress_output(message_data)
+          compressed_flag = 1
+        else
+          compressed_flag = 0
+        end
+
+        message = [compressed_flag, message_data.bytesize].pack("CN") << message_data
+        stream.write(message)
+
+        @body_written = true
+      end
+    rescue IOError
+      close
+    end
+
+    def remote_send(response)
+      send_framed_message(response)
+    end
+
+    def deadline_exceeded?
+      @deadline && @deadline <= Time.now
+    end
+
+    def each_remote_read
+      return enum_for(:each_remote_read) unless block_given?
+
+      while (resp = remote_read) || !cancelled?
+
+        yield resp
+      end
+    end
+
+    def bidi_streamer?
+      input_stream? && output_stream?
+    end
+
+    def client_streamer?
+      input_stream? && !output_stream?
+    end
+
+    def server_streamer?
+      !input_stream? && output_stream?
+    end
+
+    def request_response?
+      !input_stream? && !output_stream?
+    end
+
+    def send_initial_metadata(kv_pairs)
+      add_headers(kv_pairs.transform_values { |v| Array(v) })
+    end
+
+    def send_empty
+      remote_send(output_type.new) unless @body_written
+    end
+
+    def send_status(status_code, status_details, trailing_metadata = {})
+      trailers = {
+        "grpc-status" => status_code.to_s
+      }
+
+      unless status_details.nil? || status_details.empty?
+        encoded_message = status_details.gsub(/[ #%&+,:;<=>?@\[\]^`{|}~\\"]/) do |c|
+          "%" + c.ord.to_s(16).upcase
+        end
+        trailers["grpc-message"] = encoded_message
+      end
+
+      trailing_metadata.each do |key, value|
+        trailers[key] = \
+          if key.to_s.end_with?("-bin")
+            Base64.strict_encode64(value.to_s)
+          else
+            value.to_s
+          end
+      end
+
+      send_trailers(trailers)
+    end
+
+    def send_trailers(trailers)
+      stream.send_trailers(trailers)
+    end
+  end
+end

data/lib/itsi/server/grpc/grpc_interface.rb

@@ -0,0 +1,107 @@
+module Itsi
+  class Server
+    class GrpcInterface
+      DeadlineExceeded = Class.new(StandardError)
+
+      attr_accessor :service, :service_class
+
+      def self.for(service)
+        interface = new(service)
+        lambda do |request|
+          interface.handle_request(request)
+        end
+      end
+
+      def self.reflection_for(handlers)
+        require_relative "reflection/v1/reflection_services_pb"
+        interface = new(Grpc::Reflection::V1::ServerReflection::Service.new(handlers))
+        lambda do |request|
+          interface.handle_request(request)
+        end
+      end
+
+      def initialize(service)
+        @service = service
+        @service_class = service.class
+        @rpc_descs = @service_class.rpc_descs.transform_keys do |k|
+          k.to_s.gsub(/([a-z])([A-Z])/, "\\1_\\2").downcase.to_sym
+        end
+      end
+
+      def handle_request(active_call)
+        puts "Handling active call"
+        unless (active_call.rpc_desc = @rpc_descs[active_call.method_name])
+          active_call.stream.write("\n")
+          active_call.send_status(13, "Method not found")
+          active_call.close
+          return
+        end
+
+        active_call.send_initial_metadata(
+          {
+            "grpc-accept-encoding" => "gzip, deflate, identity",
+            "content-type" => active_call.json? ? "application/json" : "application/grpc"
+          }
+        )
+
+        begin
+          if active_call.bidi_streamer?
+            handle_bidi_streaming(active_call)
+          elsif active_call.client_streamer?
+            handle_client_streaming(active_call)
+          elsif active_call.server_streamer?
+            handle_server_streaming(active_call)
+          elsif active_call.request_response?
+            handle_unary(active_call)
+          end
+          active_call.send_status(0, "Success")
+        rescue Google::Protobuf::ParseError => e
+          active_call.send_empty
+          active_call.send_status(3, e.message)
+        rescue DeadlineExceeded => e
+          active_call.send_empty
+          active_call.send_status(4, e.message)
+        rescue StandardError => e
+          active_call.send_empty
+          active_call.send_status(13, e.message)
+        end
+      rescue StandardError => e
+        Itsi.log_warn("Unhandled error in grpc_interface: #{e.message}")
+      ensure
+        active_call.close
+      end
+
+      private
+
+      def handle_unary(active_call)
+        message = active_call.remote_read
+        response = service.send(active_call.method_name, message, active_call)
+        active_call.remote_send(response)
+      end
+
+      def handle_client_streaming(active_call)
+        response = service.send(active_call.method_name, active_call.each_remote_read, active_call)
+        active_call.remote_send(response)
+      end
+
+      def handle_server_streaming(active_call)
+        message = active_call.remote_read
+        result = service.send(active_call.method_name, message, active_call) do |response|
+          active_call.remote_send(response)
+        end
+        if result.kind_of?(Enumerator)
+          result.each { |response| active_call.remote_send(response) }
+        end
+      end
+
+      def handle_bidi_streaming(active_call)
+        result = service.send(active_call.method_name, active_call.each_remote_read, active_call) do |response|
+          active_call.remote_send(response)
+        end
+        if result.kind_of?(Enumerator)
+          result.each { |response| active_call.remote_send(response) }
+        end
+      end
+    end
+  end
+end

data/lib/itsi/server/grpc/reflection/v1/reflection_pb.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: reflection.proto
+
+require 'google/protobuf'
+require "google/protobuf/descriptor_pb"
+
+descriptor_data = "\n\x10reflection.proto\x12\x12grpc.reflection.v1\"\x85\x02\n\x17ServerReflectionRequest\x12\x0c\n\x04host\x18\x01 \x01(\t\x12\x1a\n\x10\x66ile_by_filename\x18\x03 \x01(\tH\x00\x12 \n\x16\x66ile_containing_symbol\x18\x04 \x01(\tH\x00\x12I\n\x19\x66ile_containing_extension\x18\x05 \x01(\x0b\x32$.grpc.reflection.v1.ExtensionRequestH\x00\x12\'\n\x1d\x61ll_extension_numbers_of_type\x18\x06 \x01(\tH\x00\x12\x17\n\rlist_services\x18\x07 \x01(\tH\x00\x42\x11\n\x0fmessage_request\"E\n\x10\x45xtensionRequest\x12\x17\n\x0f\x63ontaining_type\x18\x01 \x01(\t\x12\x18\n\x10\x65xtension_number\x18\x02 \x01(\x05\"\xb8\x03\n\x18ServerReflectionResponse\x12\x12\n\nvalid_host\x18\x01 \x01(\t\x12\x45\n\x10original_request\x18\x02 \x01(\x0b\x32+.grpc.reflection.v1.ServerReflectionRequest\x12N\n\x18\x66ile_descriptor_response\x18\x04 \x01(\x0b\x32*.grpc.reflection.v1.FileDescriptorResponseH\x00\x12U\n\x1e\x61ll_extension_numbers_response\x18\x05 \x01(\x0b\x32+.grpc.reflection.v1.ExtensionNumberResponseH\x00\x12I\n\x16list_services_response\x18\x06 \x01(\x0b\x32\'.grpc.reflection.v1.ListServiceResponseH\x00\x12;\n\x0e\x65rror_response\x18\x07 \x01(\x0b\x32!.grpc.reflection.v1.ErrorResponseH\x00\x42\x12\n\x10message_response\"7\n\x16\x46ileDescriptorResponse\x12\x1d\n\x15\x66ile_descriptor_proto\x18\x01 \x03(\x0c\"K\n\x17\x45xtensionNumberResponse\x12\x16\n\x0e\x62\x61se_type_name\x18\x01 \x01(\t\x12\x18\n\x10\x65xtension_number\x18\x02 \x03(\x05\"K\n\x13ListServiceResponse\x12\x34\n\x07service\x18\x01 \x03(\x0b\x32#.grpc.reflection.v1.ServiceResponse\"\x1f\n\x0fServiceResponse\x12\x0c\n\x04name\x18\x01 \x01(\t\":\n\rErrorResponse\x12\x12\n\nerror_code\x18\x01 \x01(\x05\x12\x15\n\rerror_message\x18\x02 \x01(\t2\x89\x01\n\x10ServerReflection\x12u\n\x14ServerReflectionInfo\x12+.grpc.reflection.v1.ServerReflectionRequest\x1a,.grpc.reflection.v1.ServerReflectionResponse(\x01\x30\x01\x42\x66\n\x15io.grpc.reflection.v1B\x15ServerReflectionProtoP\x01Z4google.golang.org/grpc/reflection/grpc_reflection_v1b\x06proto3"
+
+pool = Google::Protobuf::DescriptorPool.generated_pool
+pool.add_serialized_file(descriptor_data)
+
+module Grpc
+  module Reflection
+    module V1
+      ServerReflectionRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ServerReflectionRequest").msgclass
+      ExtensionRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ExtensionRequest").msgclass
+      ServerReflectionResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ServerReflectionResponse").msgclass
+      FileDescriptorResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.FileDescriptorResponse").msgclass
+      ExtensionNumberResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ExtensionNumberResponse").msgclass
+      ListServiceResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ListServiceResponse").msgclass
+      ServiceResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ServiceResponse").msgclass
+      ErrorResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.reflection.v1.ErrorResponse").msgclass
+    end
+  end
+end

data/lib/itsi/server/grpc/reflection/v1/reflection_services_pb.rb

@@ -0,0 +1,122 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# Source: reflection.proto for package 'grpc.reflection.v1'
+# Original file comments:
+# Copyright 2016 The gRPC Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Service exported by server reflection.  A more complete description of how
+# server reflection works can be found at
+# https://github.com/grpc/grpc/blob/master/doc/server-reflection.md
+#
+# The canonical version of this proto can be found at
+# https://github.com/grpc/grpc-proto/blob/master/grpc/reflection/v1/reflection.proto
+#
+
+require "grpc"
+require_relative "reflection_pb"
+
+module Grpc
+  module Reflection
+    module V1
+      module ServerReflection
+        class Service
+          include ::GRPC::GenericService
+
+          self.marshal_class_method = :encode
+          self.unmarshal_class_method = :decode
+          self.service_name = "grpc.reflection.v1.ServerReflection"
+
+          # The reflection service is structured as a bidirectional stream, ensuring
+          # all related requests go to a single server.
+          rpc :ServerReflectionInfo, stream(::Grpc::Reflection::V1::ServerReflectionRequest),
+              stream(::Grpc::Reflection::V1::ServerReflectionResponse)
+
+          def initialize(handlers)
+            @handlers = handlers
+            super()
+          end
+
+          def server_reflection_info(req, _unused_call)
+            req.each do |request|
+              res = Grpc::Reflection::V1::ServerReflectionResponse.new
+
+              if !request.list_services.empty?
+                res.list_services_response = Grpc::Reflection::V1::ListServiceResponse.new(service: list_services_response)
+              elsif !request.file_containing_symbol.empty?
+                res.file_descriptor_response = Grpc::Reflection::V1::FileDescriptorResponse.new(
+                  file_descriptor_proto: [
+                    Google::Protobuf::FileDescriptorProto.encode(Google::Protobuf::DescriptorPool.generated_pool.lookup(request.file_containing_symbol).file_descriptor.to_proto)
+                  ]
+                )
+              elsif !request.file_by_filename.empty?
+                # Handle file_by_filename requests
+                file_descriptor = find_file_descriptor_by_filename(request.file_by_filename)
+                if file_descriptor
+                  res.file_descriptor_response = Grpc::Reflection::V1::FileDescriptorResponse.new(
+                    file_descriptor_proto: [Google::Protobuf::FileDescriptorProto.encode(file_descriptor)]
+                  )
+                else
+                  res.error_response = Grpc::Reflection::V1::ErrorResponse.new(
+                    error_code: 5, # NOT_FOUND
+                    error_message: "File not found: #{request.file_by_filename}"
+                  )
+                end
+              end
+              yield res
+              # We can loop here if running in Fiber mode, but for best compatibility with blocking IO modes
+              # we'll close the connection and force the client to reconnect force
+              # subsequent reflection requests
+              break
+            end
+          end
+
+          def find_file_descriptor_by_filename(filename)
+            # First try direct lookup in the pool
+
+            descriptor = Google::Protobuf::DescriptorPool.generated_pool.lookup(filename)&.file_descriptor
+            return descriptor.to_proto if descriptor
+
+            proto_name = convert_file_path_to_proto_name(filename)
+            descriptor = Google::Protobuf::DescriptorPool.generated_pool.lookup(proto_name)&.file_descriptor
+            return descriptor.to_proto if descriptor
+
+            nil
+          end
+
+          def convert_file_path_to_proto_name(file_path)
+            # Remove .proto extension
+            file_path = file_path.sub(/\.proto$/, "")
+
+            # Split path into parts
+            parts = file_path.split("/")
+
+            # Convert last part to PascalCase (e.g., money -> Money)
+            parts[-1] = parts[-1].split("_").map(&:capitalize).join
+
+            # Join with dots
+            parts.join(".")
+          end
+
+          def list_services_response
+            @list_services_response ||= @handlers.map(&:class).map(&:service_name).map do |name|
+              Grpc::Reflection::V1::ServiceResponse.new(name: name)
+            end
+          end
+        end
+
+        Stub = Service.rpc_stub_class
+      end
+    end
+  end
+end

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

@@ -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}"]
+          }
+        )
+      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