kanrisuru 0.11.1 → 0.14.0

data/lib/kanrisuru/os_package/collection.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module OsPackage
+    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
+  end
+end

data/lib/kanrisuru/os_package/define.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+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
+  end
+end

data/lib/kanrisuru/os_package/include.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module OsPackage
+    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

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/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

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/version.rb

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

data/spec/functional/core/archive_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-RSpec.describe Kanrisuru::Core::Apt do
+RSpec.describe Kanrisuru::Core::Archive do
   before(:all) do
     StubNetwork.stub!
     StubNetwork.stub_command!(:realpath) do |_args|
@@ -141,6 +141,7 @@ RSpec.describe Kanrisuru::Core::Apt 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),

data/spec/functional/core/mount_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kanrisuru::Core::Mount do
+  before(:all) do
+    StubNetwork.stub!
+  end
+
+  after(:all) do
+    StubNetwork.unstub!
+  end
+
+  let(:host) do
+    Kanrisuru::Remote::Host.new(
+      host: 'localhost',
+      username: 'ubuntu',
+      keys: ['id_rsa']
+    )
+  end
+
+  it 'prepares mount command' do
+    expect_command(host.mount, 'mount')
+    expect_command(host.mount(bind_old: '/mnt/dira', bind_new: '/mnt/dirb'), 'mount --bind /mnt/dira /mnt/dirb')
+    expect_command(host.mount(rbind_old: '/mnt/dira', rbind_new: '/mnt/dirb'), 'mount --rbind /mnt/dira /mnt/dirb')
+    expect_command(host.mount(move_old: '/mnt/dira', move_new: '/mnt/dirb'), 'mount --move /mnt/dira /mnt/dirb')
+    expect_command(host.mount(
+                     label: 'cloudimg-rootfs',
+                     uuid: '5fbaea960d09e2ad',
+                     sloppy: true,
+                     internal_only: true,
+                     fake: true,
+                     no_mtab: true,
+                     no_canonicalize: true,
+                     device: '/dev/vda9',
+                     directory: '/mnt/dir1'
+                   ), 'mount -L cloudimg-rootfs -U 5fbaea960d09e2ad -f -i -s --no-mtab --no-canonicalize /dev/vda9 /mnt/dir1')
+
+    expect_command(host.mount(
+                     fs_opts: { async: true, auto: true, group: true, relatime: true, owner: true },
+                     device: '/dev/tty',
+                     directory: '/mnt/dir2'
+                   ), 'mount -o async,auto,group,relatime,owner /dev/tty /mnt/dir2')
+
+    expect do
+      host.mount(fs_opts: { value: true }, device: '/home/ubuntu/dir', directory: '/mnt/dir3')
+    end.to raise_error(ArgumentError)
+
+    expect_command(host.mount(
+                     type: 'ext2',
+                     device: '/dev/tty',
+                     directory: '/mnt/dir2'
+                   ), 'mount -t ext2 /dev/tty /mnt/dir2')
+
+    expect_command(host.mount(
+                     type: 'ext4',
+                     fs_opts: { acl: true, journal: 'update', usrquota: true, async: true, owner: true, group: true },
+                     device: '/dev/tty',
+                     directory: '/mnt/dir2'
+                   ), 'mount -t ext4 -o acl,journal=update,usrquota,async,owner,group /dev/tty /mnt/dir2')
+
+    expect_command(host.mount(type: 'nontfs,xfs', all: true), 'mount -t nontfs,xfs -a')
+    expect_command(host.mount(type: 'fat,xfs', all: true), 'mount -t fat,xfs -a')
+
+    expect do
+      host.mount(
+        type: 'ext2',
+        fs_opts: { acl: true, journal: 'update', usrquota: true, async: true, owner: true, group: true },
+        device: '/dev/tty',
+        directory: '/mnt/dir2'
+      )
+    end.to raise_error(ArgumentError)
+
+    expect do
+      host.mount(
+        type: 'ext4',
+        fs_opts: { acl: true, journal: true, usrquota: true, async: true, owner: true, group: true },
+        device: '/dev/tty',
+        directory: '/mnt/dir2'
+      )
+    end.to raise_error(ArgumentError)
+
+    expect_command(host.mount(all: true, test_opts: { _netdev: true }), 'mount -a -O _netdev')
+    expect_command(host.mount(all: true, test_opts: { async: true, blocksize: 512, uid: 0, gid: 0, dots: true }, type: 'fat'),
+                   'mount -t fat -a -O async,blocksize=512,uid=0,gid=0,dots')
+
+    expect_command(host.mount(
+                     type: 'loop',
+                     fs_opts: { loop: '/dev/loop3' },
+                     device: '/mnt',
+                     directory: '/tmp/fdimage'
+                   ),
+                   'mount -t loop -o loop=/dev/loop3 /mnt /tmp/fdimage')
+  end
+
+  it 'prepares umount command' do
+    expect_command(host.umount, 'umount')
+    expect_command(host.umount(
+                     fake: true,
+                     no_canonicalize: true,
+                     no_mtab: true,
+                     fail_remount_readonly: true,
+                     free_loopback: true,
+                     lazy: true,
+                     force: true,
+                     device: '/dev/vda1'
+                   ),
+                   'umount --fake --no-canonicalize -n -r -d -l -f /dev/vda1')
+
+    expect_command(host.umount(
+                     all: true,
+                     type: 'ext4,nofat'
+                   ), 'umount -a -t ext4,nofat')
+
+    expect_command(host.umount(
+                     all: true,
+                     type: 'ext4',
+                     test_opts: { barrier: 1, nouid32: true }
+                   ), 'umount -a -t ext4 -O barrier=1,nouid32')
+  end
+end