itsi 0.1.14 → 0.1.19

data/sandbox/itsi_file/Itsi.rb

@@ -1,150 +1,360 @@
 workers 1
 threads 1
+fiber_scheduler true
+
+scheduler_threads 1
+
+request_timeout 2
 
 preload false
 
 bind 'http://localhost:3000'
-bind 'http://0.0.0.0:8000'
 
-shutdown_timeout 3
-multithreaded_reactor true
+shutdown_timeout 10
 
-watch '*.rb', [%w[bundle exec itsi restart]]
+auto_reload_config!
 
-def user_serve(request)
-  response = request.response
-  response.status = 200
-  response.add_header('Content-Type', 'text/plain')
-  response << 'Hello, user!'
-  response.close
-end
+log_level :debug
+log_format :plain
 
-def user_create(request)
-  response = request.response
-  response.status = 201
-  response.add_header('Content-Type', 'text/plain')
-  response << 'User created!'
-  response.close
+get "/root" do |req|
+  req.ok "Got from root"
 end
 
-location "/etag-test" do
-  etag type: 'strong', algorithm: 'sha256', min_body_size: 0
 
-  get '/' do |req|
-    # Fixed content that will generate the same ETag each time
-    content = "This is a fixed response that will always have the same ETag."
-
-    # Add a timestamp as a comment to see the response is fresh
-    resp = req.response
-    req.respond("Content: #{content}.# Generated at: #{Time.now}")
+location "app" do
+  location "/users" do
+    get "/:id" do |req|
+      req.ok "Got user #{req.url_params[:id]}"
+    end
   end
+
+  run(->(env){
+    [200, {}, ["Fallback Rack app"]]
+  })
 end
 
 
-location "/cached-with-etag" do
-  # Set up caching parameters
-  cache_control max_age: 3600, public: true, vary: ['Accept-Encoding']
+static_assets \
+  relative_path: true,
+  root_dir: "public",
+  not_found_behavior: "fallthrough",
+  try_html_extension: true,
+  auto_index: true,
+  max_file_size_in_memory: 1024 * 1024,
+  max_files_in_memory: 1000,
+  file_check_interval: 5,
+  serve_hidden_files: false
+
+run(->(env){
+  [200, {}, ["Final Fallback Rack App. SN: #{env['SCRIPT_NAME']} PI: #{env['PATH_INFO']}"]]
+})
+# location %q{/foo/:id(\d+)/test/:name/bla} do
+#   get "/" do |req|
+#     req.respond json: req.url_params
+#   end
+# end
 
-  # Add ETags for cache validation
-  etag type: 'weak', algorithm: 'md5', min_body_size: 0
+# location "blocking" do
+#   run ->(env){
+#     sleep 0.25
+#     [200, {}, [:ok]]
+#   }
+# end
 
-  get '/' do |req|
-    req.respond("This response will have both cache headers and an ETag.")
-  end
-end
+# location "nonblocking" do
+#   run(->(env){
+#     sleep 0.25
+#     [200, {}, [:ok]]
+#   }, nonblocking: true)
+# end
 
+# require_relative 'echo_service/echo_service_impl'
 
-location "/" do
-  intrusion_protection banned_time_seconds: 5, banned_url_patterns: [/\/admin/, /\/secret/], store_config: { redis: { connection_url: 'redis://localhost:6379/0' } }, error_response: { plaintext: 'no way', code: 403, default: 'plaintext' }
+# grpc EchoServiceImpl.new, nonblocking: false do
+# end
 
-  # Example for API endpoints with ETags
-  location "/api" do
-    etag type: 'weak', algorithm: 'md5', min_body_size: 0
-    get '/users/id' do |req|
-      user_id = 5
-      req.respond("User data for #{user_id}")
-    end
-  end
+# location "foo" do
+#   static_response code: 200, headers: [["Headers","Foo"]], body: "This is my body"
+# end
 
