kanrisuru 0.20.0 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 767ab1b59818ddd394ef7f4bb96435e5be43d2bf89c2c4469419f20a8a5f4a0c
-  data.tar.gz: 4c370eb4c60270ed707a78606976b391d098c1298de026558c80a543e28d8326
+  metadata.gz: 38c3969fd06510c73c0237e611fb1b0acd31dade42489f21b9d118a456e5b834
+  data.tar.gz: 604ca2ef34b74dc435aa35ee24853f8f563e42cff6309d6d7d2c6b6437aa7bc3
 SHA512:
-  metadata.gz: 8cacf38cbfc427dfe1c3a1980a8c52e3c004f119b13473380f0eaeeb0eba39c5c495bed0a2a2be37add8b8d148505f6a34ff7f0455b6a6c4c6b71f2e80849c75
-  data.tar.gz: fbf05703912544955455f75af13ce799e0a039ee7269e7106bb3e2db9e1882cc2b2d90ee535c85e3bd0f259bffe4cfc4684ef49f97bf76884eaa61e1b8d3bc72
+  metadata.gz: 6ef8d8316b07a088e88a4aad0f5d0bb48419890ba0f00895c2bbae01eb356db246104e095d4e7fe06b91d9cebeaa2c2efe973d3302a40e3eeb4714d3e394dd83
+  data.tar.gz: b78410887ec8b5b3e809f4e59934f7c7f6e5d0363ddf9e4a38f436bd42ca0a43de8117f837646edec963c07051f4e546a0705ae2e4581a8971ead44943f22cca

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 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. 

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/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,37 +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 { |_, host| host.su(user) }
+        each { |host| host.su(user) }
       end
 
       def chdir(path = '~')
@@ -68,15 +60,70 @@ module Kanrisuru
       end
 
       def cd(path = '~')
-        @hosts.each { |_, host| host.cd(path) }
+        each { |host| host.cd(path) }
       end
 
       def disconnect
-        @hosts.each { |_, host| host.disconnect }
+        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
@@ -88,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
@@ -119,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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kanrisuru
-  VERSION = '0.20.0'
+  VERSION = '1.0.0.beta1'
 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/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/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/remote/host.rb

@@ -41,7 +41,7 @@ RSpec.shared_examples 'host' do |os_name, host_json, _spec_dir|
         proxy: proxy
       )
 
-      ## Test instiation
+      ## Test instantiation
       expect(host.proxy).to be_instance_of(Net::SSH::Gateway)
       expect(host.ssh).to be_instance_of(Net::SSH::Connection::Session)
 
@@ -61,8 +61,6 @@ RSpec.shared_examples 'host' do |os_name, host_json, _spec_dir|
       expect(result).to be_instance_of(String)
       lines = result.split("\n")
       expect(lines.length).to be >= 1
-
-      ## Test upload
     end
 
     it 'changes directories' do

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kanrisuru
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 1.0.0.beta1
 platform: ruby
 authors:
 - Ryan Mammina
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-20 00:00:00.000000000 Z
+date: 2022-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel_tests
@@ -440,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
@@ -486,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
@@ -602,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
@@ -670,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
@@ -697,6 +698,7 @@ 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
@@ -722,9 +724,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.5
 signing_key: 

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