kanrisuru 0.5.2 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 577077bbfed12648f504d29d8cfc71c3b370c629517a0e245bd9a666d59647de
-  data.tar.gz: c7172f53feae30e08ed8394077d091733624f0937925cf9e8c2778ef293341bf
+  metadata.gz: 4ffb2183c8f1a5610dd416259a663787076f79cb8502fe8656a52d2c2cd1a7e0
+  data.tar.gz: 43b63c2e14d7f29356cd110261ef1ba55aabd50e97830e4aea3770429625caf8
 SHA512:
-  metadata.gz: 1bb1ae43f1dbb544356c781c76d78abe38a006efae79379f802059d1571c75fb9e67c5ff7ae34aa5ae243591eb96c4f733167aa434683f4a5fcb6b92975ff7fb
-  data.tar.gz: a7b3cd0fe6804bd1ded0872b2d5cb42bb406cb5bd4572f5e40e689fe352ba2ce81162e5ceddb3cdadc9974217a37c7c4ac877ccb05012dab418fdb5d9117bee1
+  metadata.gz: c0b333f36fb00bd16177fe434522c2bd1717db0019d39dba681ab7810b786aca050e6ea79c2647a1bedf4f0bdb4d7e6ffb26079b2ad10d92d3b6da6e4372ee56
+  data.tar.gz: 17377294cc356a44b1a76c6d32bae36940d8ec43d31cdbf0716c4d347735a8d30591e94a8babc8f7cd70d68127f7177d6a2dd70015c4eb8132148868e47a227d

data/.github/CONTRIBUTING.md

@@ -0,0 +1,17 @@
+# How to contribute
+Thank you for your interest in contributing to the Kanrisuru project. We appreciate any volunteers that want to help improve, grow and sustain the Kanrisuru code base!
+
+## Submitting a bug
+* Do not open up a GitHub issue if the bug is a security vulnerability with the Kanrisuru project, instead send an email to engineeering@avamia.com for any security realted issues.
+* Check if there's already an existing issue before submitting a [similar one](https://github.com/avamia/kanrisuru/issues).
+* If you can't find a similar issue [open a new one](https://github.com/avamia/kanrisuru/issues/new?assignees=&labels=&template=bug_report.md). Be sure to include a **title and clear description**, as much relevant information as possible, and a **code sample** or an **executable test case** demonstrating the expected behavior that is not occurring.
+
+## Adding a core feature
+* We always welcome improving the core Kanrisuru project. If we are missing a core command available on most linux distros, this would be a place to add that type of functionality.
+* Other ideas like performance optimization, additional testing, and ease of use are great ways of improving the project.
+* If you want to create something outside of the core project, see the next section.
+
+## Adding a new module
+* If you want to extent Kanrisuru beyond the underlying system code base or core module packages, the best way is to create a new gem, in the format of `kanrisuru-package`. 
+* This helps keep the core Kanrisuru package from too much bloat.
+* See our developer module section to see how to build a new Kanrisuru module.

data/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,33 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. Ubuntu]
+ - Version [e.g. 22]
+ - Ruby version: [e.g 2.7.4]
+
+
+**Additional context**
+Add any other context about the problem here.

data/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

data/.rubocop.yml

@@ -20,6 +20,10 @@ Naming/InclusiveLanguage:
     - lib/kanrisuru/core/dmi.rb
     - spec/unit/core/dmi_spec.rb
 
