RubyGems - itsi - Versions diffs - 0.1.14 → 0.1.19 - Mend

itsi 0.1.14 → 0.1.19

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.

Files changed (169) hide show

data/gems/server/lib/itsi/server/default_app/index.html CHANGED Viewed

@@ -1,91 +1,115 @@
-<!DOCTYPE html>
+<!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>
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Itsi - Default</title>
+    <style>
+      :root {
+        --bg-color: #f0f2f5;
+        --text-color: #333;
+        --link-color: #0052cc;
+      }
+      *,
+      *::before,
+      *::after {
+        box-sizing: border-box;
+      }
+      body {
+        margin: 0;
+        font-family: "Helvetica Neue", Arial, sans-serif;
+        background: var(--bg-color);
+        color: var(--text-color);
+        line-height: 1.6;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        padding: 3rem 1rem;
+      }
+      header {
+        text-align: center;
+        margin-bottom: 2rem;
+      }
+      h1 {
+        font-size: 2.5rem;
+        margin-bottom: 0.5rem;
+      }
+      p {
+        font-size: 1.5rem;
+        margin-bottom: 2rem;
+        color: #555;
+      }
+      ul.fields {
+        list-style: none;
+        padding: 0;
+        margin: 0;
+        max-width: 100%%;
+        width: 100%%;
+      }
+      ul.fields li {
+        display: flex;
+        justify-content: space-between;
+        padding: 1rem;
+        border-bottom: 1px solid #ddd;
+      }
+      ul.fields li:last-child {
+        border-bottom: none;
+      }
+      .label {
+        font-weight: bold;
+        margin-right: 1rem;
+      }
+      /* Make it expansive: let content use more horizontal space on larger screens */
+      main {
+        max-width: 1200px;
+        width: 100%%;
+      }
+      /* Responsive adjustments for small devices */
+      @media (max-width: 480px) {
+        h1 {
+          font-size: 2.5rem;
+        }
+        p {
+          font-size: 1.2rem;
+        }
+        ul.fields li {
+          padding: 0.75rem;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <header>
+        <h1>You're running on Itsi!</h1>
+        <p>RACK environment:</p>
+      </header>
+      <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>
+    </main>
+  </body>
 </html>

data/gems/server/lib/itsi/server/{Itsi.rb → default_config/Itsi-rackup.rb} RENAMED Viewed

@@ -12,7 +12,7 @@ env = ENV.fetch("APP_ENV") { ENV.fetch("RACK_ENV", "development") }
 # If more than 1, Itsi will be booted in Cluster mode
 workers ENV.fetch("ITSI_WORKERS") {
   require "etc"
-  env == "development" ? 1 : Etc.nprocessors
+  env == "development" ? 1 : nil
 }
 # Number of threads to spawn per worker process

data/gems/server/lib/itsi/server/default_config/Itsi.rb ADDED Viewed

@@ -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_threshold_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 :ansi or :json. If you leave it blank Itsi will try
+# and auto-detect the format based on the TTY environment.
+log_format :auto

data/gems/server/lib/itsi/server/grpc/grpc_call.rb ADDED Viewed

@@ -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/gems/server/lib/itsi/server/grpc/grpc_interface.rb ADDED Viewed

@@ -0,0 +1,100 @@
+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
+        @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)
+        unless (active_call.rpc_desc = service_class.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
+        service.send(active_call.method_name, message, active_call) do |response|
+          active_call.remote_send(response)
+        end
+      end
+      def handle_bidi_streaming(active_call)
+        service.send(active_call.method_name, active_call.each_remote_read, active_call) do |response|
+          active_call.remote_send(response)
+        end
+      end
+    end
+  end
+end