kanrisuru 0.19.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef72387ee3392fab30d54254e7226e066d943757b686bd1e66fea0fc1bd58181
-  data.tar.gz: eb829fe3e5d90968c17cfa9922161505f4fbdce4a44da5524f35ad23967c7335
+  metadata.gz: 2c8f6cf4fd27ca458feef7d89dd49617d3e4aba1058b203c297c0206bf5d91f0
+  data.tar.gz: c0f03db6bee208f1bcd6ed667f3e50db85e56482ded88023e91efa0025c2a7ad
 SHA512:
-  metadata.gz: 9e6b315320713f79f5693b6a21269dcadbf6327efae5ab8dc4287165ebfd6f0c05cc221cb351911f669f71b1812ac3a43884ed978ef64422f07a3beab835ec4a
-  data.tar.gz: 21e425b548076e932aa9770f4a0827e3252b6dba3869e90d219bbf3e70d983fadb87f14b7ed1747f3c4c569c109901e4da708211816573c963c96bd3977bee24
+  metadata.gz: 004c36ab67130dcb5a2bc8ff3dd60a28a15ef9c48b64a523b6386ee05a656f92f8af9492cc75400b16c5c26006c9ba9134c8605c6b3f87c185a79624ccf5af93
+  data.tar.gz: a2c3d25e09d91bc8da26198e9bfffe986270671f6e81ace0f11710a328cada0ac341d5e40d097cf204a93b091d7c3d400c9caf8b160064ca087da9dcdddec4b7

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## Kanrisuru 1.0.0.beta1 (February 27, 2022) ##
+*  Add parallel mode for cluster. Allows hosts to run commands concurrently, reducing time it takes due to the high I/O blocking nature of the network requests.
+*  Add test cases for cluster parallel mode.
+*  Clean up methods on cluster class to use map and each methods in a simplified manner.
+*  Remove `/spec` dir from codecoverage.
+
+## Kanrisuru 0.20.0 (February 21, 2022) ##
+*  Allow hosts to be connected via proxy host. This is much like using a bastion / jump server. 
+*  Add integration test cases for proxy host connection. 
+
 ## Kanrisuru 0.19.4 (February 19, 2022) ##
 *  Add additional family types to `ss` command.
 

data/README.md

@@ -54,6 +54,27 @@ host = Kanrisuru::Remote::Host.new(
 )
 ```
 
+#### Connect with a Jump / Bastion Host
+To connect to a host behind a firewall through a jump / bastion host, pass either an instance of another Kanrisuru::Remote::Host, or a hash of host config values
+
+```ruby
+proxy = Kanrisuru::Remote::Host.new(
+  host: 'proxy-host',
+  username: 'ubuntu',
+  keys: ['~/.ssh/proxy.pem']
+)
+
+host = Kanrisuru::Remote::Host.new(
+  host: '1.2.3.4', 
+  username: 'ubuntu', 
+  keys: ['~/.ssh/id_rsa'],
+  proxy: proxy
+)
+
+host.whoami
+'ubuntu'
+```
+
 #### run a simple echo command on the remote host
 ```ruby
 host.env['VAR'] = 'world'
