kanrisuru 0.9.2 → 0.12.0

data/lib/kanrisuru/os_package.rb

@@ -1,247 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
-module Kanrisuru
-  module OsPackage
-    module Define
-      def self.extended(base)
-        base.instance_variable_set(:@os_method_properties, {})
-        base.instance_variable_set(:@os_methods, Set.new)
-      end
-
-      def os_define(os_name, method_name, options = {})
-        unique_method_name = options[:alias] || method_name
-
-        @os_methods.add(method_name)
-
-        if @os_method_properties.key?(unique_method_name)
-          params = {
-            os_name: os_name.to_s,
-            method_name: method_name,
-            options: options
-          }
-
-          @os_method_properties[unique_method_name].prepend(params)
-        else
-          @os_method_properties[unique_method_name] = [{
-            os_name: os_name.to_s,
-            method_name: method_name,
-            options: options
-          }]
-        end
-      end
-    end
-
-    module Collection
-      def os_collection(mod, opts = {})
-        os_method_properties = mod.instance_variable_get(:@os_method_properties)
-        os_method_names = os_method_properties.keys
-
-        namespace          = opts[:namespace]
-        namespace_instance = nil
-
-        if namespace
-          ## Define the namespace as an eigen class instance on the host.
-          ## Namespaced instances will access core host methods
-          ## with @host instance variable.
-
-          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
-
-          namespace_class.class_eval do
-            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) }
-                end
-              end
-            end
-          end
-        else
-          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) }
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-    module Include
-      def os_include(mod, opts = {})
-        os_method_properties = mod.instance_variable_get(:@os_method_properties)
-        os_method_names = os_method_properties.keys
-
-        ## Need to encapsulate any helper methods called in the module
-        ## to bind to the host instance. This acts as a psudeo module include.
-        os_methods        = mod.instance_variable_get(:@os_methods)
-
-        public_methods    = mod.instance_methods(false) - os_methods.to_a
-        private_methods   = mod.private_instance_methods(false)
-        protected_methods = mod.protected_instance_methods(false)
-        include_methods   = (public_methods + protected_methods + private_methods).flatten
-
-        include_method_bindings = proc do
-          include_methods.each do |method_name|
-            define_method method_name do |*args, &block|
-              unbound_method = mod.instance_method(method_name)
-              bind_method(unbound_method, *args, &block)
-            end
-          end
-
-          private_methods.each { |method_name| private(method_name) }
-          protected_methods.each { |method_name| protected(method_name) }
-
-          private
-          if RUBY_VERSION < '2.7'
-            define_method 'bind_method' do |unbound_method, *args, &block|
-              unbound_method.bind(self).call(*args, &block)
-            end
-          else
-            define_method 'bind_method' do |unbound_method, *args, &block|
-              unbound_method.bind_call(self, *args, &block)
-            end
-          end
-        end
-
-        namespace          = opts[:namespace]
-        namespace_class    = nil
-        namespace_instance = nil
-
-        if namespace
-          ## Define the namespace as an eigen class instance within the host class.
-          ## Namespaced instances will access core host methods
-          ## with @host instance variable.
-
-          ## 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
-              end
-            end
-          end
-
-          namespace_class.class_eval(&include_method_bindings)
-        else
-          class_eval(&include_method_bindings)
-        end
-
-        class_eval do
-          os_method_names.each do |method_name|
-            if namespace
-              namespace_class.class_eval do
-                define_method method_name do |*args, &block|
-                  unbound_method = nil
-
-                  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
-                      raise NoMethodError, "undefined method `#{method_name}' for #{self.class}"
-                    end
-
-                    ## Get reference to the unbound method defined in module
-                    unbound_method = mod.instance_method(defined_method_name)
-                    raise NoMethodError, "undefined method `#{method_name}' for #{self.class}" unless unbound_method
-
-                    ## Cache the unbound method on this host instance for faster resolution on
-                    ## the next invocation of this 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
-                  ## call it with args and block
-                  bind_method(unbound_method, *args, &block)
-                end
-              end
-            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
-                  ## 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
-
-                  ## Get reference to the unbound method defined in module
-                  unbound_method = mod.instance_method(defined_method_name)
-                  raise NoMethodError, "undefined method `#{method_name}' for #{self.class}" unless unbound_method
-
-                  ## 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
-                ## call it with args and block
-                bind_method(unbound_method, *args, &block)
-              end
-            end
-          end
-
-          def resolve_os_method_name(properties, method_name)
-            kernel  = os.kernel.downcase
-            release = os.release.downcase
-
-            properties[method_name].each do |property|
-              os_name = property[:os_name]
-              strict = property[:options] ? property[:options][:strict] : false
-              except = property[:options] ? property[:options][:except] : ''
-
-              next if except && (except == release || except.include?(release))
-
-              if release == os_name || kernel == os_name ||
-                 (Kanrisuru::Util::OsFamily.family_include_distribution?(os_name, release) && !strict) ||
-                 (Kanrisuru::Util::OsFamily.upstream_include_distribution?(os_name, release) && !strict)
-                return property[:method_name]
-              end
-            end
-
-            nil
-          end
-        end
-      end
-    end
-  end
-end
+require_relative 'os_package/collection'
+require_relative 'os_package/define'
+require_relative 'os_package/include'

data/lib/kanrisuru/remote/cpu.rb

@@ -27,6 +27,10 @@ module Kanrisuru
         load_average[2]
       end
 
+      def architecture
+        @cpu_architecture.architecture
+      end
+
       def sockets
         @cpu_architecture.sockets
       end
@@ -103,7 +107,7 @@ module Kanrisuru
         @cpu_architecture.flags
       end
 
-        def hyperthreading?
+      def hyperthreading?
         threads_per_core > 1
       end
 

data/lib/kanrisuru/remote/env.rb

@@ -25,6 +25,14 @@ module Kanrisuru
         string
       end
 
+      def count
+        @env.count
+      end
+
+      def delete(key)
+        @env.delete(key.to_s.upcase)
+      end
+
       def [](key)
         @env[key.to_s.upcase]
       end

data/lib/kanrisuru/remote/fstab.rb

@@ -161,7 +161,7 @@ module Kanrisuru
 
           if Kanrisuru::Util.present?(@line) && @line.instance_of?(String)
             parse_line!
-          elsif Kanrisuru::Util.present?(@opts) && @opts.instance_of?(String) || @opts.instance_of?(Hash)
+          elsif (Kanrisuru::Util.present?(@opts) && @opts.instance_of?(String)) || @opts.instance_of?(Hash)
             @opts = Kanrisuru::Remote::Fstab::Options.new(@type, @opts)
           end
         end
@@ -255,7 +255,7 @@ module Kanrisuru
           end
 
           result = @host.blkid(device: @device)
-          @uuid = result.success? ? result.uuid : nil
+          @uuid = result.success? ? result[0].uuid : nil
         end
 
         def parse_uuid(fsline)
@@ -269,15 +269,15 @@ module Kanrisuru
           end
 
           result = @host.blkid(device: @device)
-          @label = result.success? ? result.label : nil
+          @label = result.success? ? result[0].label : nil
         end
 
         def parse_dev(fsline)
           @device = fsline
           result = @host.blkid(device: @device)
 
-          @label = result.success? ? result.label : nil
-          @uuid = result.success? ? result.uuid : nil
+          @label = result.success? ? result[0].label : nil
+          @uuid = result.success? ? result[0].uuid : nil
         end
       end
 

data/lib/kanrisuru/result.rb

@@ -40,13 +40,14 @@ module Kanrisuru
     end
 
     def to_i
-      if @data.instance_of?(Integer)
+      case @data
+      when Integer
         @data
-      elsif @data.instance_of?(String)
+      when String
         @data.to_i
-      elsif @data.instance_of?(Array)
+      when Array
         @data.map(&:to_i)
-      elsif @data.instance_of?(NilClass)
+      when NilClass
         nil
       else
         raise NoMethodError, "(undefined method `to_i' for Kanrisuru::Result)"

data/lib/kanrisuru/util.rb

@@ -24,7 +24,7 @@ module Kanrisuru
       Kanrisuru.logger.info do
         'DEPRECATION WARNING: string_join_array will be removed in the upcoming major release. Use array_join_string instead.'
       end
-      
+
       array = arg.instance_of?(String) ? [arg] : arg
       array.join(field)
     end

data/lib/kanrisuru/version.rb

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

data/spec/functional/core/apt_spec.rb

@@ -22,10 +22,9 @@ RSpec.describe Kanrisuru::Core::Apt do
   it 'prepares apt list command' do
     expect_command(host.apt('list'), 'apt list')
     expect_command(host.apt('list',
-      installed: true,
-      upgradeable: true,
-      all_versions: true,
-    ), 'apt list --installed --upgradeable --all-versions')
+                            installed: true,
+                            upgradeable: true,
+                            all_versions: true), 'apt list --installed --upgradeable --all-versions')
 
     expect_command(host.apt('list', package_name: 'nginx'), 'apt list -a nginx')
   end
@@ -43,28 +42,22 @@ RSpec.describe Kanrisuru::Core::Apt do
   end
 
   it 'prepares apt install command' do
-    expect_command(host.apt('install', 
-        packages: 'nginx'
-      ),
-      'apt-get install -y nginx'
-    )
-
-    expect_command(host.apt('install', 
-        packages: 'monit',
-        no_upgrade: true,
-        reinstall: true
-      ),
-      'apt-get install -y --no-upgrade --reinstall monit'
-    )
-
-    expect_command(host.apt('install', 
-        packages: ['build-essential', 'manpages-dev'],
-        only_upgrade: true,
-      ),
-      'apt-get install -y --only-upgrade build-essential manpages-dev'
-    )
+    expect_command(host.apt('install',
+                            packages: 'nginx'),
+                   'apt-get install -y nginx')
+
+    expect_command(host.apt('install',
+                            packages: 'monit',
+                            no_upgrade: true,
+                            reinstall: true),
+                   'apt-get install -y --no-upgrade --reinstall monit')
+
+    expect_command(host.apt('install',
+                            packages: %w[build-essential manpages-dev],
+                            only_upgrade: true),
+                   'apt-get install -y --only-upgrade build-essential manpages-dev')
   end
-  
+
   it 'prepares apt remove command' do
     expect_command(host.apt('remove', packages: ['python']), 'apt-get remove -y python')
   end
@@ -82,15 +75,14 @@ RSpec.describe Kanrisuru::Core::Apt do
   end
 
   it 'prepares apt show command' do
-    expect_command(host.apt('show', packages: 'ruby'), 'apt show -a ruby') 
-  end 
+    expect_command(host.apt('show', packages: 'ruby'), 'apt show -a ruby')
+  end
 
   it 'prepares apt clean command' do
-    expect_command(host.apt('clean'), 'apt-get clean') 
+    expect_command(host.apt('clean'), 'apt-get clean')
   end
 
   it 'prepares apt autoclean command' do
-    expect_command(host.apt('autoclean'), 'apt-get autoclean') 
+    expect_command(host.apt('autoclean'), 'apt-get autoclean')
   end
-
 end