-  location "/hey" do
-    location "/world*" do
-      request_headers additions: {"X-Custom-Req" => ["Foo", "Bar", "Baz"]}, removals: [""]
-      response_headers additions: {"X-Custom-Resp" => ["Foo", "Bar"]}, removals: []
-      rate_limit requests: 5, seconds: 30, key: 'address', store_config: { redis: { connection_url: 'redis://localhost:6379/0' } }, error_response: { plaintext: 'no way', code: 429, default: 'plaintext' }
-      post '/' do |req|
-        puts "I'm a post!"
-        req.respond("Post successful!")
-      end
-      get '/' do |req|
-        puts "Headers are", "#{req["foo"]}"
-        req.respond("Is this still fast?")
-      end
-    end
-  end
+# location "/public" do
+#   static_assets relative_path: true, root_dir: "public", not_found_behavior: {error: 'not_found'},
+#     try_html_extension: true, auto_index: true, max_file_size_in_memory: 1024 * 1024,
+#       # Maximum number of files to keep in memory cache
+#       max_files_in_memory: 1000,
+#       # Check for file modifications every 5 seconds
+#       file_check_interval: 5,
+#       serve_hidden_files: false
+# end
 
-  # Add a new location with cache_control middleware
-  location "/cached" do
-    cache_control max_age: 3600, public: true, vary: ['Accept-Encoding']
-    get '/' do |req|
-      req.respond("This content is cached for 1 hour.")
-    end
-  end
+# require 'debug'
+# require 'date'
 
-  location "/etag" do
-    etag enabled: true, etag_type: 'strong', hash_algorithm: 'sha256', min_body_size: 0
-    get '/' do |req|
-      # Create a response large enough to be worth ETagging
-      content = "This content will have ETags. " * 20
-      req.respond(content)
-    end
-  end
-end
+# UserSchema = {
+#   id: Integer,
+#   name: String
+# }
 
 
+# ResultSchema = {
+#   status_code: Integer,
+#   user: UserSchema
+# }
 
-# For an assets example
-location "/assets" do
-  cache_control max_age: 604800, s_max_age: 2592000,
-               stale_while_revalidate: 86400,
-               public: true, immutable: true
+# module UserController
 
-  get "/:file" do |req|
-    file_name = req.params["file"]
-    req.respond("Pretending to serve #{file_name} with long-lived caching")
-  end
-end
+#   def self.create(req)
+#     req.ok \
+#       json: {
+#         status: :created,
+#         user: user
+#       }
+#   end
+
+#   def self.create(req, params: UserSchema, return_type: ResultSchema)
+#     req.ok \
+#       json: {
+#         status_code: 5,
+#         user: params
+#       },
+#       as: return_type
+#   end
+
+#   def self.create_no_type(req, params)
+#     req.ok json: "foo"
+#   end
+
+# end
+
+# controller UserController
+# post "/", :create
+# get "/" do |req, return_type: ResultSchema|
+#   req.ok as: return_type, json: {
+#     status_code: 5,
+#     user: {
+#       id: 3,
+#       name: "Foo Bar"
+#     }
+#   }
+# end
+
+# post "/nt", :create_no_type
+
+# location "/rack" do
+#   run(->(env){
+#     sleep 5
+#     [200, {}, [:ok]]
+#   })
+# end
+# location '*' do
+#   proxy to: 'http://{host}{path_and_query}', backends: ['127.0.0.1:8082','127.0.0.1:8080', '127.0.0.1:8081'], headers: {}, verify_ssl: false, timeout: 1, tls_sni: false, backend_priority: 'round_robin'
+# end
 