+Naming/MethodParameterName:
+  Exclude:
+    - spec/functional/os_package_spec.rb
+
 Metrics/AbcSize:
   Enabled: false
 

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+## Kanrisuru 0.7.2 (August 9, 2021) ##
+* Fixed bug with the `os_method_cache` instance variable set in the namespaced instance of a host. This was causing collision issues inbetween host instances, where, hosts with the same aliased method name was getting overwritten (with a different OS), since the namespace instance variable existing on the host class definition wasn't getting reset inbetween host instantiations. Given that the `os_method_cache` is normally re-instantiated, this bug fix addresses this so that the `os_method_cache` is always defined on the host instance, ie:
+
+  ```ruby
+  host.instance_variable_get(:@os_method_cache)
+  host.instance_variable_set(:@os_method_cache, os_method_cache)
+  ```
+  This is done instead of being saved on the namespace module. With the previous bug fix of using namespaced keys, there's no way for a method to be overwritten otherwise with a global `os_method_cache`.
+
+## Kanrisuru 0.7.1 (August 8, 2021) ##
+* Fix bug with `os_include` when caching namespace unbound methods, use the namespace in the 
+cache key to avoid any namespace collisions with the same method name, namely:
+```ruby
+"#{namespace}.#{method_name}"
+```
+
+## Kanrisuru 0.7.0 (August 8, 2021) ##
+* Simplify `FileInfo` struct for return object of `ls` command.
+* Rename `size` to `fsize` for the `OpenFile` struct to avoid method naming conflicts of the struct class. 
+* Allow `os_include` and `os_collection` to define multiple groupings of methods with the same namespace.
+* Add `clear` method for remote env class, to remove any session based env variables.
+* Add `to_s` method to result for quick analysis of string based return values. 
+* Remove duplicate `numeric` method in the utils module.
+
+## Kanrisuru 0.6.0 (August 1, 2021) ##
+* Add `lsof` implementation in system core module
+* Fix changelog formatting
+* Add changelog url to gemspec
+
 ## Kanrisuru 0.5.2 (July 30, 2021) ##
 * Add changelog documentation
 * Update documentation table with new tested core module 
@@ -37,7 +66,6 @@
 * Fix `address_size` in `cpu` method call.
 
 ## Kanrisuru 0.3.0 (July 22, 2021) ##
-
 * Add `lscpu` system core module 
 * Replace `cpu` module internal fetching of data from `cpu_info` to `lscpu` struct.
  
@@ -78,7 +106,7 @@
 ## Kanrisuru 0.2.1 (June 16, 2021) ##
 * Add first working release on rubygems.org
 
-## Kanrisuru 0.2.0 (June 16, 2021) [YANKED]##
+## Kanrisuru 0.2.0 (June 16, 2021) [YANKED] ##
 
 ## Kanrisuru 0.1.0 (December 12, 2020) ##
 * Initialize repository, start working on project.

data/README.md

