nonnative 1.27.0

data/lib/nonnative/http_client.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class HTTPClient
+    def initialize(host)
+      @host = host
+    end
+
+    protected
+
+    def get(pathname, headers = {}, timeout = 60)
+      with_exception do
+        uri = URI.join(host, pathname)
+        RestClient::Request.execute(method: :get, url: uri.to_s, headers: headers, timeout: timeout)
+      end
+    end
+
+    def post(pathname, payload, headers = {}, timeout = 60)
+      with_exception do
+        uri = URI.join(host, pathname)
+        RestClient::Request.execute(method: :post, url: uri.to_s, payload: payload.to_json, headers: headers,
+                                    timeout: timeout)
+      end
+    end
+
+    def delete(pathname, headers = {}, timeout = 60)
+      with_exception do
+        uri = URI.join(host, pathname)
+        RestClient::Request.execute(method: :delete, url: uri.to_s, headers: headers, timeout: timeout)
+      end
+    end
+
+    def put(pathname, payload, headers = {}, timeout = 60)
+      with_exception do
+        uri = URI.join(host, pathname)
+        RestClient::Request.execute(method: :put, url: uri.to_s, payload: payload.to_json, headers: headers,
+                                    timeout: timeout)
+      end
+    end
+
+    private
+
+    attr_reader :host
+
+    def with_exception
+      yield
+    rescue RestClient::Exceptions::ReadTimeout => e
+      raise e
+    rescue RestClient::ExceptionWithResponse => e
+      e.response
+    end
+  end
+end

data/lib/nonnative/http_server.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class HTTPServer < Nonnative::Server
+    def initialize(service)
+      log = File.open(service.log, 'a')
+      events = Puma::Events.new(log, log)
+      @server = Puma::Server.new(app, events)
+
+      super service
+    end
+
+    protected
+
+    def perform_start
+      server.add_tcp_listener '0.0.0.0', proxy.port
+      server.run.join
+    end
+
+    def perform_stop
+      server.stop(true)
+    end
+
+    def wait_start
+      timeout.perform do
+        super until server.running
+      end
+    end
+
+    def wait_stop
+      timeout.perform do
+        super while server.running
+      end
+    end
+
+    private
+
+    attr_reader :queue, :server
+  end
+end

data/lib/nonnative/invalid_data_socket_pair.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class InvalidDataSocketPair < SocketPair
+    def write(socket, data)
+      data = data.chars.shuffle.join
+
+      super socket, data
+    end
+  end
+end

data/lib/nonnative/manual.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+# Do nothing as it's manual

data/lib/nonnative/no_proxy.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class NoProxy < Proxy
+    def start
+      # Do nothing.
+    end
+
+    def stop
+      # Do nothing.
+    end
+
+    def port
+      service.port
+    end
+  end
+end

data/lib/nonnative/observability.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class Observability < Nonnative::HTTPClient
+    def health
+      get('health', { content_type: :json, accept: :json })
+    end
+
+    def metrics
+      get('metrics')
+    end
+  end
+end

data/lib/nonnative/pool.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class Pool
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def start(&block)
+      [servers, processes].each { |t| process(t, :start, :open?, &block) }
+    end
+
+    def stop(&block)
+      [processes, servers].each { |t| process(t, :stop, :closed?, &block) }
+    end
+
+    def server_by_name(name)
+      index = configuration.servers.find_index { |s| s.name == name }
+      servers[index].first
+    end
+
+    private
+
+    attr_reader :configuration
+
+    def processes
+      @processes ||= configuration.processes.map do |d|
+        [Nonnative::Command.new(d), Nonnative::Port.new(d)]
+      end
+    end
+
+    def servers
+      @servers ||= configuration.servers.map do |d|
+        [d.klass.new(d), Nonnative::Port.new(d)]
+      end
+    end
+
+    def process(all, type_method, port_method, &block)
+      types = []
+      pids = []
+      threads = []
+
+      all.each do |type, port|
+        types << type
+        pids << type.send(type_method)
+        threads << Thread.new { port.send(port_method) }
+      end
+
+      ports = threads.map(&:value)
+
+      yield_results(types, pids, ports, &block)
+    end
+
+    def yield_results(all, pids, ports)
+      all.zip(pids, ports).each do |type, id, result|
+        yield type.name, id, result
+      end
+    end
+  end
+end

data/lib/nonnative/port.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class Port
+    def initialize(process)
+      @process = process
+      @timeout = Nonnative::Timeout.new(process.timeout)
+    end
+
+    def open?
+      timeout.perform do
+        open_socket
+        true
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+        sleep_interval
+        retry
+      end
+    end
+
+    def closed?
+      timeout.perform do
+        open_socket
+        raise Nonnative::Error
+      rescue Nonnative::Error
+        sleep_interval
+        retry
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNRESET
+        true
+      end
+    end
+
+    private
+
+    attr_reader :process, :timeout
+
+    def open_socket
+      TCPSocket.new('0.0.0.0', process.port).close
+    end
+
+    def sleep_interval
+      sleep 0.01
+    end
+  end
+end

data/lib/nonnative/proxy.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class Proxy
+    def initialize(service)
+      @service = service
+    end
+
+    protected
+
+    attr_reader :service
+  end
+end

data/lib/nonnative/proxy_factory.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class ProxyFactory
+    class << self
+      def create(service)
+        proxy = case service.proxy.type
+                when 'fault_injection'
+                  FaultInjectionProxy
+                else
+                  NoProxy
+                end
+
+        proxy.new(service)
+      end
+    end
+  end
+end

data/lib/nonnative/server.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class Server < Nonnative::Service
+    attr_reader :proxy
+
+    def initialize(service)
+      @proxy = Nonnative::ProxyFactory.create(service)
+
+      super service
+    end
+
+    def start
+      unless thread
+        proxy.start
+        @thread = Thread.new { perform_start }
+
+        wait_start
+      end
+
+      object_id
+    end
+
+    def stop
+      if thread
+        perform_stop
+        thread.terminate
+        proxy.stop
+
+        @thread = nil
+        wait_stop
+      end
+
+      object_id
+    end
+
+    private
+
+    attr_reader :thread
+  end
+end

data/lib/nonnative/service.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class Service
+    def initialize(service)
+      @service = service
+      @timeout = Nonnative::Timeout.new(service.timeout)
+    end
+
+    def name
+      service.name
+    end
+
+    protected
+
+    attr_reader :service, :timeout
+
+    def wait_start
+      sleep 0.1
+    end
+
+    def wait_stop
+      sleep 0.1
+    end
+  end
+end

data/lib/nonnative/socket_pair.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class SocketPair
+    def initialize(proxy, logger)
+      @proxy = proxy
+      @logger = logger
+    end
+
+    def connect(local_socket)
+      remote_socket = create_remote_socket
+
+      loop do
+        ready = select([local_socket, remote_socket], nil, nil)
+
+        break if pipe(ready, local_socket, remote_socket)
+        break if pipe(ready, remote_socket, local_socket)
+      end
+    rescue StandardError => e
+      logger.error e
+    ensure
+      local_socket.close
+      remote_socket&.close
+    end
+
+    protected
+
+    attr_reader :proxy, :logger
+
+    def create_remote_socket
+      ::TCPSocket.new('0.0.0.0', proxy.port)
+    end
+
+    def pipe(ready, socket1, socket2)
+      if ready[0].include?(socket1)
+        data = read(socket1)
+        return true if data.empty?
+
+        write socket2, data
+      end
+
+      false
+    end
+
+    def read(socket)
+      socket.recv(1024)
+    end
+
+    def write(socket, data)
+      socket.write(data)
+    end
+  end
+end

data/lib/nonnative/socket_pair_factory.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class SocketPairFactory
+    class << self
+      def create(type, proxy, logger)
+        pair = case type
+               when :close_all
+                 CloseAllSocketPair
+               when :delay
+                 DelaySocketPair
+               when :invalid_data
+                 InvalidDataSocketPair
+               else
+                 SocketPair
+               end
+
+        pair.new(proxy, logger)
+      end
+    end
+  end
+end

data/lib/nonnative/start_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class StartError < Nonnative::Error
+  end
+end

data/lib/nonnative/startup.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+at_exit do
+  Nonnative.stop
+end
+
+Nonnative.start