@@ -124,7 +145,24 @@ host = Kanrisuru::Remote::Host.new(host: 'remote-host-4', username: 'rhel', keys
 cluster << host 
 ```
 
-Kanrisuru at this point only runs commands sequentially. We plan on creating a parallel run mode in a future release.
+#### Run cluster in parallel mode to reduce time waiting on blocking IO
+```ruby
+Benchmark.measure do
+  cluster.each do |host|
+    puts cluster.pwd 
+  end
+end
+# => 0.198980   0.029681   0.228661 (  5.258496)
+
+cluster.parallel = true
+
+Benchmark.measure do
+  cluster.each do |host|
+    puts cluster.pwd 
+  end
+end
+# => 0.016478   0.007956   0.024434 (  0.120066)
+```
 
 #### To run across all hosts with a single command, cluster will return a array of result hashes
 ```ruby

data/kanrisuru.gemspec

@@ -27,6 +27,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency 'net-ping', '~> 2.0'
   gem.add_runtime_dependency 'net-scp', '~> 3.0'
   gem.add_runtime_dependency 'net-ssh', '~> 6.1'
+  gem.add_runtime_dependency 'net-ssh-gateway', '~> 2.0'
 
   gem.files         = `git ls-files`.split("\n")
   gem.require_paths = ['lib']

data/lib/kanrisuru/core/system/commands/sysctl.rb

@@ -14,7 +14,7 @@ module Kanrisuru
         else
           command.append_flag('--all')
         end
-        
+
         execute_shell(command)
 
         Kanrisuru::Result.new(command) do |cmd|

data/lib/kanrisuru/core/system/parsers/sysctl.rb

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
+
 require 'ostruct'
 
 module Kanrisuru
   module Core
     module System
       module Parser
-        class Sysctl 
+        class Sysctl
           class << self
             def parse(command)
               result = {}
 
               lines = command.to_a
               lines.each do |line|
-                next if line.include?("permission denied on key")
+                next if line.include?('permission denied on key')
 
                 keys, value = parse_line(line)
                 next if Kanrisuru::Util.blank?(value)
@@ -27,7 +28,7 @@ module Kanrisuru
             def build_struct(hash)
               struct = Struct.new(*hash.keys).new
 
-              hash.keys.each do |key|
+              hash.each_key do |key|
                 struct[key] = hash[key].is_a?(Hash) ? build_struct(hash[key]) : hash[key]
               end
 
@@ -35,7 +36,7 @@ module Kanrisuru
             end
 
             def merge_recursively(h1, h2)
-              h1.merge(h2) do |k, v1, v2|
+              h1.merge(h2) do |_k, v1, v2|
                 if v1.is_a?(Hash) && v2.is_a?(Hash)
                   merge_recursively(v1, v2)
                 else
@@ -64,7 +65,6 @@ module Kanrisuru
 
               [string.split('.').map(&:to_sym), value]
             end
-
           end
         end
       end

data/lib/kanrisuru/os_package/collection.rb

@@ -34,9 +34,8 @@ module Kanrisuru
             os_method_names.each do |method_name|
               define_method method_name do |*args, &block|
                 cluster = namespace_instance.instance_variable_get(:@cluster)
-                hosts = cluster.instance_variable_get(:@hosts)
-                hosts.map do |host_addr, host|
-                  { host: host_addr, result: host.send(namespace).send(method_name, *args, &block) }
+                cluster.map do |host|
+                  host.send(namespace).send(method_name, *args, &block)
                 end
               end
             end
@@ -45,8 +44,8 @@ module Kanrisuru
           class_eval do
             os_method_names.each do |method_name|
               define_method method_name do |*args, &block|
-                @hosts.map do |host_addr, host|
-                  { host: host_addr, result: host.send(method_name, *args, &block) }
+                map do |host|
+                  host.send(method_name, *args, &block)
                 end
               end
             end

data/lib/kanrisuru/processor_count.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require 'etc'
+
+module Kanrisuru
+  # https://github.com/grosser/parallel/blob/master/lib/parallel/processor_count.rb
+  module ProcessorCount
+    # Number of processors seen by the OS, used for process scheduling
+    def self.processor_count
+      @processor_count ||= Integer(ENV['PARALLEL_PROCESSOR_COUNT'] || Etc.nprocessors)
+    end
+
+    # Number of physical processor cores on the current system.
+    def self.physical_processor_count
+      @physical_processor_count ||= begin
+        ppc =
+          case RbConfig::CONFIG["target_os"]
+          when /darwin[12]/
+            IO.popen("/usr/sbin/sysctl -n hw.physicalcpu").read.to_i
+          when /linux/
+            cores = {} # unique physical ID / core ID combinations
+            phy = 0
+            IO.read("/proc/cpuinfo").scan(/^physical id.*|^core id.*/) do |ln|
+              if ln.start_with?("physical")
+                phy = ln[/\d+/]
+              elsif ln.start_with?("core")
+                cid = "#{phy}:#{ln[/\d+/]}"
+                cores[cid] = true unless cores[cid]
+              end
+            end
+            cores.count
+          when /mswin|mingw/
+            require 'win32ole'
+            result_set = WIN32OLE.connect("winmgmts://").ExecQuery(
+              "select NumberOfCores from Win32_Processor"
+            )
+            result_set.to_enum.collect(&:NumberOfCores).reduce(:+)
+          else
+            processor_count
+          end
+        # fall back to logical count if physical info is invalid
+        ppc > 0 ? ppc : processor_count
+      end
+    end
+  end
+end

data/lib/kanrisuru/remote/cluster.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'thread'
 
 module Kanrisuru
   module Remote
@@ -6,7 +7,12 @@ module Kanrisuru
       extend OsPackage::Collection
       include Enumerable
 
+      attr_accessor :parallel, :concurrency
+
       def initialize(*hosts)
+        @parallel = false 
+        @concurrency = local_concurrency
+
         @hosts = {}
         hosts.each do |host_opts|
           add_host(host_opts)
@@ -30,39 +36,23 @@ module Kanrisuru
       end
 
       def execute(command)
-        @hosts.map do |host_addr, host|
-          ## Need to evaluate each host independently for the command.
-          cmd = create_command(command)
-
-          { host: host_addr, result: host.execute(cmd) }
-        end
+        map { |host| host.execute(create_command(command)) }
       end
 
       def execute_shell(command)
-        @hosts.map do |host_addr, host|
-          ## Need to evaluate each host independently for the command.
-          cmd = create_command(command)
-
-          { host: host_addr, result: host.execute_shell(cmd) }
-        end
-      end
-
-      def each(&block)
-        @hosts.each { |_host_addr, host| block.call(host) }
+        map { |host| host.execute_shell(create_command(command)) }
       end
 
       def hostname
-        map_host_results(:hostname)
+        map { |host| host.send(:hostname) }
       end
 
       def ping?
-        map_host_results(:ping?)
+        map { |host| host.send(:ping?) }
       end
 
       def su(user)
-        @hosts.each do |_host_addr, host|
-          host.su(user)
-        end
+        each { |host| host.su(user) }
       end
 
       def chdir(path = '~')
@@ -70,19 +60,70 @@ module Kanrisuru
       end
 
       def cd(path = '~')
-        @hosts.each do |_host_addr, host|
-          host.cd(path)
-        end
+        each { |host| host.cd(path) }
       end
 
       def disconnect
-        @hosts.each do |_host_addr, host|
-          host.disconnect
-        end
+        each { |host| host.disconnect }
+      end
+
+      def map(&block)
+        parallel? ? each_parallel(preserve: true, &block) : each_sequential(preserve: true, &block)
+      end
+
+      def each(&block)
+        parallel? ? each_parallel(preserve: false, &block) : each_sequential(preserve: false, &block)
+      end
+
+      def parallel?
+        @parallel 
+      end
+
+      def sequential?
+        !parallel?
       end
 
       private
 
+      def each_sequential(opts = {}, &block)
+        results = @hosts.map do |host_addr, host| 
+          { host: host_addr, result: block.call(host) }
+        end
+
+        opts[:preserve] ? results : self
+      end
+
+      def each_parallel(opts = {}, &block)
+        queue = Queue.new.tap do |q|
+          @hosts.each { |_, host| q << host }
+        end
+
+        threads = []
+        results = []
+        mutex = Mutex.new
+
+        ## No need to spawn more threads then number of hosts in cluster
+        concurrency = queue.length < @concurrency ? queue.length : @concurrency 
+        concurrency.times do
+          threads << Thread.new do
+            loop do
+              host = queue.pop(true) rescue Thread.exit
+
+              begin
+                result = block.call(host)
+                mutex.synchronize { results.push({ host: host.host, result: result }) }
+              rescue Exception => exception
+                mutex.synchronize { results.push({ host: host.host, result: exception }) }
+              end
+            end
+          end
+        end
+
+        threads.each(&:join) 
+
+        opts[:preserve] ? results : self
+      end
+
       def create_command(command)
         case command
         when String
@@ -94,12 +135,6 @@ module Kanrisuru
         end
       end
 
-      def map_host_results(action)
-        @hosts.map do |host_addr, host|
-          { host: host_addr, result: host.send(action) }
-        end
-      end
-
       def remove_host(host)
         if host.instance_of?(Kanrisuru::Remote::Host)
           removed = false
@@ -125,14 +160,22 @@ module Kanrisuru
       end
 
       def add_host(host_opts)
-        if host_opts.instance_of?(Hash)
+        case host_opts
+        when Hash
           @hosts[host_opts[:host]] = Kanrisuru::Remote::Host.new(host_opts)
-        elsif host_opts.instance_of?(Kanrisuru::Remote::Host)
+        when Kanrisuru::Remote::Host
           @hosts[host_opts.host] = host_opts
+        when Kanrisuru::Remote::Cluster
+          host_opts.send(:each_sequential) { |host| @hosts[host.host] = host }
         else
           raise ArgumentError, 'Invalid host option'
         end
       end
+
+      def local_concurrency
+        ProcessorCount.physical_processor_count
+      end
+
     end
   end
 end

data/lib/kanrisuru/remote/host.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'net/ssh'
+require 'net/ssh/gateway'
 require 'net/scp'
 require 'net/ping'
 
@@ -12,6 +13,8 @@ module Kanrisuru
       attr_reader :host, :username, :password, :port, :keys
 
       def initialize(opts = {})
+        @opts = opts
+
         @host = opts[:host]
         @username = opts[:username]
         @login_user = @username
@@ -84,7 +87,11 @@ module Kanrisuru
       end
 
       def ssh
-        @ssh ||= Net::SSH.start(@host, @username, keys: @keys, password: @password, port: @port)
+        @ssh ||= init_ssh
+      end
+
+      def proxy
+        @proxy ||= init_proxy
       end
 
       def ping?
@@ -110,6 +117,7 @@ module Kanrisuru
 
       def disconnect
         ssh.close
+        proxy&.close(ssh.transport.port)
       end
 
       private
@@ -158,6 +166,35 @@ module Kanrisuru
         end
       end
 
+      def init_ssh
+        if proxy&.active?
+          proxy.ssh(@host, @username,
+                    keys: @keys, password: @password, port: @port)
+        else
+          Net::SSH.start(@host, @username,
+                         keys: @keys, password: @password, port: @port)
+        end
+      end
+
+      def init_proxy
+        return unless @opts[:proxy]
+
+        proxy = @opts[:proxy]
+
+        case proxy
+        when Hash
+          Net::SSH::Gateway.new(proxy[:host], proxy[:username],
+                                keys: proxy[:keys], password: proxy[:password], port: proxy[:port])
+        when Kanrisuru::Remote::Host
+          Net::SSH::Gateway.new(proxy.host, proxy.username,
+                                keys: proxy.keys, password: proxy.password, port: proxy.port)
+        when Net::SSH::Gateway
+          proxy
+        else
+          raise ArgumentError, 'Invalid proxy type'
+        end
+      end
+
       def init_hostname
         command = Kanrisuru::Command.new('hostname')
         execute(command)

data/lib/kanrisuru/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kanrisuru
-  VERSION = '0.19.4'
+  VERSION = '1.0.0'
 end

data/lib/kanrisuru.rb

@@ -29,6 +29,7 @@ require_relative 'kanrisuru/util'
 require_relative 'kanrisuru/mode'
 require_relative 'kanrisuru/os_package'
 require_relative 'kanrisuru/command'
+require_relative 'kanrisuru/processor_count'
 require_relative 'kanrisuru/remote'
 require_relative 'kanrisuru/result'
 require_relative 'kanrisuru/core'

data/spec/functional/processor_count_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::ProcessorCount do
+  it 'gets processor count' do
+    expect(described_class.processor_count).to be > 0
+  end 
+
+  it 'gets physical processor count' do
+    expect(described_class.physical_processor_count).to be > 0
+  end
+
+  it "is even factor of logical cpus" do
+    expect(described_class.processor_count % described_class.physical_processor_count).to be == 0
+  end
+end

data/spec/functional/remote/cluster_spec.rb

@@ -27,6 +27,14 @@ RSpec.describe Kanrisuru::Remote::Cluster do
     )
   end
 
