kanrisuru 0.16.7 → 0.16.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dad2f67bc43f63f08358733b56f5f2c60b0badba2fad40072b5fd856bcd0f00
-  data.tar.gz: 84a2b6a7a85bcbd2282fed9540e70a86517605e2681a64e231681a5d156f3332
+  metadata.gz: b7e691e6227ba9b1c056be999461a641fd28a425a4d75cb02af41265b724b0af
+  data.tar.gz: a44f3470adab298c100ada9e954e775df42a38f933bf6533f6f54de096158745
 SHA512:
-  metadata.gz: a9cc599d2f48f0d3643489b87c850be0972b217e67b4e488531f5e6de0727fe265460f8af0023917bd65920805d763047b801a23fb49bf5abc78f745a8900d14
-  data.tar.gz: de40ab48a6758caa3ae9d4f8de9a71b0c15723d5921bb065054003e9756b874a7f248da34c2b7721b78f29b967aa5c61d9a07ac7582a1c994df0261bf3714028
+  metadata.gz: 631d251e1833edc36568eb00907850a45f39bf623e85b4bc2f45806800ce71de97f1f60e129d4f452d7696f265de1aaa9a8228a67c013edadbd3bdcee94c1f85
+  data.tar.gz: fee6dcab58110f2addc66c93394b679d6dcc5ac0b83fb619102dd3aed1556a3a4a224f34ad87cda7be79cc8e0d39fd3248e2c7340bc50b64ec5130b79ee640fe

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## Kanrisuru 0.16.11 (December 28, 2021) ##
+*  Add functional and integration test cases for the `Kanrisuru::Remote::Cluster` class.
+*  Allow for passing a command instance into `execute` and `execute_shell` on a cluster instance, by deep copying a command object. 
+
+## Kanrisuru 0.16.10 (December 28, 2021) ##
+*  Add `iname` and `iregex` params to `find` command.
+
+## Kanrisuru 0.16.9 (December 27, 2021) ##
+*  Use cp intead of mv for recurisive dir overwrite on upload command.
+
+## Kanrisuru 0.16.8 (December 27, 2021) ##
+*  Fix return value of field for dmi parser.
+*  Fix upload command to copy contents of directory when transfering directories from tmp location.
+
 ## Kanrisuru 0.16.7 (December 27, 2021) ##
 *  Update homepage to docs website.
 

data/README.md

@@ -15,15 +15,11 @@
   <img src="https://img.shields.io/codeclimate/maintainability/avamia/kanrisuru?style=flat-square" alt="Code Climate maintainability" />
 </p>
 
-Kanrisuru (manage) helps you remotely control infrastructure using Ruby. This is done over SSH. I'm working on building up some basic functionality to help quickly provision, deploy and manage a single host or cluster of hosts.
+Kanrisuru manages remote infrastructure with plain ruby objects. The goal with Kanrisuru is to provide a clean objected oriented wrapper over the most commonly used linux commands, with a clean command interface, and with any usable output, present that as parsed structured data. Kanrisuru doesn't use remote agents to run commands on hosts, nor does the project rely on a large complex set of dependencies.
 
-The idea behind this project is not to replace the numerous other projects to manage your infrastrucutre, however, I've found there usually meant to be a standalone project that have their own ecosystem. With Kanrisuru, you essentailly plug the library directly into your ruby project.
+## Getting Started
 
-At this point, Kanrisuru doesn't use a DSL, or offer idempotency, and while that may be added later on, the goal with this project is to expose helpful ways of managing your remote infrastructure with plain ruby in a procedural manner. The realization I had was when trying to deal with other open source projects, you either had to deal with a different language than ruby, use agents on remote hosts, or deal with a complex library that is meant to act in a declarative manner.
-
-If you want to dynamically interact with a host, eg: If you need to dynamically scale your infrastructure by continually monitoring specific stats from a centralized system, Kanrisuru can help you accomplish this.
-
-## Installation
+Kanrisuru requires ruby `2.5.0` at a minimum.
 
 Add this line to your application's Gemfile:
 