-# location '' do
-
-  # location '/spa' do
-  #   # Serve static files from the "public/assets" directory
-  #   log_requests before: { format: "REQUEST_ID={request_id}  METHOD={method} PATH={path} QUERY={query} HOST={host} PORT={port} START_TIME={start_time}" , level: 'INFO'}, after: { format: "REQUEST_ID={request_id} RESPONSE_TIME={response_time}", level: 'INFO' }
-  #   allow_list allowed_patterns: [/127.*/], error_response: { plaintext: 'no way', code: 401, default: 'plaintext' }
-  #   static_assets\
-  #     relative_path: true,
-  #     root_dir: 'spa/dist',
-  #     # # Only allow certain file extensions
-  #     # allowed_extensions: %w[css js jpg jpeg png gif svg ico woff woff2 ttf
-  #     #                        otf html],
-  #     # Return a 404 error if file is not found
-  #     not_found_behavior: { index: 'index.html' },
-  #     # Enable auto-indexing of directories
-  #     auto_index: true,
-  #     # Try adding .html extension to extensionless URLs
-  #     try_html_extension: true,
-  #     # Files under this size are cached in memory
-  #     max_file_size_in_memory: 1024 * 1024, # 1MB
-  #     # Maximum number of files to keep in memory cache
-  #     max_files_in_memory: 1000,
-  #     # Check for file modifications every 5 seconds
-  #     file_check_interval: 5,
-  #     # Add custom headers to all responses
-  #     headers: {
-  #       'Cache-Control' => 'public, max-age=86400',
-  #       'X-Content-Type-Options' => 'nosniff'
-  #     }
-  #   compress algorithms: ['zstd'], min_size: 0, compress_streams: true, mime_types: ['all'], level: 'fastest'
-  # end
+# # require_relative 'echo_service/echo_service_impl'
+
+# # grpc EchoServiceImpl.new do
+
+# # end
+
+# location '/' do
+#   # compress algorithms: ['zstd'], min_size: 0, compress_streams: true, mime_types: ['all'], level: 'fastest'
+#   max_body max_size: 5
+#   get '/' do |req|
+#     req.respond('Foo')
+#   end
+#   etag type: 'weak', algorithm: 'md5', min_body_size: 0
+#   post '/' do |req|
+#     puts "Post to me!"
+#         req.respond('Foo')
+#   end
+# end
+
+# location '/' do
+# end
+# rate_limit requests: 5, seconds: 5, key: 'address', store_config: { redis: { connection_url: 'redis://localhost:6379/0' } }, error_response: { plaintext: 'no way', code: 429, default: 'plaintext' }
+
+#
+
+# static_assets\
+#   relative_path: true,
+#   root_dir: 'spa/dist',
+#   # # Only allow certain file extensions
+#   # allowed_extensions: %w[css js jpg jpeg png gif svg ico woff woff2 ttf
+#   #                        otf html],
+#   # Return a 404 error if file is not found
+#   not_found_behavior: { index: 'index.html' },
+#   # Enable auto-indexing of directories
+#   auto_index: true,
+#   # Try adding .html extension to extensionless URLs
+#   try_html_extension: true,
+#   # Files under this size are cached in memory
+#   max_file_size_in_memory: 1024 * 1024, # 1MB
+#   # Maximum number of files to keep in memory cache
+#   max_files_in_memory: 1000,
+#   # Check for file modifications every 5 seconds
+#   file_check_interval: 5,
+#   # Add custom headers to all responses
+#   headers: {
+#     'Cache-Control' => 'public, max-age=86400',
+#     'X-Content-Type-Options' => 'nosniff'
+#   }
+
+# run(lambda  { |env|
+#   [200, {}, ["I'm a fallback"]]
+# })
+
+# def user_serve(request)
+#   response = request.response
+#   response.status = 200
+#   response.add_header('Content-Type', 'text/plain')
+#   response << 'Hello, user!'
+#   response.close
+# end
+
+# def user_create(request)
+#   response = request.response
+#   response.status = 201
+#   response.add_header('Content-Type', 'text/plain')
+#   response << 'User created!'
+#   response.close
+# end
+
+# location "/etag-test" do
+#   etag type: 'strong', algorithm: 'sha256', min_body_size: 0
+
+#   get '/' do |req|
+#     # Fixed content that will generate the same ETag each time
+#     content = "This is a fixed response that will always have the same ETag."
+
+#     # Add a timestamp as a comment to see the response is fresh
+#     resp = req.response
+#     req.respond("Content: #{content}.# Generated at: #{Time.now}")
+#   end
+# end
+
+# location "/cached-with-etag" do
+#   # Set up caching parameters
+#   cache_control max_age: 3600, public: true, vary: ['Accept-Encoding']
+
+#   # Add ETags for cache validation
+#   etag type: 'weak', algorithm: 'md5', min_body_size: 0
+
+#   get '/' do |req|
+#     req.respond("This response will have both cache headers and an ETag.")
+#   end
+# end
+
+# location "/" do
+#   intrusion_protection banned_time_seconds: 5, banned_url_patterns: [/\/admin/, /\/secret/], store_config: { redis: { connection_url: 'redis://localhost:6379/0' } }, error_response: { plaintext: 'no way', code: 403, default: 'plaintext' }
+
+#   # Example for API endpoints with ETags
+#   location "/api" do
+#     etag type: 'weak', algorithm: 'md5', min_body_size: 0
+#     get '/users/id' do |req|
+#       user_id = 5
+#       req.respond("User data for #{user_id}")
+#     end
+#   end
+
+#   location "/hey" do
+#     location "/world*" do
+#       request_headers additions: {"X-Custom-Req" => ["Foo", "Bar", "Baz"]}, removals: [""]
+#       response_headers additions: {"X-Custom-Resp" => ["Foo", "Bar"]}, removals: []
+#       rate_limit requests: 5, seconds: 30, key: 'address', store_config: { redis: { connection_url: 'redis://localhost:6379/0' } }, error_response: { plaintext: 'no way', code: 429, default: 'plaintext' }
+#       post '/' do |req|
+#         puts "I'm a post!"
+#         req.respond("Post successful!")
+#       end
+#       get '/' do |req|
+#         req.respond("Is this still fast?")
+#       end
+#     end
+#   end
+
+#   # Add a new location with cache_control middleware
+#   location "/cached" do
+#     cache_control max_age: 3600, public: true, vary: ['Accept-Encoding']
+#     get '/' do |req|
+#       req.respond("This content is cached for 1 hour.")
+#     end
+#   end
+
+#   location "/etag" do
+#     etag enabled: true, etag_type: 'strong', hash_algorithm: 'sha256', min_body_size: 0
+#     get '/' do |req|
+#       # Create a response large enough to be worth ETagging
+#       content = "This content will have ETags. " * 20
+#       req.respond(content)
+#     end
+#   end
+
+#   location "/jwt" do
+#     auth_jwt token_source: { header: { name: 'Authorization', prefix: 'Bearer ' } },
+#       verifiers: {
+#         'hs256' => ["1V6nZzztO/F6Y3XAYXJ1I37AAXCJ/V7EVHJoVnD8lr4="],
+#         'rs256' => [%Q{
+#           -----BEGIN PUBLIC KEY-----
+#           MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAs8XK+wP7nnKkOGXP6+il
+#           +JDQMFRV8zoVg1BYYapGla6AzR0YCV6xq28lNB1FE8C6xhCEKYiOlnkXZwj+a4UW
+#           q4Bex/U9qvfza0zGxHlTnQT9T+vjwXNsWYuefYC4EAZjEd6bGeP23De128QfhlLc
+#           oQpcfW32/e8KjSYtn8rtWuKV6Anqf92o9zEbVn8y2OZwZbiW0LbfDnimazqP5ATy
+#           SI6a5kQorBeG9cU4WW93ctuT5nkyAbBaEpiejWIpjbMkofD5fj2pUgg7H/Xvh+eR
+#           S9A+//VGfy4A4SFjBooVewhJ04VhDkMnVC29fbVwVuNqm6Z+FZaxI5pqvisxvH8S
+#           XwIDAQAB
+#           -----END PUBLIC KEY-----
+#           }]
+#   },  error_response: { code: 401, plaintext: 'Unauthorized', default: 'plaintext' }
+#     get "/" do |req|
+#       req.respond('Hello, JWT user!')
+#     end
+#   end
+
+# end
+
+# # For an assets example
+# location "/assets" do
+#   cache_control max_age: 604800, s_max_age: 2592000,
+#                stale_while_revalidate: 86400,
+#                public: true, immutable: true
+
+#   get "/:file" do |req|
+#     file_name = req.params["file"]
+#     req.respond("Pretending to serve #{file_name} with long-lived caching")
+#   end
+# end
+
+# # location '' do
+
+# location '/spa' do
+#   # Serve static files from the "public/assets" directory
+#   log_requests before: { format: "REQUEST_ID={request_id}  METHOD={method} PATH={path} QUERY={query} HOST={host} PORT={port} START_TIME={start_time}" , level: 'INFO'}, after: { format: "REQUEST_ID={request_id} RESPONSE_TIME={response_time}", level: 'INFO' }
+#   allow_list allowed_patterns: [/127.*/], error_response: { plaintext: 'no way', code: 401, default: 'plaintext' }
+#   static_assets\
+#     relative_path: true,
+#     root_dir: 'spa/dist',
+#     # # Only allow certain file extensions
+#     # allowed_extensions: %w[css js jpg jpeg png gif svg ico woff woff2 ttf
+#     #                        otf html],
+#     # Return a 404 error if file is not found
+#     not_found_behavior: { index: 'index.html' },
+#     # Enable auto-indexing of directories
+#     auto_index: true,
+#     # Try adding .html extension to extensionless URLs
+#     try_html_extension: true,
+#     # Files under this size are cached in memory
+#     max_file_size_in_memory: 1024 * 1024, # 1MB
+#     # Maximum number of files to keep in memory cache
+#     max_files_in_memory: 1000,
+#     # Check for file modifications every 5 seconds
+#     file_check_interval: 5,
+#     # Add custom headers to all responses
+#     headers: {
+#       'Cache-Control' => 'public, max-age=86400',
+#       'X-Content-Type-Options' => 'nosniff'
+#     }
+#   compress algorithms: ['zstd'], min_size: 0, compress_streams: true, mime_types: ['all'], level: 'fastest'
+# end
 # end
 
 # location "/cors_test" do