+  let(:host3) do
+    Kanrisuru::Remote::Host.new(
+      host: 'centos-host',
+      username: 'centos',
+      keys: ['id_rsa']
+    )
+  end
+
   it 'adds host to a cluster' do
     cluster = described_class.new(host1)
     expect(cluster.hosts.length).to eq(1)
@@ -46,7 +54,7 @@ RSpec.describe Kanrisuru::Remote::Cluster do
       username: 'centos',
       keys: ['id_rsa']
     }
-
+    
     expect(cluster.hosts.length).to eq(3)
     expect(cluster.count).to eq(3)
     expect(cluster.count).to eq(3)
@@ -55,6 +63,19 @@ RSpec.describe Kanrisuru::Remote::Cluster do
     expect(cluster.hosts).to include(host2)
   end
 
+  it 'adds a cluster to another cluster' do
+    cluster1 = described_class.new(host1, host2)
+    cluster2 = described_class.new(host3)
+
+    cluster1 << cluster2
+    expect(cluster1.hosts.length).to eq(3)
+    expect(cluster1.count).to eq(3)
+    expect(cluster1.count).to eq(3)
+    expect(cluster1['centos-host'].username).to eq('centos')
+    expect(cluster1.hosts).to include(host1)
+    expect(cluster1.hosts).to include(host2)
+  end
+
   it 'fails to add host to a cluster' do
     cluster = described_class.new
     expect { cluster << 1 }.to raise_error(ArgumentError)