@@ -43,48 +39,128 @@ Or install it yourself as:
 $ gem install kanrisuru
 ```
 
-## Usage
-Run basic commands you would have access to while running on a remote host or on a cluster of hosts.
+## Documentation
+You can find the official documentation https://kanrisuru.com
 
+## Usage Guide
 ### Host
+To connect with Kanrisuru to a remote host, provide the login credentials to instantiate a `Kanrisuru::Remote::Host` instance.
+
+```ruby
+host = Kanrisuru::Remote::Host.new(
+  host: 'remote-host-name', 
+  username: 'ubuntu', 
+  keys: ['~/.ssh/id_rsa']
+)
+```
+
+#### run a simple echo command on the remote host
+```ruby
+host.env['VAR'] = 'world'
+result = host.echo('hello $VAR')
+result.success?
+true
+
+result.to_s
+'hello world'
+```
+
+#### build a custom command
+```ruby
+command = Kanrisuru::Command.new('wc')
+command << '/home/ubuntu/file1.txt'
+
+host.execute_shell(command)
+result = Kanrisuru::Result.new(command) do |cmd|
+  items = cmd.to_s.split
+  
+  struct = Kanrisuru::Core::File::FileCount.new
+  struct.lines = items[0]
+  struct.words = items[1]
+  struct.characters = items[2]
+  struct
+end
+```
+The `Kanrisuru::Result` class will only run the parsing block if the command run on the remote host was succeful. The final line will be used to build the result object to be read easily. This instance will also dynamically add getter methods to read the underlying data struct for easier querying capabiltiies.
+
 ```ruby
-host = Kanrisuru::Remote::Host.new(host: 'host', username: 'ubuntu', keys: ['~/.ssh/id_rsa'])
-result = host.whoami   
-result.to_s						# => 'ubuntu'
+result.success?
+true
 
-result = host.pwd
-result.path 					# => /home/ubuntu 
+result.lines
+8
+
+result.characters
+150
+
+result.words
+85
 ```
 
-### Cluster 
+### Cluster
+Kanrisuru can manage multiple hosts at the same time with the `Kanrisuru::Remote::Cluster`.
+
+#### To instantiate a cluster, add 1 or more hosts:
 ```ruby
 cluster = Kanrisuru::Remote::Cluster.new({
-  host: 'host1', username: 'ubuntu', keys: ['~/.ssh/id_rsa']
+  host: 'remote-host-1',
+  username: 'ubuntu',
+  keys: ['~/.ssh/remote_1_id_rsa']
+}, {
+  host: 'remote-host-2',
+  username: 'centos',
+  keys: ['~/.ssh/remote_2_id_rsa']
 }, {
-  host: 'host2', username: 'alice', keys: ['~/.ssh/id_rsa']
+  host: 'remote-host-3',
+  username: 'opensuse',
+  keys: ['~/.ssh/remote_3_id_rsa']
 })
-
-cluster.whoami   # => {host: 'host1', result: 'ubuntu'}, {host: 'host2', result: 'alice'}
-cluster.pwd      # => {host: 'host1', result: '/home/ubuntu'}, {host: 'host2', result: '/home/alice'}
-
-cluster.each do |host|
-  host.pwd.path  # => /home/ubuntu
-end
 ```
 
-### Host or Cluster with underlying command
+#### You can also add a host to a cluster that's already been created 
 ```ruby
-host = Kanrisuru::Remote::Host.new(host: 'host1', username: 'ubuntu', keys: ['~/.ssh/id_rsa'])
+host = Kanrisuru::Remote::Host.new(host: 'remote-host-4', username: 'rhel', keys: ['~/.ssh/remote_4_id_rsa'])
 