@@ -154,17 +364,7 @@ end
 #   end
 # end
 
-# location "/basic" do
-#   auth_basic realm: 'My Realm', credential_pairs: { 'user' => 'password' }
-# end
 
-# location "/jwt" do
-#   auth_jwt token_source: { header: { name: 'Authorization', prefix: 'Bearer ' } }, verifiers: {'hs256' => ["1V6nZzztO/F6Y3XAYXJ1I37AAXCJ/V7EVHJoVnD8lr4="]
-# },  error_response: { code: 401, plaintext: 'Unauthorized', default: 'plaintext' }
-#   get "/" do |req|
-#     req.respond('Hello, JWT user!')
-#   end
-# end
 
 # location '/proxy_as_foo_com' do
 #   compress algorithms: ['zstd'], min_size: 0, compress_streams: true, mime_types: ['all'], level: 'fastest'
@@ -229,7 +429,6 @@ end
 #   req.respond("This is a test")
 # end
 
-
 # location '*', protocols: :http do
 #   location 'foo' do
 #     redirect to: 'https://{host}:3001{path}'
@@ -272,5 +471,4 @@ end
 
 # Example with both caching and ETags
 
-
 # Simple ETag test endpoint with predictable content

data/sandbox/itsi_file/call.json

@@ -0,0 +1 @@
+{"message": "Hello, World!"}

