morio_bridge 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f0fce2880ec932e61fa2a9d3d80633b0c9da60ec447e045648ffd1dab279515e
+  data.tar.gz: 5fd1cb1b6e08879d422ea65f7628ecd3853da98e97697055144bf0feaedab86d
+SHA512:
+  metadata.gz: 706bb1b76e072fb7cb5f4ecdf20e7e06bfc1f2ee074df488047bebe8970c4bdf05158598a4659b1af284039f1bf6911e6a8d052469749a29023a7fdc7dd80ff7
+  data.tar.gz: 51c0fc4554e5a12871e36f400c1a15b317c4a7d12fe3cf9c193c1ec19f3483a6180775c3d3f49c0d110217d954828d502bf397d4b7b645692dca52a69b854dec

data/bin/post-install.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+
+
+#===============================================
+# 
+#   Install dependencies
+# 
+#===============================================
+# Install Bun
+curl -fsSL https://bun.sh/install | bash -s "bun-v1.2.13"
+
+
+# install global dependencies
+bun install -g prisma@6.8.2 @prisma/client@6.8.2 @prisma/adapter-pg@6.8.2 fastest-validator@1.19.1 pg@8.16.0
+
+# add bun to the path and save it to the .bashrc and source it
+export PATH="$HOME/.bun/bin:$PATH"
+echo "export PATH=\"$HOME/.bun/bin:$PATH\"" >> ~/.bashrc
+source ~/.bashrc
+
+# upgrade bun to the latest version
+bun upgrade
+
+# Verify installation
+echo "dependencies installed successfully"
+echo "installed bun v$(bun --version)"
+
+
+#===============================================
+# 
+#   Build plugins
+# 
+#===============================================
+echo "building plugins ..."
+
+mkdir -p $HOME/.morio/bin
+rm -rf $HOME/.morio/bin/server-*
+rm -rf bin/server-*
+
+IS_DOCKER="$1"
+PLATFORM="$2"
+ARCH="$3"
+OUTPUT=$HOME/.morio/bin/bridge_server.js
+
+
+cd  ./server
+
+bun install
+bun build --target=bun index.ts --outfile "$OUTPUT"
+
+
+
+
+
+
+
+
+

data/lib/morio_bridge.rb