-command = Kanrisuru::Command.new('uname')
-host.execute(command)
+cluster << host 
+```
 
-command.success? #=> true
-command.to_s  #=> Linux
+Kanrisuru at this point only runs commands sequentially. We plan on creating a parallel run mode in a future release.
 
-cluster = Kanrisuru::Remote::Cluster.new(host, {host: 'host2', username: 'alice', keys: ['~/.ssh/id_rsa']})
+#### To run across all hosts with a single command, cluster will return a array of result hashes
+```ruby
+cluster.whoami
+[
+  {
+    :host => "remote-host-1",
+    :result => #<Kanrisuru::Result:0x640 @status=0 @data=#<struct Kanrisuru::Core::Path::UserName user="ubuntu"> @command=sudo -u ubuntu /bin/bash -c "whoami">
+  },
+  {
+    :host => "remote-host-2",
+    :result => #<Kanrisuru::Result:0x700 @status=0 @data=#<struct Kanrisuru::Core::Path::UserName user="centos"> @command=sudo -u centos /bin/bash -c "whoami">
+  },
+  {
+    :host => "remote-host-3",
+    :result => #<Kanrisuru::Result:0x760 @status=0 @data=#<struct Kanrisuru::Core::Path::UserName user="opensuse"> @command=sudo -u opensuse /bin/bash -c "whoami">
+  },
+  {
+    :host => "remote-host-4",
+    :result => #<Kanrisuru::Result:0x820 @status=0 @data=#<struct Kanrisuru::Core::Path::UserName user="rhel"> @command=sudo -u rhel /bin/bash -c "whoami">
+  }
+]
+```
 
-cluster.execute('uname') #=> {host: 'host1', result: 'Linux'}, {host: 'host2', result: 'Linux'}
+#### You can also access each host individually to run a command conditionaly within an iterable block
+```ruby
+cluster.each do |host|
+  case host.os.release
+  when 'ubuntu', 'debian'
+    host.apt('update')
+  when 'centos', 'redhat', 'fedora'
+    host.yum('update')
+  when 'opensuse_leap', 'sles'
+    host.zypper('update')
+  end
+end
 ```
 
 ## Development

data/lib/kanrisuru/command.rb

@@ -7,6 +7,7 @@ module Kanrisuru
 
     def initialize(command)
       @valid_exit_codes = [0]
+
       @raw_command = command
       @raw_result = []
     end

data/lib/kanrisuru/core/dmi/parsers/dmi.rb

@@ -94,40 +94,40 @@ module Kanrisuru
 
             def dmi_field_translate(struct, field)
               field = dmi_scrub_field(field)
-
               case struct.dmi_type
               when 'Memory Device'
                 case field
                 when 'size'
-                  'mem_size'
+                  field = 'mem_size'
                 end
               when 'System Slots'
                 case field
                 when 'length'
-                  'slot_length'
+                  field = 'slot_length'
                 end
               when 'OEM Strings'
                 case field
                 when /^string/
-                  'strings'
+                  field = 'strings'
                 end
               when 'Boot Integrity Services'
                 case field
                 when '16_bit_entry_point_address'
-                  'sixteen_bit_entry_point_address'
+                  field = 'sixteen_bit_entry_point_address'
                 when '32_bit_entry_point_address'
-                  'thirty_two_bit_entry_point_address'
+                  field = 'thirty_two_bit_entry_point_address'
                 end
-              else
-                field
               end
+
+              field
             end
 
             def dmi_scrub_field(field)
               field = field.downcase
               field = field.gsub(/\s/, '_')
               field = field.gsub('-', '_')
-              field.gsub(':', '')
+              field = field.gsub(':', '')
+              field
             end
 
             def dmi_type_to_struct(type)

data/lib/kanrisuru/core/find/commands/find.rb

@@ -36,6 +36,7 @@ module Kanrisuru
 
         command.append_arg('-path', opts[:path])
         command.append_arg('-name', opts[:name])
+        command.append_arg('-iname', opts[:iname])
         command.append_arg('-gid', opts[:gid])
         command.append_arg('-uid', opts[:uid])
         command.append_arg('-user', opts[:user])
@@ -58,7 +59,8 @@ module Kanrisuru
           command.append_arg('-regextype', opts[:regex_type])
         end
 
-        command.append_arg('-regex', "'#{regex}'") if Kanrisuru::Util.present?(regex)
+        command.append_arg('-regex', "'#{opts[:regex]}'") if Kanrisuru::Util.present?(opts[:regex])
+        command.append_arg('-iregex', "'#{opts[:iregex]}'") if Kanrisuru::Util.present?(opts[:iregex])
 
         if size.instance_of?(String)
           regex = Regexp.new(/^([-+])?(\d+)([bcwkMG])*$/)

data/lib/kanrisuru/core/transfer/commands/upload.rb

@@ -10,9 +10,18 @@ module Kanrisuru
           result = ssh.scp.upload!(local_path, tmp_path, opts)
           raise 'Unable to upload file' unless result
 
-          result = mv(tmp_path, remote_path)
-          raise 'Unable to move file to remote path' unless result.success?
+          ## Need to copy internal dir contents, not the tmp dir itself
+          if opts[:recursive]
+            unless dir?(remote_path)
+              mkdir(remote_path, silent: true)
+            end
 
+            result = cp("#{tmp_path}/*", remote_path, recursive: true)
+          else
+            result = mv(tmp_path, remote_path)
+          end
+
+          raise "Unable to move file to remote path - #{result.command.raw_result}" unless result.success?
           stat(remote_path)
         ensure
           rm(tmp_path, force: true) if inode?(tmp_path)

data/lib/kanrisuru/remote/cluster.rb

@@ -32,7 +32,7 @@ module Kanrisuru
       def execute(command)
         @hosts.map do |host_addr, host|
           ## Need to evaluate each host independently for the command.
-          cmd = Kanrisuru::Command.new(command)
+          cmd = create_command(command)
 
           { host: host_addr, result: host.execute(cmd) }
         end
@@ -41,7 +41,7 @@ module Kanrisuru
       def execute_shell(command)
         @hosts.map do |host_addr, host|
           ## Need to evaluate each host independently for the command.
-          cmd = Kanrisuru::Command.new(command)
+          cmd = create_command(command)
 
           { host: host_addr, result: host.execute_shell(cmd) }
         end
@@ -83,6 +83,17 @@ module Kanrisuru
 
       private
 
+      def create_command(command)
+        case command
+        when String
+          Kanrisuru::Command.new(command)
+        when Kanrisuru::Command
+          command.clone
+        else
+          raise ArgumentError, 'Invalid command type'
+        end
+      end
+
       def map_host_results(action)
         @hosts.map do |host_addr, host|
           { host: host_addr, result: host.send(action) }

data/lib/kanrisuru/version.rb

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

data/spec/functional/core/find_spec.rb

@@ -64,12 +64,24 @@ RSpec.describe Kanrisuru::Core::Find do
                              mmin: '300'),
                    'find /var/log -atime +1 -ctime +2 -mtime +3 -amin 100 -cmin 200 -mmin 300')
 
+    expect_command(host.find(
+                     paths: '/dev',
+                     iname: 'tty*'
+                   ),
+                   "find /dev -iname tty*")
+
     expect_command(host.find(
                      paths: '/dev',
                      regex: '/dev/tty[0-9]*'
                    ),
                    "find /dev -regex '/dev/tty[0-9]*'")
 
+    expect_command(host.find(
+                     paths: '/dev',
+                     iregex: '/dev/tty[0-9]*'
+                   ),
+                   "find /dev -iregex '/dev/tty[0-9]*'")
+
     expect_command(host.find(
                      paths: '/dev',
                      regex_type: 'posix-egrep',

data/spec/functional/remote/cluster_spec.rb

@@ -40,6 +40,19 @@ RSpec.describe Kanrisuru::Remote::Cluster do
     expect(cluster[host2.host]).to eq(host2)
     expect(cluster.hosts).to include(host1)
     expect(cluster.hosts).to include(host2)
+
+    cluster << {
+      host: 'centos-host',
+      username: 'centos',
+      keys: ['id_rsa']
+    }
+
+    expect(cluster.hosts.length).to eq(3)
+    expect(cluster.count).to eq(3)
+    expect(cluster.count).to eq(3)
+    expect(cluster['centos-host'].username).to eq('centos')
+    expect(cluster.hosts).to include(host1)
+    expect(cluster.hosts).to include(host2)
   end
 
   it 'fails to add host to a cluster' do
@@ -51,6 +64,62 @@ RSpec.describe Kanrisuru::Remote::Cluster do
     expect(cluster.count).to eq(0)
   end
 
+  it 'creates a new command instance' do
+    cluster = described_class.new
+    cluster << host1
+    cluster << host2
+
+    expect(cluster.send(:create_command, 'hello')).to be_instance_of(Kanrisuru::Command)
+
+    command = Kanrisuru::Command.new('ls')
+    command.remote_user = 'root'
+    command.remote_shell = '/bin/bash'
+    cloned_command = cluster.send(:create_command, command)
+
+    expect(cloned_command).to be_instance_of(Kanrisuru::Command)
+    expect(cloned_command.object_id).not_to eq(command.object_id)
+
+    expect(command.raw_command).to eq('ls')
+    expect(cloned_command.raw_command).to eq('ls')
+
+    expect(command.prepared_command).to eq('sudo -u root /bin/bash -c "ls"')
+    expect(cloned_command.prepared_command).to eq('sudo -u root /bin/bash -c "ls"')
+
+    expect {
+      cluster.send(:create_command, 1)
+    }.to raise_error(ArgumentError)
+  end
+
+  it 'runs execute for a command on a cluster' do
+    cluster = described_class.new
+    cluster << host1
+    cluster << host2
+
+    command = Kanrisuru::Command.new('pwd')
+
+    results = cluster.execute(command)
+    results.each do |result|
+      expect(result).to have_key(:host)
+      expect(result).to have_key(:result)
+    end
+  end
+
+  it 'runs execute_shell for a command on a cluster' do
+    cluster = described_class.new
+    cluster << host1
+    cluster << host2
+
+    command = Kanrisuru::Command.new('pwd')
+    command.remote_user = 'root'
+    command.remote_shell = '/bin/zsh'
+
+    results = cluster.execute_shell(command)
+    results.each do |result|
+      expect(result).to have_key(:host)
+      expect(result).to have_key(:result)
+    end
+  end
+
   it 'removes a host from a cluster' do
     cluster = described_class.new(host1, host2)
     expect(cluster.count).to eq(2)
@@ -63,4 +132,84 @@ RSpec.describe Kanrisuru::Remote::Cluster do
     expect(cluster.count).to eq(0)
     expect(cluster.hosts).not_to include(host1)
   end
+
+  it 'fetches the hostname for each host in a cluster' do
+    allow_any_instance_of(Kanrisuru::Remote::Host).to receive(:hostname).and_return('ubuntu')
+    cluster = described_class.new(host1, host2)
+
+    results = cluster.hostname
+    results.each do |result|
+      expect(result).to have_key(:host)
+      expect(result).to have_key(:result)
+      expect(result[:result]).to eq('ubuntu')
+    end
+  end
+
+  it 'pings the host for each host in a cluster' do
+    allow_any_instance_of(Kanrisuru::Remote::Host).to receive(:ping?).and_return(true)
+    cluster = described_class.new(host1, host2)
+
+    results = cluster.ping?
+    results.each do |result|
+      expect(result).to have_key(:host)
+      expect(result).to have_key(:result)
+      expect(result[:result]).to eq(true)
+    end
+  end
+
+  it 'switches user for each host in a cluster' do
+    cluster = described_class.new(host1, host2)
+
+    cluster.su('root')
+    cluster.each do |host|
+      expect(host.remote_user).to eq('root')
+    end
+  end
+
+  it 'changes current working directory for each host in a cluster' do
+    cluster = described_class.new(host1, host2)
+
+    StubNetwork.stub_command!(:pwd) do
+      Kanrisuru::Core::Path::FilePath.new('/etc')
+    end
+    StubNetwork.stub_command!(:realpath) do
+      Kanrisuru::Core::Path::FilePath.new('/etc')
+    end
+
+    cluster.cd('/etc')
+    cluster.each do |host|
+      expect(host.instance_variable_get(:@current_dir)).to eq('/etc') 
+    end 
+
+    StubNetwork.unstub_command!(:pwd)
+    StubNetwork.unstub_command!(:realpath)
+  end
+
+  it 'changes current working directory for each host in a cluster' do
+    cluster = described_class.new(host1, host2)
+
+    StubNetwork.stub_command!(:pwd) do
+      Kanrisuru::Core::Path::FilePath.new('/etc')
+    end
+
+    StubNetwork.stub_command!(:realpath) do
+      Kanrisuru::Core::Path::FilePath.new('/etc')
+    end
+
+    cluster.chdir('/etc')
+    cluster.each do |host|
+      expect(host.instance_variable_get(:@current_dir)).to eq('/etc') 
+    end 
+
+    StubNetwork.unstub_command!(:pwd)
+    StubNetwork.unstub_command!(:realpath)
+  end
+  
+  it 'fails to remove a host from a cluster' do
+    cluster = described_class.new(host1, host2)
+
+    expect {
+      cluster.delete(1)
+    }.to raise_error(ArgumentError)
+  end
 end

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

@@ -68,7 +68,7 @@ RSpec.shared_examples 'transfer' do |os_name, host_json, spec_dir|
     end
 
     it 'uploads a dir' do
-      path = '../meta/'
+      path = '/home/ubuntu/kanrisuru/meta/'
       dest_path = "#{spec_dir}/meta"
 
       result = host.upload(path, dest_path, recursive: true)

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

@@ -2,8 +2,24 @@
 
 require 'spec_helper'
 
-RSpec.shared_examples 'cluster' do |os_name, _host_json, _spec_dir|
+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',
@@ -41,5 +57,14 @@ RSpec.shared_examples 'cluster' do |os_name, _host_json, _spec_dir|
 
       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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kanrisuru
 version: !ruby/object:Gem::Version
-  version: 0.16.7
+  version: 0.16.11
 platform: ruby
 authors:
 - Ryan Mammina
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-27 00:00:00.000000000 Z
+date: 2021-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel_tests