@@ -2,6 +2,10 @@
 [![Latest version](https://img.shields.io/github/license/avamia/kanrisuru)](https://github.com/avamia/kanrisuru/blob/main/LICENSE.txt) 
 ![GitHub repo size](https://img.shields.io/github/repo-size/avamia/kanrisuru) 
 
+<p align='center'>
+  <img src="https://s3.us-east-2.amazonaws.com/kanrisuru.com/kanrisuru-banner-02.png" width="600" />
+</p>
+
 # Kanrisuru
 
 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.
@@ -81,6 +85,8 @@ cluster.execute('uname') #=> {host: 'host1', result: 'Linux'}, {host: 'host2', r
 | Get CPU Info                          | cpu_info         | lscpu              | core   | https://linux.die.net/man/1/lscpu    | [x]    | [x]    | [x]    | [x]    | [x]  | [x]      | [x]  |
 | Get CPU architecture                          |  lscpu         | lscpu            | core   | https://linux.die.net/man/1/lscpu    | [x]    | [x]    | [x]    | [x]    | [x]  | [x]      | [x]  |
 | Get kernel stastics                          |  kernel_statistics         | cat /proc/stat            | core   |   | [x]    | [x]    | [x]    | [x]    | [x]  | [x]      | [x]  |
+| Get hardware BIOS info                          |  dmi         | dmidecode            | core   | https://linux.die.net/man/8/dmidecode  | [x]    | [x]    | [x]    | [x]    | [x]  | [x]      | [x]  |
+| Get open file details for processes                          |  lsof         | lsof            | core   | https://linux.die.net/man/8/lsof  | [x]    | [x]    | [x]    | [x]    | [x]  | [x]      | [x]  |
 | Get Load Average                      | load_average     | cat /proc/load_avg | core   |                                      | [x]    | [x]    | [x]    | [x]    | [x]  | [x]      | [x]  |
 | Get RAM Available                     | free             | cat /proc/meminfo  | core   |                                      | [x]    | [x]    | [x]    | [x]    | [x]  | [x]      | [x]  |
 | Get list of processes                 | ps               | ps                 | core   | https://linux.die.net/man/1/ps       | [x]    | [x]    | [x]    | [x]    | [x]  | [x]      | [x]  |

data/kanrisuru.gemspec

@@ -27,6 +27,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
 
   gem.metadata = {
-    'source_code_uri' => 'https://github.com/avamia/kanrisuru/'
+    'source_code_uri' => 'https://github.com/avamia/kanrisuru/',
+    'changelog_uri' => 'https://github.com/avamia/kanrisuru/blob/main/CHANGELOG.md'
   }
 end

data/lib/kanrisuru/core/path.rb

@@ -9,10 +9,10 @@ module Kanrisuru
 
       os_define :linux, :ls
       os_define :linux, :pwd
-      os_define :linux, :whoami
-      os_define :linux, :which
       os_define :linux, :realpath
       os_define :linux, :readlink
+      os_define :linux, :whoami
+      os_define :linux, :which
 
       FilePath = Struct.new(:path)
       FileInfoId = Struct.new(:inode, :mode, :memory_blocks, :uid, :gid, :fsize, :date, :path, :type)
@@ -46,7 +46,7 @@ module Kanrisuru
             type = values[1].include?('d') ? 'directory' : 'file'
             items <<
               if id
-                FileInfoId.new(
+                FileInfo.new(
                   values[0].to_i,
                   Kanrisuru::Mode.new(values[1]),
                   values[2].to_i,

data/lib/kanrisuru/core/system.rb

@@ -16,6 +16,9 @@ module Kanrisuru
       os_define :linux, :kill
 
       os_define :linux, :kernel_statistics
+      os_define :linux, :kstat
+
+      os_define :linux, :lsof
 
       os_define :linux, :uptime
 
@@ -101,6 +104,18 @@ module Kanrisuru
 
       UserLoggedIn = Struct.new(:user, :tty, :ip, :login, :idle, :jcpu, :pcpu, :command)
 
+      OpenFile = Struct.new(
+        :command,
+        :pid,
+        :uid,
+        :file_descriptor,
+        :type,
+        :device,
+        :fsize,
+        :inode,
+        :name
+      )
+
       def load_env
         command = Kanrisuru::Command.new('env')
         execute_shell(command)
@@ -205,9 +220,9 @@ module Kanrisuru
       end
 
       def cpu_info(spec)
-        Kanrisuru.logger.info {
+        Kanrisuru.logger.info do
           'DEPRECATION WARNING: cpu_info will be removed in the upcoming major release. Use lscpu instead.'
-        }
+        end
 
         name =
           case spec
@@ -305,6 +320,60 @@ module Kanrisuru
         Kanrisuru::Result.new(command)
       end
 
+      def lsof(_opts = {})
+        command = Kanrisuru::Command.new('lsof -F pcuftDsin')
+
+        execute_shell(command)
+        Kanrisuru::Result.new(command) do |cmd|
+          lines = cmd.to_a
+
+          current_row = nil
+          current_pid = nil
+          current_user = nil
+          current_command = nil
+
+          rows = []
+
+          lines.each do |line|
+            case line
+            when /^p/
+              current_pid = parse_lsof(line, 'p').to_i
+            when /^c/
+              current_command = parse_lsof(line, 'c')
+            when /^u/
+              current_user = parse_lsof(line, 'u').to_i
+            when /^f/
+              rows << current_row if current_row
+
+              current_row = OpenFile.new
+              current_row.pid = current_pid
+              current_row.command = current_command
+              current_row.uid = current_user
+
+              current_row.file_descriptor = parse_lsof(line, 'f')
+            when /^t/
+              current_row.type = parse_lsof(line, 't')
+            when /^D/
+              current_row.device = parse_lsof(line, 'D')
+            when /^s/
+              current_row.fsize = parse_lsof(line, 's').to_i
+            when /^i/
+              current_row.inode = parse_lsof(line, 'i').to_i
+            when /^n/
+              current_row.name = parse_lsof(line, 'n')
+            end
+          end
+
+          rows << current_row if current_row
+
+          rows
+        end
+      end
+
+      def kstat
+        kernel_statistics
+      end
+
       def kernel_statistics
         command = Kanrisuru::Command.new('cat /proc/stat')
 
@@ -494,6 +563,10 @@ module Kanrisuru
 
       private
 
+      def parse_lsof(line, char)
+        line.split(char, 2)[1]
+      end
+
       def parse_policy_abbr(value)
         case value
         when '-'

data/lib/kanrisuru/os_package.rb

@@ -8,7 +8,6 @@ module Kanrisuru
       def self.extended(base)
         base.instance_variable_set(:@os_method_properties, {})
         base.instance_variable_set(:@os_methods, Set.new)
-        base.instance_variable_set(:@os_method_cache, {})
       end
 
       def os_define(os_name, method_name, options = {})
@@ -46,13 +45,19 @@ module Kanrisuru
           ## Define the namespace as an eigen class instance on the host.
           ## Namespaced instances will access core host methods
           ## with @host instance variable.
-          namespace_class    = Kanrisuru::Remote::Cluster.const_set(Kanrisuru::Util.camelize(namespace), Class.new)
-          namespace_instance = Kanrisuru::Remote::Cluster.instance_variable_set("@#{namespace}", namespace_class.new)
 
-          class_eval do
-            define_method namespace do
-              namespace_instance.instance_variable_set(:@cluster, self)
-              namespace_instance
+          if Kanrisuru::Remote::Cluster.instance_variable_defined?("@#{namespace}")
+            namespace_class = Kanrisuru::Remote::Cluster.const_get(Kanrisuru::Util.camelize(namespace))
+            namespace_instance = instance_variable_get("@#{namespace}")
+          else
+            namespace_class    = Kanrisuru::Remote::Cluster.const_set(Kanrisuru::Util.camelize(namespace), Class.new)
+            namespace_instance = Kanrisuru::Remote::Cluster.instance_variable_set("@#{namespace}", namespace_class.new)
+
+            class_eval do
+              define_method namespace do
+                namespace_instance.instance_variable_set(:@cluster, self)
+                namespace_instance
+              end
             end
           end
 
@@ -96,12 +101,6 @@ module Kanrisuru
         include_methods   = (public_methods + protected_methods + private_methods).flatten
 
         include_method_bindings = proc do
-          define_method 'os_method_cache' do
-            @os_method_cache ||= {}
-          end
-
-          private :os_method_cache
-
           include_methods.each do |method_name|
             define_method method_name do |*args, &block|
               unbound_method = mod.instance_method(method_name)
@@ -132,17 +131,26 @@ module Kanrisuru
           ## Define the namespace as an eigen class instance within the host class.
           ## Namespaced instances will access core host methods
           ## with @host instance variable.
-          namespace_class    = Kanrisuru::Remote::Host.const_set(Kanrisuru::Util.camelize(namespace), Class.new)
-          namespace_instance = Kanrisuru::Remote::Host.instance_variable_set("@#{namespace}", namespace_class.new)
 
-          namespace_class.class_eval(&include_method_bindings)
+          ## Check to see if the namespace was defined. If so, additional methods will be appended to the
+          ## existing namespace class definition, otherwise, a new namespace class and instance will be
+          ## defined with the methods added.
+          if Kanrisuru::Remote::Host.instance_variable_defined?("@#{namespace}")
+            namespace_class = Kanrisuru::Remote::Host.const_get(Kanrisuru::Util.camelize(namespace))
+            namespace_instance = Kanrisuru::Remote::Host.instance_variable_get("@#{namespace}")
+          else
+            namespace_class    = Kanrisuru::Remote::Host.const_set(Kanrisuru::Util.camelize(namespace), Class.new)
+            namespace_instance = Kanrisuru::Remote::Host.instance_variable_set("@#{namespace}", namespace_class.new)
 
-          class_eval do
-            define_method namespace do
-              namespace_instance.instance_variable_set(:@host, self)
-              namespace_instance
+            class_eval do
+              define_method namespace do
+                namespace_instance.instance_variable_set(:@host, self)
+                namespace_instance
+              end
             end
           end
+
+          namespace_class.class_eval(&include_method_bindings)
         else
           class_eval(&include_method_bindings)
         end
@@ -151,14 +159,16 @@ module Kanrisuru
           os_method_names.each do |method_name|
             if namespace
               namespace_class.class_eval do
+
                 define_method method_name do |*args, &block|
                   unbound_method = nil
 
-                  if os_method_cache.key?(method_name)
-                    unbound_method = os_method_cache[method_name]
-                  else
-                    host = namespace_instance.instance_variable_get(:@host)
+                  host = namespace_instance.instance_variable_get(:@host)
+                  os_method_cache = host.instance_variable_get(:@os_method_cache) || {}
 
+                  if os_method_cache.key?("#{namespace}.#{method_name}")
+                    unbound_method = os_method_cache["#{namespace}.#{method_name}"]
+                  else
                     ## Find the correct method to resolve based on the OS for the remote host.
                     defined_method_name = host.resolve_os_method_name(os_method_properties, method_name)
                     unless defined_method_name
@@ -171,7 +181,8 @@ module Kanrisuru
 
                     ## Cache the unbound method on this host instance for faster resolution on
                     ## the next invocation of this method
-                    os_method_cache[method_name] = unbound_method
+                    os_method_cache["#{namespace}.#{method_name}"] = unbound_method
+                    host.instance_variable_set(:@os_method_cache, os_method_cache)
                   end
 
                   ## Bind the method to host instance and
@@ -182,12 +193,13 @@ module Kanrisuru
             else
               define_method method_name do |*args, &block|
                 unbound_method = nil
+                
+                host = self
+                os_method_cache = host.instance_variable_get(:@os_method_cache) || {}
 
                 if os_method_cache.key?(method_name)
                   unbound_method = os_method_cache[method_name]
                 else
-                  host = self
-
                   ## Find the correct method to resolve based on the OS for the remote host.
                   defined_method_name = host.resolve_os_method_name(os_method_properties, method_name)
                   raise NoMethodError, "undefined method `#{method_name}' for #{self.class}" unless defined_method_name
@@ -199,6 +211,7 @@ module Kanrisuru
                   ## Cache the unbound method on this host instance for faster resolution on
                   ## the next invocation of this method
                   os_method_cache[method_name] = unbound_method
+                  host.instance_variable_set(:@os_method_cache, os_method_cache)
                 end
 
                 ## Bind the method to host instance and

data/lib/kanrisuru/remote/env.rb

@@ -11,6 +11,10 @@ module Kanrisuru
         @env
       end
 
+      def clear
+        @env = {}
+      end
+
       def to_s
         string = ''
         @env.each.with_index do |(key, value), index|

data/lib/kanrisuru/result.rb

@@ -31,6 +31,10 @@ module Kanrisuru
       @data[prop]
     end
 
+    def to_s
+      @data.to_s
+    end
+
     def to_a
       @data.instance_of?(Array) ? @data : [@data]
     end

data/lib/kanrisuru/version.rb

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

data/spec/functional/core/system_spec.rb

@@ -26,14 +26,20 @@ RSpec.describe Kanrisuru::Core::System do
 
       it 'gets environment variables' do
         result = host.load_env
-
-        expect(result.success?).to be(true)
+        expect(result).to be_success
         expect(result.data).to be_instance_of(Hash)
       end
 
+      it 'gets open files' do
+        host.su('root')
+        result = host.lsof
+        expect(result).to be_success
+        expect(result.data).to be_instance_of(Array)
+      end
+
       it 'gets uptime' do
         result = host.uptime
-        expect(result.success?).to eq(true)
+        expect(result).to be_success
 
         expect(result).to respond_to(
           :boot_time, :uptime, :seconds,

data/spec/functional/os_package_spec.rb

@@ -16,7 +16,7 @@ module Kanrisuru
   module TestNamespace
     extend Kanrisuru::OsPackage::Define
 
-    os_define :unix_like, :tester
+    os_define :linux, :tester
     os_define :centos, :test_not_correct
 
     def tester
@@ -25,17 +25,82 @@ module Kanrisuru
 
     def test_not_correct; end
   end
+
+  module TestNamespaceAdditions
+    extend Kanrisuru::OsPackage::Define
+
+    os_define :linux, :add
+    os_define :linux, :minus
+
+    def add(a, b)
+      a + b
+    end
+
+    def minus(a, b)
+      a - b
+    end
+  end
+
+  module TestAliasNames
+    extend Kanrisuru::OsPackage::Define
+
+    os_define :fedora, :output_fedora, alias: :output
+    os_define :debian, :output_debian, alias: :output
+    os_define :sles,   :output_sles, alias: :output
+
+    def output_debian
+      'debian'
+    end
+
+    def output_fedora
+      'fedora'
+    end
+
+    def output_sles
+      'sles'
+    end
+  end
+
+  module TestAliasNamesNamespace
+    extend Kanrisuru::OsPackage::Define
+
+    os_define :fedora, :output_fedora, alias: :output
+    os_define :debian, :output_debian, alias: :output
+    os_define :sles,   :output_sles, alias: :output
+
+    def output_debian
+      'debian'
+    end
+
+    def output_fedora
+      'fedora'
+    end
+
+    def output_sles
+      'sles'
+    end
+  end
 end
 
 module Kanrisuru
   module Remote
     class Host
       os_include Kanrisuru::TestInclude
+
+      os_include Kanrisuru::TestAliasNames
+      os_include Kanrisuru::TestAliasNamesNamespace, namespace: :alias
+
+      os_include Kanrisuru::TestNamespaceAdditions, namespace: :asdf
       os_include Kanrisuru::TestNamespace, namespace: :asdf
     end
 
     class Cluster
       os_collection Kanrisuru::TestInclude
+
+      os_collection Kanrisuru::TestAliasNames
+      os_collection Kanrisuru::TestAliasNamesNamespace, namespace: :alias
+
+      os_collection Kanrisuru::TestNamespaceAdditions, namespace: :asdf
       os_collection Kanrisuru::TestNamespace, namespace: :asdf
     end
   end
@@ -64,12 +129,65 @@ RSpec.describe Kanrisuru::OsPackage do
 
     expect(host).to respond_to(:asdf)
     expect(host.asdf).to respond_to(:tester)
+    expect(host.asdf).to respond_to(:add)
+    expect(host.asdf).to respond_to(:minus)
+
     expect(host.asdf.tester).to eq 'hello namespace'
+    expect(host.asdf.add(1, 2)).to eq(3)
+    expect(host.asdf.minus(3, 2)).to eq(1)
+
     expect(host.tester).to eq('hello ubuntu')
+
     expect { host.asdf.test_not_correct }.to raise_error(NoMethodError)
     expect(cluster.asdf.tester).to be_instance_of(Array)
 
     host.disconnect
+    host2.disconnect
+    cluster.disconnect
+  end
+
+  it 'includes the correct alias named method' do
+    host1 = Kanrisuru::Remote::Host.new(host: 'ubuntu-host', username: 'ubuntu', keys: ['~/.ssh/id_rsa'])
+    host2 = Kanrisuru::Remote::Host.new(host: 'centos-host', username: 'centos', keys: ['~/.ssh/id_rsa'])
+    host3 = Kanrisuru::Remote::Host.new(host: 'opensuse-host', username: 'opensuse', keys: ['~/.ssh/id_rsa'])
+
+    cluster = Kanrisuru::Remote::Cluster.new([host1, host2, host3])
+
+    expect(host1).to respond_to(:output)
+    expect(host2).to respond_to(:output)
+    expect(host3).to respond_to(:output)
+    expect(host1.output).to eq('debian')
+    expect(host2.output).to eq('fedora')
+    expect(host3.output).to eq('sles')
+
+    expect(cluster).to respond_to(:output)
+    expect(cluster.output).to eq([
+      {:host=>"ubuntu-host", :result=>"debian"},
+      {:host=>"centos-host", :result=>"fedora"},
+      {:host=>"opensuse-host", :result=>"sles"}
+    ])
+
+    expect(host1).to respond_to(:alias)
+    expect(host2).to respond_to(:alias)
+    expect(host3).to respond_to(:alias)
+    expect(host1.alias).to respond_to(:output)
+    expect(host2.alias).to respond_to(:output)
+    expect(host3.alias).to respond_to(:output)
+    expect(host1.alias.output).to eq('debian')
+    expect(host2.alias.output).to eq('fedora')
+    expect(host3.alias.output).to eq('sles')
+
+    expect(cluster).to respond_to(:alias)
+    expect(cluster.alias).to respond_to(:output)
+    expect(cluster.alias.output).to eq([
+      {:host=>"ubuntu-host", :result=>"debian"},
+      {:host=>"centos-host", :result=>"fedora"},
+      {:host=>"opensuse-host", :result=>"sles"}
+    ])
+
+    host1.disconnect
+    host2.disconnect
+    host3.disconnect
     cluster.disconnect
   end
 end

data/spec/spec_helper.rb

@@ -4,7 +4,6 @@ require 'simplecov'
 SimpleCov.start
 
 require 'kanrisuru'
-
 require_relative 'helper/test_hosts'
 
 Kanrisuru.logger.level = Logger::WARN

data/spec/unit/core/apt_spec.rb

@@ -11,7 +11,7 @@ RSpec.describe Kanrisuru::Core::Apt do
     expect(Kanrisuru::Core::Apt::PackageOverview.new).to respond_to(
       :package, :version, :suites, :architecture, :installed, :upgradeable, :automatic
     )
-    
+
     expect(Kanrisuru::Core::Apt::PackageDetail.new).to respond_to(
       :package,
       :version,

data/spec/unit/core/ip_spec.rb

@@ -10,9 +10,9 @@ RSpec.describe Kanrisuru::Core::IP do
 
     expect(Kanrisuru::Core::IP::IP_ROUTE_TYPES).to(
       eq(%w[
-        unicast unreachable blackhole prohibit local
-        broadcast throw nat via anycast multicast
-      ])
+           unicast unreachable blackhole prohibit local
+           broadcast throw nat via anycast multicast
+         ])
     )
 
     expect(Kanrisuru::Core::IP::IPLinkProperty.new).to respond_to(

data/spec/unit/core/socket_spec.rb

@@ -13,20 +13,20 @@ RSpec.describe Kanrisuru::Core::Socket do
       :rmem_alloc, :rcv_buf, :wmem_alloc, :snd_buf,
       :fwd_alloc, :wmem_queued, :ropt_mem, :back_log, :sock_drop
     )
-    expect(Kanrisuru::Core::Socket::TCP_STATES).to eq( 
+    expect(Kanrisuru::Core::Socket::TCP_STATES).to eq(
       %w[
         established syn-sent syn-recv
         fin-wait-1 fin-wait-2 time-wait
         closed close-wait last-ack listening closing
       ]
     )
-    expect(Kanrisuru::Core::Socket::OTHER_STATES).to eq( 
+    expect(Kanrisuru::Core::Socket::OTHER_STATES).to eq(
       %w[
         all connected synchronized bucket syn-recv
         big
       ]
     )
-    expect(Kanrisuru::Core::Socket::TCP_STATE_ABBR).to eq( 
+    expect(Kanrisuru::Core::Socket::TCP_STATE_ABBR).to eq(
       {
         'ESTAB' => 'established', 'LISTEN' => 'listening', 'UNCONN' => 'unconnected',
         'SYN-SENT' => 'syn-sent', 'SYN-RECV' => 'syn-recv', 'FIN-WAIT-1' => 'fin-wait-1',

data/spec/unit/core/system_spec.rb

@@ -75,5 +75,16 @@ RSpec.describe Kanrisuru::Core::System do
     expect(Kanrisuru::Core::System::UserLoggedIn.new).to respond_to(
       :user, :tty, :ip, :login, :idle, :jcpu, :pcpu, :command
     )
+    expect(Kanrisuru::Core::System::OpenFile.new).to respond_to(
+      :command,
+      :pid,
+      :uid,
+      :file_descriptor,
+      :type,
+      :device,
+      :fsize,
+      :inode,
+      :name
+    )
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kanrisuru
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.7.2
 platform: ruby
 authors:
 - Ryan Mammina
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-30 00:00:00.000000000 Z
+date: 2021-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -114,6 +114,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/CONTRIBUTING.md"
+- ".github/ISSUE_TEMPLATE/bug_report.md"
+- ".github/ISSUE_TEMPLATE/feature_request.md"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -226,6 +229,7 @@ licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/avamia/kanrisuru/
+  changelog_uri: https://github.com/avamia/kanrisuru/blob/main/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths: