nonnative 1.27.0

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'nonnative'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+gem install bundler
+bundle config set path 'vendor/bundle'
+bundle check || bundle install
+bundle clean --force

data/lib/nonnative.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'timeout'
+require 'yaml'
+
+require 'grpc'
+require 'sinatra'
+require 'rest-client'
+require 'puma'
+require 'puma/server'
+require 'concurrent'
+
+require 'nonnative/version'
+require 'nonnative/error'
+require 'nonnative/start_error'
+require 'nonnative/stop_error'
+require 'nonnative/timeout'
+require 'nonnative/port'
+require 'nonnative/configuration'
+require 'nonnative/configuration_process'
+require 'nonnative/configuration_server'
+require 'nonnative/configuration_proxy'
+require 'nonnative/service'
+require 'nonnative/command'
+require 'nonnative/pool'
+require 'nonnative/server'
+require 'nonnative/http_client'
+require 'nonnative/http_server'
+require 'nonnative/grpc_server'
+require 'nonnative/grpc_server'
+require 'nonnative/observability'
+require 'nonnative/proxy_factory'
+require 'nonnative/proxy'
+require 'nonnative/no_proxy'
+require 'nonnative/fault_injection_proxy'
+require 'nonnative/socket_pair'
+require 'nonnative/close_all_socket_pair'
+require 'nonnative/delay_socket_pair'
+require 'nonnative/invalid_data_socket_pair'
+require 'nonnative/socket_pair_factory'
+
+module Nonnative
+  class << self
+    attr_reader :pool
+
+    def load_configuration(path)
+      @configuration ||= Nonnative::Configuration.load_file(path) # rubocop:disable Naming/MemoizedInstanceVariableName
+    end
+
+    def configuration
+      @configuration ||= Nonnative::Configuration.new
+    end
+
+    def configure
+      yield configuration
+
+      require "nonnative/#{configuration.strategy}"
+    end
+
+    def start
+      @pool ||= Nonnative::Pool.new(configuration)
+      errors = []
+
+      @pool.start do |name, id, result|
+        errors << "Started #{name} with id #{id}, though did respond in time" unless result
+      end
+
+      raise Nonnative::StartError, errors.join("\n") unless errors.empty?
+    end
+
+    def stop
+      return if @pool.nil?
+
+      errors = []
+
+      @pool.stop do |name, id, result|
+        errors << "Stopped #{name} with id #{id}, though did respond in time" unless result
+      end
+
+      raise Nonnative::StopError, errors.join("\n") unless errors.empty?
+    end
+
+    def clear
+      @configuration = nil
+      @pool = nil
+    end
+  end
+end

data/lib/nonnative/before.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'cucumber'
+
+Before do
+  Nonnative.start
+end
+
+After do
+  Nonnative.stop
+end

data/lib/nonnative/close_all_socket_pair.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class CloseAllSocketPair < SocketPair
+    def connect(local_socket)
+      local_socket.close
+    end
+  end
+end

data/lib/nonnative/command.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class Command < Nonnative::Service
+    def start
+      unless command_exists?
+        @pid = command_spawn
+        wait_start
+      end
+
+      pid
+    end
+
+    def stop
+      if command_exists?
+        command_kill
+        wait_stop
+      end
+
+      pid
+    end
+
+    protected
+
+    def wait_stop
+      timeout.perform do
+        Process.waitpid2(pid)
+      end
+    end
+
+    private
+
+    attr_reader :pid
+
+    def command_kill
+      signal = Signal.list[service.signal || 'INT'] || Signal.list['INT']
+      Process.kill(signal, pid)
+    end
+
+    def command_spawn
+      spawn(service.command, %i[out err] => [service.log, 'a'])
+    end
+
+    def command_exists?
+      return false if pid.nil?
+
+      signal = Signal.list['EXIT']
+      Process.kill(signal, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+  end
+end

data/lib/nonnative/configuration.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class Configuration
+    class << self
+      def load_file(path)
+        file = YAML.load_file(path)
+
+        new.tap do |c|
+          c.strategy = file['strategy']
+
+          processes(file, c)
+          servers(file, c)
+        end
+      end
+
+      private
+
+      def processes(file, config)
+        processes = file['processes'] || []
+        processes.each do |fd|
+          config.process do |d|
+            d.name = fd['name']
+            d.command = fd['command']
+            d.timeout = fd['timeout']
+            d.port = fd['port']
+            d.log = fd['log']
+            d.signal = fd['signal']
+          end
+        end
+      end
+
+      def servers(file, config)
+        servers = file['servers'] || []
+        servers.each do |fd|
+          config.server do |s|
+            s.name = fd['name']
+            s.klass = Object.const_get(fd['klass'])
+            s.timeout = fd['timeout']
+            s.port = fd['port']
+            s.log = fd['log']
+
+            proxy = fd['proxy']
+
+            if proxy
+              s.proxy = {
+                type: proxy['type'],
+                port: proxy['port'],
+                log: proxy['log'],
+                options: proxy['options']
+              }
+            end
+          end
+        end
+      end
+    end
+
+    def initialize
+      self.strategy = :before
+      self.processes = []
+      self.servers = []
+    end
+
+    attr_accessor :strategy, :processes, :servers
+
+    def process
+      process = Nonnative::ConfigurationProcess.new
+      yield process
+
+      processes << process
+    end
+
+    def server
+      server = Nonnative::ConfigurationServer.new
+      yield server
+
+      servers << server
+    end
+  end
+end

data/lib/nonnative/configuration_process.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class ConfigurationProcess
+    attr_accessor :name, :command, :timeout, :port, :log, :signal
+  end
+end

data/lib/nonnative/configuration_proxy.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class ConfigurationProxy
+    attr_accessor :type, :port, :log, :options
+
+    def initialize
+      self.type = 'none'
+      self.port = 0
+      self.options = {}
+    end
+  end
+end

data/lib/nonnative/configuration_server.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class ConfigurationServer
+    attr_accessor :name, :klass, :timeout, :port, :log
+    attr_reader :proxy
+
+    def initialize
+      @proxy = Nonnative::ConfigurationProxy.new
+    end
+
+    def proxy=(value)
+      proxy.type = value[:type]
+      proxy.port = value[:port]
+      proxy.log = value[:log]
+      proxy.options = value[:options]
+    end
+  end
+end

data/lib/nonnative/delay_socket_pair.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class DelaySocketPair < SocketPair
+    def read(socket)
+      duration = proxy.options.dig(:delay) || 2
+      sleep duration
+
+      super socket
+    end
+  end
+end

data/lib/nonnative/error.rb

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

data/lib/nonnative/fault_injection_proxy.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class FaultInjectionProxy < Nonnative::Proxy
+    def initialize(service)
+      @connections = Concurrent::Hash.new
+      @logger = Logger.new(service.proxy.log)
+      @mutex = Mutex.new
+      @state = :none
+
+      super service
+    end
+
+    def start
+      @tcp_server = ::TCPServer.new('0.0.0.0', service.port)
+      @thread = Thread.new { perform_start }
+    end
+
+    def stop
+      thread.terminate
+      tcp_server.close
+    end
+
+    def close_all
+      apply_state :close_all
+    end
+
+    def delay
+      apply_state :delay
+    end
+
+    def invalid_data
+      apply_state :invalid_data
+    end
+
+    def reset
+      apply_state :none
+    end
+
+    def port
+      service.proxy.port
+    end
+
+    private
+
+    attr_reader :tcp_server, :thread, :connections, :mutex, :state, :logger
+
+    def perform_start
+      loop do
+        thread = Thread.start(tcp_server.accept) do |local_socket|
+          id = Thread.current.object_id
+
+          logger.info "started connection for #{id} with socket #{local_socket.inspect}"
+
+          connect local_socket
+          connections.delete(id)
+
+          logger.info "finished connection for #{id} with socket #{local_socket.inspect}"
+        end
+
+        thread.report_on_exception = false
+        connections[thread.object_id] = thread
+      end
+    end
+
+    def connect(local_socket)
+      SocketPairFactory.create(read_state, service.proxy, logger).connect(local_socket)
+    end
+
+    def apply_state(state)
+      mutex.synchronize { @state = state }
+    end
+
+    def read_state
+      mutex.synchronize { state }
+    end
+  end
+end

data/lib/nonnative/grpc_server.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Nonnative
+  class GRPCServer < Nonnative::Server
+    def initialize(service)
+      @server = GRPC::RpcServer.new
+      server.handle(svc)
+
+      # Unfortunately gRPC has only one logger so the first server wins.
+      GRPC.define_singleton_method(:logger) do
+        @logger ||= Logger.new(service.log)
+      end
+
+      super service
+    end
+
+    protected
+
+    def perform_start
+      server.add_http2_port("0.0.0.0:#{proxy.port}", :this_port_is_insecure)
+      server.run
+    end
+
+    def perform_stop
+      server.stop
+    end
+
+    def wait_start
+      timeout.perform do
+        super until server.running?
+      end
+    end
+
+    def wait_stop
+      timeout.perform do
+        super until server.stopped?
+      end
+    end
+
+    private
+
+    attr_reader :server
+  end
+end