data/spec/functional/core/archive_spec.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Core::Archive do
+  before(:all) do
+    StubNetwork.stub!
+    StubNetwork.stub_command!(:realpath) do |_args|
+      Kanrisuru::Core::Path::FilePath.new(directory)
+    end
+  end
+
+  after(:all) do
+    StubNetwork.unstub_command!(:realpath)
+    StubNetwork.unstub!
+  end
+
+  let(:host) do
+    Kanrisuru::Remote::Host.new(
+      host: 'localhost',
+      username: 'ubuntu',
+      keys: ['id_rsa']
+    )
+  end
+
+  let(:directory) { '/home/ubuntu/dir' }
+
+  it 'prepares tar list command' do
+    %w[list t].each do |action_variant|
+      expect_command(host.tar(action_variant, 'file.txt'),
+                     'tar --restrict -f file.txt -t')
+
+      expect_command(host.tar(action_variant, '~/file.txt',
+                              compress: 'bzip2',
+                              directory: directory,
+                              occurrence: 1,
+                              label: true,
+                              multi_volume: true),
+                     'tar --restrict -C /home/ubuntu/dir -f ~/file.txt -j -t --occurrence 1 --label --multi-volume')
+    end
+  end
+
+  it 'prepares tar extract command' do
+    %w[extract get x].each do |action_variant|
+      expect_command(host.tar(action_variant, 'archive.tar'),
+                     'tar --restrict -f archive.tar -x')
+
+      expect_command(host.tar(action_variant, 'archive.tar',
+                              compress: 'xz',
+                              directory: directory,
+                              occurrence: 2,
+                              no_same_owner: true,
+                              no_same_permissions: true,
+                              no_selinux: true,
+                              no_xattrs: true,
+                              multi_volume: true,
+                              label: true,
+                              skip_old_files: true,
+                              overwrite: true,
+                              overwrite_dir: true,
+                              unlink_first: true,
+                              recursive_unlink: true,
+                              paths: 'file.txt'),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.tar -J -x --occurrence 2 --no-same-owner --no-same-permissions --no-selinux --no-xattrs --multi-volume --label --skip-old-files --overwrite --overwrite-dir --unlink-first --recursive-unlink file.txt')
+
+      expect_command(host.tar(action_variant, 'archive.tar',
+                              preserve_permissions: true,
+                              same_owners: true,
+                              one_file_system: true,
+                              keep_old_files: true,
+                              paths: ['file1.txt', 'file2.txt']),
+                     'tar --restrict -f archive.tar -x --preserve-permissions --same-owner --one-file-system --keep-old-files file1.txt file2.txt')
+    end
+  end
+
+  it 'prepares tar create command' do
+    %w[create c].each do |action_variant|
+      expect_command(host.tar(action_variant, 'archive.lzma', compress: 'lzma'),
+                     'tar --restrict -f archive.lzma --lzma -c')
+      expect_command(host.tar(action_variant, 'archive.gz'), 'tar --restrict -f archive.gz -c')
+
+      expect_command(host.tar(action_variant, 'archive.gz',
+                              directory: directory,
+                              compress: 'gzip',
+                              exclude: 'file2.txt',
+                              paths: 'file1.txt'),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.gz -z -c --exclude=file2.txt file1.txt')
+
+      expect_command(host.tar(action_variant, 'archive.gz',
+                              compress: 'gzip',
+                              exclude: ['file2.txt', 'file4.txt'],
+                              paths: ['file1.txt', 'file3.txt']),
+                     'tar --restrict -f archive.gz -z -c --exclude=file2.txt --exclude=file4.txt file1.txt file3.txt')
+    end
+  end
+
+  it 'prepares tar append command' do
+    %w[append r].each do |action_variant|
+      expect_command(host.tar(action_variant, 'archive.tar'), 'tar --restrict -f archive.tar -r')
+
+      expect_command(host.tar(action_variant, 'archive.tar',
+                              directory: directory,
+                              paths: 'main.conf'),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.tar -r main.conf')
+
+      expect_command(host.tar(action_variant, 'archive.tar',
+                              paths: ['main.conf', 'main2.conf']),
+                     'tar --restrict -f archive.tar -r main.conf main2.conf')
+    end
+  end
+
+  it 'prepares tar concat command' do
+    %w[catenate concat A].each do |action_variant|
+      expect_command(host.tar(action_variant, 'archive.tar'), 'tar --restrict -f archive.tar -A')
+      expect_command(host.tar(action_variant, 'archive.tar',
+                              directory: directory,
+                              paths: 'archive2.tar'),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.tar -A archive2.tar')
+
+      expect_command(host.tar(action_variant, 'archive.tar',
+                              directory: directory,
+                              paths: ['archive2.tar', 'archive3.tar']),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.tar -A archive2.tar archive3.tar')
+    end
+  end
+
+  it 'prepares tar update command' do
+    %w[update u].each do |action_variant|
+      expect_command(host.tar(action_variant, 'archive',
+                              paths: 'file1.txt'),
+                     'tar --restrict -f archive -u file1.txt')
+
+      expect_command(host.tar(action_variant, 'archive',
+                              directory: directory,
+                              paths: ['file1.txt', 'file2.txt']),
+                     'tar --restrict -C /home/ubuntu/dir -f archive -u file1.txt file2.txt')
+    end
+  end
+
+  it 'prepares tar diff command' do
+    %w[diff compare d].each do |action_variant|
+      expect_command(host.tar(action_variant, 'archive.tar', directory: directory),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.tar -d')
+
+      expect_command(host.tar(action_variant, 'archive.tar',
+                              directory: directory,
+                              occurrence: 4),
+                     'tar --restrict -C /home/ubuntu/dir -f archive.tar -d --occurrence 4')
+    end
+  end
+
+  it 'prepares tar delete command' do
+    expect_command(host.tar('delete', 'archive.tar', paths: 'file1.txt'),
+                   'tar --restrict -f archive.tar --delete file1.txt')
+    expect_command(host.tar('delete', 'archive.tar',
+                            paths: ['file1.txt', 'file2.txt'],
+                            occurrence: 3),
+                   'tar --restrict -f archive.tar --delete --occurrence 3 file1.txt file2.txt')
+  end
+
+  it 'prepares invalid tar command' do
+    expect do
+      host.tar('abc', 'file1.txt')
+    end.to raise_error(ArgumentError)
+
+    expect do
+      host.tar('create', 'archive.tar', compress: 'xip')
+    end.to raise_error(ArgumentError)
+  end
+end