@@ -90,6 +111,58 @@ RSpec.describe Kanrisuru::Remote::Cluster do
     end.to raise_error(ArgumentError)
   end
 
+  it 'initializes cluster and is run in sequential mode by default' do
+    cluster = described_class.new
+    expect(cluster).to be_sequential
+  end
+
+  it 'sets cluster to parallel mode' do
+    cluster = described_class.new
+    cluster.parallel = true
+    expect(cluster).to be_parallel
+  end
+
+  it 'runs commands on a cluster sequentialy' do
+    cluster = described_class.new(host1, host2)
+
+    expect(cluster).to receive(:each_sequential)
+
+    command = Kanrisuru::Command.new('pwd')
+    cluster.execute(command)
+  end
+
+  it 'runs commands on a cluster in parallel across hosts' do
+    cluster = described_class.new(host1, host2)
+    cluster.parallel = true
+
+    expect(cluster).to receive(:each_parallel)
+
+    command = Kanrisuru::Command.new('pwd')
+    cluster.execute(command)
+  end
+
+  it 'gets cluster back from each method' do
+    cluster = described_class.new(host1, host2)
+
+    c = cluster.each { |h| h.su('root') } 
+    expect(c).to be_instance_of(Kanrisuru::Remote::Cluster)
+    expect(c.object_id).to eq(cluster.object_id)
+  end
+
+  it 'gets results back from map method' do
+    cluster = described_class.new(host1, host2)
+  
+    results = cluster.map do |host|
+      host.execute('hello')
+    end 
+
+    expect(results).to be_instance_of(Array)
+    results.each do |result|
+      expect(result).to have_key(:host)
+      expect(result).to have_key(:result)
+    end
+  end
+
   it 'runs execute for a command on a cluster' do
     cluster = described_class.new
     cluster << host1