data/sandbox/itsi_file/echo_client/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem 'grpc', '~> 1.50'
+gem 'grpc-tools', '~> 1.50'
+
+# Ensure we use the same version of protocol buffers
+gem 'google-protobuf', '~> 3.21'
+
+# For pretty printing
+gem 'colorize', '~> 0.8.1' 

data/sandbox/itsi_file/echo_client/Gemfile.lock

@@ -0,0 +1,27 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    colorize (0.8.1)
+    google-protobuf (3.25.6)
+    googleapis-common-protos-types (1.19.0)
+      google-protobuf (>= 3.18, < 5.a)
+    grpc (1.71.0)
+      google-protobuf (>= 3.25, < 5.0)
+      googleapis-common-protos-types (~> 1.0)
+    grpc (1.71.0-arm64-darwin)
+      google-protobuf (>= 3.25, < 5.0)
+      googleapis-common-protos-types (~> 1.0)
+    grpc-tools (1.71.0)
+
+PLATFORMS
+  arm64-darwin-23
+  ruby
+
+DEPENDENCIES
+  colorize (~> 0.8.1)
+  google-protobuf (~> 3.21)
+  grpc (~> 1.50)
+  grpc-tools (~> 1.50)
+
+BUNDLED WITH
+   2.6.3

data/sandbox/itsi_file/echo_client/README.md