@@ -0,0 +1,482 @@
+# frozen_string_literal: true
+
+require "rubygems"
+require "pathname"
+require "fileutils"
+require "tmpdir"
+require "socket"
+require "json"
+require "logger"
+
+class Error < StandardError; end
+class TimeoutError < Error; end
+
+# Main module for the gem
+module MorioBridge
+  VERSION = "0.1.0"
+
+  class Doctor
+    def self.run
+      stats = JSON.pretty_generate({
+        current_dir: Dir.pwd,
+        bun_path: `which bun`.strip,
+        bun_version: `bun --version`.strip
+      })
+
+      puts stats
+    end
+  end
+
+  class Client
+    attr_reader :instance
+
+    def initialize(base_socket_dir = nil)
+      @server_path = File.expand_path(File.join(Dir.home, ".morio/bin/bridge_server.js"))
+      @bun_path = File.expand_path(File.join(Dir.home, ".bun/bin/bun"))
+      @base_socket_dir = base_socket_dir || Dir.mktmpdir("prisma")
+      @socket_paths = fetch_socket_paths(6)
+      @socket_connections = []
+      @socket_status = []
+      @socket_index = 0
+      @pid = nil
+      @started = false
+      @starting = false
+      @instance = nil
+      @logger = Logger.new($stdout)
+
+      return unless !@testing_mode && defined?(Morio)
+
+      # morio global logger
+      @logger = Morio.logger
+    end
+
+    #
+    # [ Lifecycle ]
+    #
+    def start
+      @starting = true
+
+      begin
+        FileUtils.mkdir_p(@base_socket_dir)
+        FileUtils.chmod(0o700, @base_socket_dir)
+
+        env = {
+          "MORIO_RB_BUN_SOCKETS" => @socket_paths.join(","),
+          "MORIO_RB_PWD" => Dir.pwd
+        }
+
+        # Start server in background thread immediately
+        server_thread = Thread.new do
+          # Create pipes for stdout and stderr
+          out_read, out_write = IO.pipe
+          err_read, err_write = IO.pipe
+
+          @pid = Process.spawn(
+            env,
+            "#{@bun_path} #{@server_path}",
+            err: err_write,
+            out: out_write,
+            pgroup: true,
+            close_others: true
+          )
+
+          # Close write ends in parent since they are not needed as we dont write anything to the child process
+          out_write.close
+          err_write.close
+
+          log_server_output(out_read, err_read)
+
+          Process.detach(@pid)
+        end
+
+        # Start health check in parallel
+        health_thread = Thread.new { server_healthy? }
+
+        # Wait for both to complete
+        server_thread.join
+        health_thread.join
+
+        # Initialize sockets...
+        threads = @socket_paths.map do |socket_path|
+          Thread.new do
+            socket_healthy?(socket_path)
+            socket = UNIXSocket.new(socket_path)
+            socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1)
+            [socket, true]
+          end
+        end
+        @socket_connections, @socket_status = threads.map(&:value).transpose
+
+        @started = true
+
+        # save instance
+        @instance = self
+
+        at_exit { stop }
+      ensure
+        @starting = false
+      end
+    end
+
+    def stop
+      @logger.debug "Stopping morio_bridge ..."
+
+      # close all the socket connections
+      @socket_connections.each do |connection|
+        connection.close
+      rescue StandardError
+        nil
+      end
+
+      # kill the unix socket cluster process
+      Process.kill("TERM", @pid) if @pid
+
+      # remove the socket directory
+      FileUtils.remove_entry(@base_socket_dir) if File.directory?(@base_socket_dir)
+
+      # set the started flag to false
+      @started = false
+
+      @logger.debug "Stopped the morio_bridge"
+    rescue StandardError
+      nil
+    end
+
+    #
+    # [ Message Handler ]
+    #
+    def request(data, skip_client_start: false)
+      # start the client if it's not already started
+      start unless @started || skip_client_start
+
+      # set the max number of retries
+      max_retries = 3
+      retries = 0
+      timeout = 0.05
+
+      loop do
+        # select a socket in round robin fashion
+        socket = select_socket
+
+        begin
+          # raise an error if the socket is closed
+          raise IOError, "Socket is closed" if socket.closed?
+
+          #=====================================
+          #
+          #  Send Request
+          #
+          #=====================================
+          # generate the request body
+          request = to_socket_format(data)
+
+          # write the request to the socket
+          socket.write_nonblock(request)
+
+          #=====================================
+          #
+          #  Read Response
+          #
+          #=====================================
+          # wait for the socket to be readable
+          readable = socket.wait_readable(timeout)
+
+          # raise an error if the socket is not readable
+          unless readable
+            timeout = 0.002
+            raise TimeoutError, "Command timed out"
+          end
+
+          # read the response from the socket into a string buffer
+          buffer = String.new(capacity: 4096)
+          done = false
+
+          while (chunk = socket.readpartial(4096))
+            buffer << chunk
+            done = true if chunk.include?("\r\n\r\n")
+            break if done
+          end
+
+          #=====================================
+          #
+          #  Parse Response
+          #
+          #=====================================
+          body = to_hash(from_socket_format(buffer))
+          return body
+        rescue Errno::EPIPE, IOError, TimeoutError => _e
+          # retry the connection in case of a communication error
+          retry_failed_connection(socket)
+
+          # increment the retries
+          retries += 1
+
+          # raise an error if the retries exceed the max retries
+          raise Error, "No healthy sockets after #{max_retries} retries" if retries >= max_retries
+
+          # sleep for a short period before retrying - exponential backoff
+          sleep(0.05 * (2**retries))
+          retry
+        end
+      end
+    end
+
+    #
+    # [ Benchmark ]
+    #
+    def benchmark(send_rate_per_second: 600_000, requests_to_be_sent: 10_000)
+      basic_test = lambda do
+        request({ command: "create", body: { name: "John Doe" } })
+      end
+
+      speed_test = lambda do
+        error_count = 0
+        durations = []
+
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+
+        loop_count = 0
+
+        loop do
+          break if loop_count > requests_to_be_sent
+
+          begin
+            duration, _result = UnixClient.with_timing(&basic_test)
+            durations << duration
+          rescue Error => _e
+            error_count += 1
+          end
+
+          loop_count += 1
+
+          sleep(1.0 / send_rate_per_second)
+        end
+
+        duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond) - start) / 1_000_000.0
+        rps = requests_to_be_sent / duration_ms * 1000
+
+        {
+          requests: requests_to_be_sent,
+          send_rate_per_second: send_rate_per_second,
+          duration_ms: duration_ms.round(2),
+          avg_latency_ms: (durations.sum / durations.size).round(2),
+          rps: rps.round(0),
+          errors: error_count
+        }
+      end
+
+      # Run tests in parallel
+      speed_thread = Thread.new { UnixClient.with_timing(&speed_test) }
+      total_duration, results = speed_thread.value
+
+      result = JSON.pretty_generate({ results:, total_duration: })
+
+      # make result gray and dim and log it
+      @logger.info result
+    end
+
+    #
+    # [ Benchmark helpers ]
+    #
+    def self.with_timing(&proc)
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+      result = proc.call
+      end_ns = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+      duration_ms = ((end_ns - start) / 1_000_000.0)
+
+      [duration_ms, result]
+    end
+
+    private
+
+    #
+    # [ Child process Logging helpers ]
+    #
+    def log_server_output(out_read, err_read)
+      # Start threads to read from pipes
+      Thread.new { handle_server_stream(out_read, :info) }
+      Thread.new { handle_server_stream(err_read, :error) }
+    end
+
+    def handle_server_stream(stream, log_level)
+      buffer = String.new
+      while (line = stream.gets)
+        buffer << line
+        next unless line.end_with?("\n")
+
+        message = buffer.chomp
+        # First try as single JSON line
+        begin
+          parsed = JSON.parse(message)
+          @logger.send(log_level, JSON.pretty_generate(parsed))
+          buffer.clear
+        rescue JSON::ParserError
+          # If single line parse failed, check if we have complete JSON
+          begin
+            parsed = JSON.parse(buffer)
+            @logger.send(log_level, JSON.pretty_generate(parsed))
+            buffer.clear
+          rescue JSON::ParserError
+            # Not complete JSON yet, or plain text
+            # Only log and clear if it's definitely not JSON
+
+            # turn off Metrics/BlockNesting:
+            # rubocop:disable Metrics/BlockNesting
+            unless buffer.match?(/[\{\[]/u)
+              @logger.send(log_level, message)
+              buffer.clear
+            end
+            # rubocop:enable Metrics/BlockNesting
+          end
+        end
+      end
+      # Log any remaining buffer content
+      @logger.send(log_level, buffer) unless buffer.empty?
+    end
+
+    #
+    # [ Socket helpers ]
+    #
+    def fetch_socket_paths(socket_server_count)
+      (0..(socket_server_count - 1)).map do |i|
+        File.join(@base_socket_dir, "prisma#{i}.sock")
+      end
+    end
+
+    def select_socket
+      connection = @socket_connections[@socket_index]
+
+      @socket_index = (@socket_index + 1) % @socket_connections.length
+      return connection if @socket_status[@socket_connections.index(connection) || 0]
+
+      @socket_paths.length.times do
+        connection = @socket_connections[@socket_index]
+
+        @socket_index = (@socket_index + 1) % @socket_connections.length
+        return connection if @socket_status[@socket_connections.index(connection) || 0]
+      end
+      raise Error, "No healthy sockets available"
+    end
+
+    def retry_failed_connection(failed_socket)
+      # get the index of the failed socket and return if it doesn't exist
+      failed_connection_id = @socket_connections.index(failed_socket)
+      return unless failed_connection_id
+
+      # set the socket status to false marking it as unhealthy
+      @socket_status[failed_connection_id] = false
+
+      # close the failed socket
+      begin
+        @socket_connections[failed_connection_id].close
+      rescue StandardError
+        nil
+      end
+
+      # get the socket path for the failed socket
+      socket_path = @socket_paths[failed_connection_id]
+
+      # try to reconnect to the socket
+      begin
+        @socket_connections[failed_connection_id] = UNIXSocket.new(socket_path)
+
+        # set the socket status to true marking it as healthy if the connection is successful
+        @socket_status[failed_connection_id] = true
+      rescue Errno::ENOENT, Errno::ECONNREFUSED => e
+        @logger.error "Failed to reconnect to socket #{socket_path}: #{e.message}"
+      end
+    end
+
+    #
+    # [ Health check helpers ]
+    #
+    def socket_healthy?(socket_path)
+      max_connection_attempts = 50
+      connection_attempt = 0
+      base_delay_s = 0.05
+
+      while connection_attempt < max_connection_attempts
+        begin
+          # attempt to connect to the socket if the connection is successful, close the socket and return
+          socket = UNIXSocket.new(socket_path)
+          socket.close
+          return true
+        rescue Errno::ENOENT, Errno::ECONNREFUSED => _e
+          # exponential backoff
+          sleep(base_delay_s * (2**connection_attempt))
+        end
+
+        # increment the connection attempt
+        connection_attempt += 1
+      end
+
+      # raise an error if the connection attempt fails and exceeds the max connection attempts
+      raise TimeoutError, "Could not connect to socket #{socket_path} after #{max_connection_attempts} attempts"
+    end
+
+    def server_healthy?
+      max_connection_attempts = 50
+      connection_attempt = 0
+      base_delay_s = 0.05 # Reduced from 0.1
+
+      while connection_attempt < max_connection_attempts
+        begin
+          socket = UNIXSocket.new(@socket_paths.first)
+          socket.write_nonblock("GET /health HTTP/1.1\r\nContent-Length: 0\r\n\r\n")
+
+          # Reduced timeout
+          if socket.wait_readable(0.05)
+            response = socket.read_nonblock(1024) # Smaller read buffer
+            if response.include?("200") # Simpler check
+              socket.close
+              return true
+            end
+          end
+          socket.close
+        rescue Errno::ENOENT, Errno::ECONNREFUSED, IOError => _e
+          sleep(base_delay_s * (1.5**connection_attempt)) # Less aggressive backoff
+        end
+        connection_attempt += 1
+      end
+
+      raise TimeoutError, "Server failed to start"
+    end
+
+    #
+    # [ socket format helpers ]
+    #
+    def from_socket_format(buffer)
+      lines = buffer.lines
+      status_line = lines[0]
+      matches = status_line.match(%r{HTTP/1\.1 (\d+)})
+      status_code = matches&.captures&.first.to_i || nil
+      body_start = lines.index("\r\n") || lines.length
+      body = lines[(body_start + 1)..]&.join || ""
+
+      # raise an error if the status code is not 200
+      raise Error, "Executable returned #{status_code}: #{body}" unless status_code == 200
+
+      body
+    end
+
+    def to_socket_format(data)
+      body = JSON.generate(data)
+
+      [
+        "POST /prisma/0/call HTTP/1.1",
+        "Content-Type: application/json",
+        "Content-Length: #{body.length}",
+        "",
+        body
+      ].join("\r\n")
+    end
+
+    def to_hash(body)
+      # Validate JSON response
+
+      JSON.parse(body)
+    rescue JSON::ParserError => e
+      raise Error, "Invalid JSON response: #{e.message}, body: #{body.inspect}"
+    end
+  end
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rubygems"
+require "morio_bridge"
+require "English"
+
+Gem.post_install do |installer|
+  if installer.spec.name == "morio_bridge"
+    post_install_script_path = File.expand_path("../bin/post-install.sh", __dir__)
+
+    if File.exist?(post_install_script_path)
+      # Make the script executable
+      File.chmod(0o755, post_install_script_path)
+
+      # Add Bun to PATH
+      ENV["PATH"] = "#{Dir.home}/.bun/bin:#{ENV.fetch('PATH', nil)}"
+
+      # Run the script
+      system("bash #{post_install_script_path}")
+
+      # Check if the script ran successfully
+      if $CHILD_STATUS.success?
+        puts "post installation completed successfully"
+      else
+        puts "post installation failed with exit code #{$CHILD_STATUS.exitstatus}"
+      end
+    else
+      puts "Warning: Could not find post install script at #{post_install_script_path}"
+    end
+  end
+end

data/morio_bridge.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name          = "morio_bridge"
+  spec.version       = "0.1.0"
+  spec.authors       = ["r2g"]
+  spec.email         = ["r2g.technology@gmail.com"]
+  spec.summary       = "A simple Ruby gem with a post-install hook."
+  spec.description   = "This gem demonstrates creating a Ruby gem with a post-install hook that installs Bun."
+  spec.homepage      = "https://github.com/r2g/morio-bridge"
+  spec.license       = "MIT"
+
+  # Specify which files to include in the gem
+  spec.files = Dir[
+    "lib/**/*",
+    "bin/**/*",
+    "README.md",
+    "LICENSE.txt",
+    "*.gemspec"
+  ]
+
+  spec.require_paths = ["lib"]
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+
+  spec.metadata["rubygems_mfa_required"] = "true"
+  spec.required_ruby_version = ">= 3.4.3"
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: morio_bridge
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- r2g
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: This gem demonstrates creating a Ruby gem with a post-install hook that
+  installs Bun.
+email:
+- r2g.technology@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/post-install.sh
+- lib/morio_bridge.rb
+- lib/rubygems_plugin.rb
+- morio_bridge.gemspec
+homepage: https://github.com/r2g/morio-bridge
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: A simple Ruby gem with a post-install hook.
+test_files: []