@@ -185,6 +258,19 @@ RSpec.describe Kanrisuru::Remote::Cluster do
     StubNetwork.unstub_command!(:realpath)
   end
 
+  it 'raises and catches exception in parallel mode' do
+    cluster = described_class.new(host1, host2, host3)
+    cluster.parallel = true
+
+    results = cluster.map do |host|
+      raise ArgumentError 
+    end 
+
+    results.each do |result|
+      expect(result[:result]).to be_instance_of(ArgumentError)
+    end
+  end
+
   it 'changes current working directory for each host in a cluster' do
     cluster = described_class.new(host1, host2)
 

data/spec/helper/hosts.json

@@ -8,6 +8,15 @@
 		"kernel": "Linux",
 		"home": "/home/ubuntu"
 	},
+  {
+    "name": "proxy",
+    "port": 22,
+    "username": "ubuntu",
+    "ssh_key": "~/.ssh/id_rsa",
+    "hostname": "proxy-host",
+    "kernel": "Linux",
+    "home": "/home/ubuntu"
+  },
 	{
 		"name": "ubuntu",
 		"port": 22,

data/spec/helper/simplecov.rb

@@ -4,6 +4,8 @@ require 'simplecov'
 require 'simplecov-cobertura'
 
 SimpleCov.start do
+  add_filter '/spec/'
+  
   command_name "kanrisuru-tests#{ENV['TEST_ENV_NUMBER'] || ''}"
   merge_timeout 2400
 

data/spec/helper/test_hosts.rb

@@ -20,6 +20,11 @@ class TestHosts
       hosts(name)
     end
 
+    def resolve(hostname)
+      s = Socket.getaddrinfo(hostname, nil)
+      s[0][2]
+    end
+
     def spec_dir(host_json)
       random_string = SecureRandom.hex
       "#{host_json['home']}/.kanrisuru_spec_files_#{random_string[0..5]}"

data/spec/integration/remote/cluster/cluster_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Remote::Cluster do
+  let(:host1) do
+    Kanrisuru::Remote::Host.new(
+      host: TestHosts.host('ubuntu')['hostname'],
+      username: TestHosts.host('ubuntu')['username'],
+      keys: [TestHosts.host('ubuntu')['ssh_key']]
+    )
+  end
+
+  let(:host2) do
+    Kanrisuru::Remote::Host.new(
+      host: TestHosts.host('debian')['hostname'],
+      username: TestHosts.host('debian')['username'],
+      keys: [TestHosts.host('debian')['ssh_key']]
+    )
+  end
+
+  let(:host3) do
+    Kanrisuru::Remote::Host.new(
+      host: TestHosts.host('centos')['hostname'],
+      username: TestHosts.host('centos')['username'],
+      keys: [TestHosts.host('centos')['ssh_key']]
+    )
+  end
+
+  let(:host4) do
+    Kanrisuru::Remote::Host.new(
+      host: TestHosts.host('opensuse')['hostname'],
+      username: TestHosts.host('opensuse')['username'],
+      keys: [TestHosts.host('opensuse')['ssh_key']]
+    )
+  end
+
+  it 'gets hostname for cluster' do
+    cluster = described_class.new(host1, host2, host3, host4)
+    expect(cluster.hostname).to match([
+                                        { host: 'ubuntu-host', result: 'ubuntu-host' },
+                                        { host: 'debian-host', result: 'debian-host' },
+                                        { host: 'centos-host', result: 'centos-host' },
+                                        { host: 'opensuse-host', result: 'opensuse-host' },
+                                      ])
+
+    cluster.disconnect
+  end
+
+  it 'can ping host cluster' do
+    cluster = described_class.new(host1, host2, host3, host4)
+    expect(cluster.ping?).to match([
+                                    { host: 'ubuntu-host', result: true },
+                                    { host: 'debian-host', result: true },
+                                    { host: 'centos-host', result: true },
+                                    { host: 'opensuse-host', result: true },
+                                   ])
+
+    cluster.disconnect
+  end
+
+  it 'should use specific number of threads as number of hosts' do
+    cluster = described_class.new(host1, host2, host3, host4)
+    cluster.parallel = true
+
+    ## Called x2 b/c two methods invoke the parallel runner 
+    expect(Thread).to receive(:new).exactly(cluster.count * 2).times.and_call_original
+
+    cluster.hostname
+    cluster.disconnect
+  end
+
+  it 'should respect concurrency setting' do
+    concurrency = 2
+
+    cluster = described_class.new(host1, host2, host3, host4)
+    cluster.parallel = true
+    cluster.concurrency = concurrency
+
+    ## Called x2 b/c two methods invoke the parallel runner 
+    expect(Thread).to receive(:new).exactly(concurrency * 2).times.and_call_original
+
+    cluster.hostname
+    cluster.disconnect
+  end
+
+  it 'saves time running cluster in parallel mode' do
+    cluster = described_class.new(host1, host2, host3, host4)
+    time1 = Benchmark.measure {
+      cluster.each do |host|
+        expect(host.pwd).to be_success
+      end
+    }
+
+    cluster.parallel = true
+    time2 = Benchmark.measure {
+      cluster.each do |host|
+        expect(host.pwd).to be_success
+      end
+    }
+
+    expect(time1.total).to be > time2.total
+    cluster.disconnect
+  end
+
+  it 'disconnects all hosts' do
+    cluster = described_class.new(host1, host2, host3, host4)
+    cluster.disconnect
+
+    cluster.each do |host|
+      expect(host.ssh).to be_closed
+    end
+  end
+end

data/spec/support/shared_examples/integration/core/system.rb

@@ -103,7 +103,7 @@ RSpec.shared_examples 'system' do |os_name, host_json, _spec_dir|
     it 'gets kernel sysctl info' do
       result = host.sysctl
       expect(result).to be_success
-      expect(result).to respond_to :net 
+      expect(result).to respond_to :net
       expect(result).to respond_to :kernel
       expect(result).to respond_to :dev
 

data/spec/support/shared_examples/integration/remote/host.rb

@@ -24,6 +24,45 @@ RSpec.shared_examples 'host' do |os_name, host_json, _spec_dir|
       expect(host.hostname).to eq(host_json['hostname'])
     end
 
+    it 'connects with proxy host' do
+      config = TestHosts.host('proxy')
+      proxy = Kanrisuru::Remote::Host.new(
+        host: config['hostname'],
+        username: config['username'],
+        keys: [config['ssh_key']]
+      )
+
+      expect(proxy).to be_ping
+
+      host = Kanrisuru::Remote::Host.new(
+        host: TestHosts.resolve(host_json['hostname']),
+        username: host_json['username'],
+        keys: [host_json['ssh_key']],
+        proxy: proxy
+      )
+
+      ## Test instantiation
+      expect(host.proxy).to be_instance_of(Net::SSH::Gateway)
+      expect(host.ssh).to be_instance_of(Net::SSH::Connection::Session)
+
+      ## Test basic commands
+      expect(host.hostname).to eq(host_json['hostname'])
+
+      host.cd('../')
+      expect(host.pwd.path).to eq('/home')
+
+      expect(host.whoami.user).to eq(host_json['username'])
+      host.su 'root'
+      expect(host.whoami.user).to eq('root')
+
+      ## Test download
+      src_path = '/etc/hosts'
+      result = host.download(src_path)
+      expect(result).to be_instance_of(String)
+      lines = result.split("\n")
+      expect(lines.length).to be >= 1
+    end
+
     it 'changes directories' do
       expect(host.pwd.path).to eq(host_json['home'])
 

data/spec/unit/processor_count_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::ProcessorCount do
+  it 'responds to methods' do
+    expect(described_class).to respond_to(:processor_count)
+    expect(described_class).to respond_to(:physical_processor_count)
+  end
+end

data/spec/unit/remote/cluster_spec.rb

@@ -26,11 +26,16 @@ RSpec.describe Kanrisuru::Remote::Cluster do
     expect(cluster).to respond_to(:execute)
     expect(cluster).to respond_to(:execute_shell)
     expect(cluster).to respond_to(:each)
+    expect(cluster).to respond_to(:map)
     expect(cluster).to respond_to(:hostname)
     expect(cluster).to respond_to(:ping?)
     expect(cluster).to respond_to(:su)
     expect(cluster).to respond_to(:chdir)
     expect(cluster).to respond_to(:cd)
     expect(cluster).to respond_to(:disconnect)
+    expect(cluster).to respond_to(:parallel)
+    expect(cluster).to respond_to(:concurrency)
+    expect(cluster).to respond_to(:parallel?)
+    expect(cluster).to respond_to(:sequential?)
   end
 end

data/spec/unit/remote/host_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe Kanrisuru::Remote::Host do
+  before(:all) do
+    StubNetwork.stub!
+  end
+
+  after(:all) do
+    StubNetwork.unstub!
+  end
+
+  let(:host) do
+    described_class.new(
+      host: 'localhost',
+      username: 'ubuntu',
+      keys: ['id_rsa']
+    )
+  end
+
+  it 'responds to methods' do
+    expect(host).to respond_to(:remote_user)
+    expect(host).to respond_to(:hostname)
+    expect(host).to respond_to(:os)
+    expect(host).to respond_to(:env)
+    expect(host).to respond_to(:template)
+    expect(host).to respond_to(:fstab)
+    expect(host).to respond_to(:chdir)
+    expect(host).to respond_to(:cd)
+    expect(host).to respond_to(:cpu)
+    expect(host).to respond_to(:memory)
+    expect(host).to respond_to(:su)
+    expect(host).to respond_to(:file)
+    expect(host).to respond_to(:ssh)
+    expect(host).to respond_to(:proxy)
+    expect(host).to respond_to(:ping?)
+    expect(host).to respond_to(:execute)
+    expect(host).to respond_to(:execute_shell)
+    expect(host).to respond_to(:disconnect)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kanrisuru
 version: !ruby/object:Gem::Version
-  version: 0.19.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Ryan Mammina
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-19 00:00:00.000000000 Z
+date: 2022-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel_tests
@@ -136,6 +136,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: net-ssh-gateway
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: "    Kanrisuru helps manage remote servers with objected oriented ruby.
   \n    Results come back as structured data, parsed, prepared and ready.\n"
 email: ryan@avamia.com
@@ -426,6 +440,7 @@ files:
 - lib/kanrisuru/os_package/collection.rb
 - lib/kanrisuru/os_package/define.rb
 - lib/kanrisuru/os_package/include.rb
+- lib/kanrisuru/processor_count.rb
 - lib/kanrisuru/remote.rb
 - lib/kanrisuru/remote/cluster.rb
 - lib/kanrisuru/remote/cpu.rb
@@ -472,6 +487,7 @@ files:
 - spec/functional/core/user_spec.rb
 - spec/functional/core/yum_spec.rb
 - spec/functional/core/zypper_spec.rb
+- spec/functional/processor_count_spec.rb
 - spec/functional/remote/cluster_spec.rb
 - spec/functional/remote/cpu_spec.rb
 - spec/functional/remote/env_spec.rb
@@ -588,7 +604,7 @@ files:
 - spec/integration/core/zypper/opensuse_spec.rb
 - spec/integration/core/zypper/sles_spec.rb
 - spec/integration/os_package_spec.rb
-- spec/integration/remote/cluster/ubuntu_spec.rb
+- spec/integration/remote/cluster/cluster_spec.rb
 - spec/integration/remote/cpu/centos_spec.rb
 - spec/integration/remote/cpu/debian_spec.rb
 - spec/integration/remote/cpu/fedora_spec.rb
@@ -656,7 +672,6 @@ files:
 - spec/support/shared_examples/integration/core/user.rb
 - spec/support/shared_examples/integration/core/yum.rb
 - spec/support/shared_examples/integration/core/zypper.rb
-- spec/support/shared_examples/integration/remote/cluster.rb
 - spec/support/shared_examples/integration/remote/cpu.rb
 - spec/support/shared_examples/integration/remote/env_spec.rb
 - spec/support/shared_examples/integration/remote/fstab.rb
@@ -683,10 +698,12 @@ files:
 - spec/unit/core/zypper_spec.rb
 - spec/unit/kanrisuru_spec.rb
 - spec/unit/mode_spec.rb
+- spec/unit/processor_count_spec.rb
 - spec/unit/remote/cluster_spec.rb
 - spec/unit/remote/cpu_spec.rb
 - spec/unit/remote/env_spec.rb
 - spec/unit/remote/fstab_spec.rb
+- spec/unit/remote/host_spec.rb
 - spec/unit/template_spec.rb
 - spec/unit/util_spec.rb
 homepage: https://kanrisuru.com

data/spec/integration/remote/cluster/ubuntu_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-TestHosts.each_os(only: %w[ubuntu]) do |os_name, host_json, spec_dir|
-  RSpec.describe Kanrisuru::Core::Disk do
-    include_examples 'disk', os_name, host_json, spec_dir
-  end
-end

data/spec/support/shared_examples/integration/remote/cluster.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.shared_examples 'cluster' do |os_name, host_json, _spec_dir|
-  context "with #{os_name}" do
-    let(:host1) do
-      Kanrisuru::Remote::Host.new(
-        host: host_json['hostname'],
-        username: host_json['username'],
-        keys: [host_json['ssh_key']]
-      )
-    end
-
-    let(:host2) do
-      Kanrisuru::Remote::Host.new(
-        host: 'localhost',
-        username: 'ubuntu',
-        keys: ['~/.ssh/id_rsa']
-      )
-    end
-
-    it 'gets hostname for cluster' do
-      cluster = described_class.new({
-                                      host: 'localhost',
-                                      username: 'ubuntu',
-                                      keys: ['~/.ssh/id_rsa']
-                                    }, {
-                                      host: '127.0.0.1',
-                                      username: 'ubuntu',
-                                      keys: ['~/.ssh/id_rsa']
-                                    })
-
-      expect(cluster.hostname).to match([
-                                          { host: 'localhost', result: 'ubuntu' },
-                                          { host: '127.0.0.1', result: 'ubuntu' }
-                                        ])
-
-      cluster.disconnect
-    end
-
-    it 'can ping host cluster' do
-      cluster = described_class.new({
-                                      host: 'localhost',
-                                      username: 'ubuntu',
-                                      keys: ['~/.ssh/id_rsa']
-                                    }, {
-                                      host: '127.0.0.1',
-                                      username: 'ubuntu',
-                                      keys: ['~/.ssh/id_rsa']
-                                    })
-
-      expect(cluster.ping?).to match([
-                                       { host: 'localhost', result: true },
-                                       { host: '127.0.0.1', result: true }
-                                     ])
-
-      cluster.disconnect
-    end
-
-    it 'disconnects all hosts' do
-      cluster = described_class.new(host1, host2)
-      cluster.disconnect
-
-      cluster.each do |host|
-        expect(host.ssh.closed).to be_truthy
-      end
-    end
-  end
-end