@@ -0,0 +1,95 @@
+# Echo gRPC Client
+
+A simple Ruby gRPC client for the Echo service.
+
+## Setup
+
+1. Install dependencies:
+
+```bash
+bundle install
+```
+
+2. Generate Ruby code from the proto file:
+
+```bash
+./gen_proto.sh
+```
+
+## Usage
+
+Run the client with optional compression:
+
+```bash
+# Run without compression (default)
+ruby echo_client.rb
+
+# Run with gzip compression
+ruby echo_client.rb gzip
+
+# Run with deflate compression
+ruby echo_client.rb deflate
+
+# Show help
+ruby echo_client.rb help
+```
+
+## Client Details
+
+This client implements all four types of gRPC methods:
+
+1. Unary RPC (`echo`)
+2. Server streaming RPC (`echo_stream`)
+3. Client streaming RPC (`echo_collect`)
+4. Bidirectional streaming RPC (`echo_bidirectional`)
+
+## Compression Options
+
+You can control compression by modifying the client initialization in `echo_client.rb`:
+
+```ruby
+# No compression
+client = EchoClient.new('localhost', 50051, compression: nil)
+
+# Gzip compression
+client = EchoClient.new('localhost', 50051, compression: :gzip)
+
+# Deflate compression
+client = EchoClient.new('localhost', 50051, compression: :deflate)
+```
+
+The compression settings are implemented using the gRPC channel arguments, which allows you to test different compression algorithms.
+
+## Troubleshooting
+
+If you encounter any issues:
+
+1. Make sure you have installed all dependencies with `bundle install`
+2. Ensure the protocol buffer code has been generated with `./gen_proto.sh`
+3. Check that the gRPC server is running on the specified host and port
+4. If you see connectivity issues, try running with debugging enabled:
+
+```bash
+GRPC_VERBOSITY=DEBUG GRPC_TRACE=all ruby echo_client.rb
+```
+
+## Example Server
+
+The client is designed to work with the EchoService server in the `../echo_service_nonitsi` directory. Make sure the server is running before starting the client.
+
+## Compression Testing
+
+To test different compression algorithms with the same message payload:
+
+```bash
+# Test without compression
+./run_client.rb -m "Large message repeated many times" -c none
+
+# Test with gzip compression
+./run_client.rb -m "Large message repeated many times" -c gzip
+
+# Test with deflate compression
+./run_client.rb -m "Large message repeated many times" -c deflate
+```
+
+This allows you to compare the performance and behavior with different compression settings.