kanrisuru 0.10.0 → 0.12.1

data/lib/kanrisuru/command.rb

@@ -84,6 +84,13 @@ module Kanrisuru
       append_value("| #{value}")
     end
 
+    def append_array(value)
+      return unless Kanrisuru::Util.present?(value)
+
+      value = [value] if value.instance_of?(String)
+      append_value(value.join(' '))
+    end
+
     def append_value(value)
       @raw_command = "#{@raw_command} #{value}"
     end

data/lib/kanrisuru/core/archive.rb

@@ -10,18 +10,16 @@ module Kanrisuru
       FilePath = Struct.new(:path)
 
       def tar(action, file, opts = {})
-        compress    = opts[:compress]
         paths       = opts[:paths]
         exclude     = opts[:exclude]
-        directory   = opts[:directory]
 
         command = Kanrisuru::Command.new('tar --restrict')
 
-        directory = realpath(directory, strip: true).path if directory
+        directory = opts[:directory] ? realpath(opts[:directory], strip: true).path : nil
         command.append_arg('-C', directory)
         command.append_arg('-f', file)
 
-        set_compression(command, compress) if compress
+        set_compression(command, opts[:compress]) if opts[:compress]
 
         case action
         when 'list', 't'
@@ -58,10 +56,7 @@ module Kanrisuru
           command.append_flag('--unlink-first', opts[:unlink_first])
           command.append_flag('--recursive-unlink', opts[:recursive_unlink])
 
-          if Kanrisuru::Util.present?(paths)
-            paths = paths.instance_of?(String) ? [paths] : paths
-            command << paths.join(' ')
-          end
+          command.append_array(paths)
 
           execute_shell(command)
           Kanrisuru::Result.new(command)
@@ -70,46 +65,31 @@ module Kanrisuru
           command.append_flag('--multi-volume', opts[:multi_volume])
 
           if Kanrisuru::Util.present?(exclude)
-            exclude_options = exclude.instance_of?(String) ? [exclude] : exclude
-            exclude_options.each do |exclude_option|
-              command << "--exclude=#{exclude_option}"
+            options = exclude.instance_of?(String) ? [exclude] : exclude
+            options.each do |option|
+              command << "--exclude=#{option}"
             end
           end
 
-          if Kanrisuru::Util.present?(paths)
-            paths = paths.instance_of?(String) ? [paths] : paths
-            command << paths.join(' ')
-          end
+          command.append_array(paths)
 
           execute_shell(command)
           Kanrisuru::Result.new(command)
         when 'append', 'r'
           command.append_flag('-r')
-
-          if Kanrisuru::Util.present?(paths)
-            paths = paths.instance_of?(String) ? [paths] : paths
-            command << paths.join(' ')
-          end
+          command.append_array(paths)
 
           execute_shell(command)
           Kanrisuru::Result.new(command)
         when 'catenate', 'concat', 'A'
           command.append_flag('-A')
-
-          if Kanrisuru::Util.present?(paths)
-            paths = paths.instance_of?(String) ? [paths] : paths
-            command << paths.join(' ')
-          end
+          command.append_array(paths)
 
           execute_shell(command)
           Kanrisuru::Result.new(command)
         when 'update', 'u'
           command.append_flag('-u')
-
-          if Kanrisuru::Util.present?(paths)
-            paths = paths.instance_of?(String) ? [paths] : paths
-            command << paths.join(' ')
-          end
+          command.append_array(paths)
 
           execute_shell(command)
           Kanrisuru::Result.new(command)
@@ -122,11 +102,7 @@ module Kanrisuru
         when 'delete'
           command.append_flag('--delete')
           command.append_arg('--occurrence', opts[:occurrence])
-
-          if Kanrisuru::Util.present?(paths)
-            paths = paths.instance_of?(String) ? [paths] : paths
-            command << paths.join(' ')
-          end
+          command.append_array(paths)
 
           execute_shell(command)
           Kanrisuru::Result.new(command)

data/lib/kanrisuru/core/disk.rb

@@ -113,9 +113,6 @@ module Kanrisuru
           case mode
           when 'search'
             cmd.to_s
-          when 'device'
-            lines = cmd.to_a
-            blkid_devices(lines)
           else
             lines = cmd.to_a
             blkid_devices(lines)

data/lib/kanrisuru/core/dmi.rb

@@ -511,7 +511,7 @@ module Kanrisuru
         return unless Kanrisuru::Util.present?(opts[:types])
 
         types = opts[:types]
-        types = types.instance_of?(Array) ? types : [types]
+        types = [types] if types.instance_of?(String)
 
         types.each do |type|
           type = parse_dmi_type(type)

data/lib/kanrisuru/core/file.rb

@@ -64,12 +64,9 @@ module Kanrisuru
           command << dest
         elsif opts[:target_directory]
           command.append_arg('-t', dest)
-
-          source = source.instance_of?(String) ? [source] : source
-          command << source.join(' ')
+          command.append_array(source)
         else
-          source = source.instance_of?(String) ? [source] : source
-          command << source.join(' ')
+          command.append_array(source)
           command << dest
         end
 
@@ -108,13 +105,9 @@ module Kanrisuru
           command << dest
         elsif opts[:target_directory]
           command.append_arg('-t', dest)
-
-          source = source.instance_of?(String) ? [source] : source
-          command << source.join(' ')
+          command.append_array(source)
         else
-          source = source.instance_of?(String) ? [source] : source
-
-          command << source.join(' ')
+          command.append_array(source)
           command << dest
         end
 

data/lib/kanrisuru/core/find.rb

@@ -10,7 +10,7 @@ module Kanrisuru
       os_define :linux, :find
 
       FilePath = Struct.new(:path)
-      REGEX_TYPES = ['emacs', 'posix-awk', 'posix-basic', 'posix-egrep', 'posix-extended']
+      REGEX_TYPES = %w[emacs posix-awk posix-basic posix-egrep posix-extended].freeze
 
       def find(opts = {})
         paths      = opts[:paths]
@@ -30,13 +30,9 @@ module Kanrisuru
         end
 
         if Kanrisuru::Util.present?(paths)
-          if paths.instance_of?(Array)
-            paths = paths.join(' ')
-          elsif paths.class != String
-            raise ArgumentError, 'Invalid paths type'
-          end
+          raise ArgumentError, 'Invalid paths type' unless [String, Array].include?(paths.class)
 
-          command << paths
+          command.append_array(paths)
         end
 
         command.append_flag('-executable', opts[:executable])
@@ -66,9 +62,7 @@ module Kanrisuru
         command.append_arg('-mmin', opts[:mmin])
 
         if Kanrisuru::Util.present?(opts[:regex_type])
-          unless REGEX_TYPES.include?(opts[:regex_type])
-            raise ArgumentError, 'invalid regex type'
-          end
+          raise ArgumentError, 'invalid regex type' unless REGEX_TYPES.include?(opts[:regex_type])
 
           command.append_arg('-regextype', opts[:regex_type])
         end
@@ -77,7 +71,8 @@ module Kanrisuru
 
         if size.instance_of?(String)
           regex = Regexp.new(/^([-+])?(\d+)([bcwkMG])*$/)
-          raise ArgumentError, "invalid size string: '#{@size}'" unless regex.match?(size) 
+          raise ArgumentError, "invalid size string: '#{@size}'" unless regex.match?(size)
+
           command.append_arg('-size', size)
         elsif size.instance_of?(Integer)
           command.append_arg('-size', size)

data/lib/kanrisuru/core/mount.rb

@@ -10,9 +10,6 @@ module Kanrisuru
 
       def mount(opts = {})
         type = opts[:type]
-        all  = opts[:all]
-        device = opts[:device]
-        directory = opts[:directory]
 
         bind_old = opts[:bind_old]
         bind_new = opts[:bind_new]
@@ -39,13 +36,12 @@ module Kanrisuru
         else
           command.append_arg('-L', opts[:label])
           command.append_arg('-U', opts[:uuid])
-          command.append_flag('-n', opts[:no_mtab])
           command.append_flag('-f', opts[:fake])
           command.append_flag('-i', opts[:internal_only])
           command.append_flag('-s', opts[:sloppy])
 
           command.append_flag('--no-mtab', opts[:no_mtab])
-          command.append_flag('--no-canonicalizeb', opts[:no_canonicalize])
+          command.append_flag('--no-canonicalize', opts[:no_canonicalize])
 
           fs_options = nil
           if Kanrisuru::Util.present?(type)
@@ -55,14 +51,14 @@ module Kanrisuru
             fs_options = Kanrisuru::Remote::Fstab::Options.new('common', fs_opts)
           end
 
-          if Kanrisuru::Util.present?(all)
+          if Kanrisuru::Util.present?(opts[:all])
             command.append_flag('-a')
             add_test_opts(command, opts[:test_opts], type)
           else
             command.append_arg('-o', fs_options.to_s)
 
-            command << device if Kanrisuru::Util.present?(device)
-            command << directory if Kanrisuru::Util.present?(directory)
+            command << opts[:device] if Kanrisuru::Util.present?(opts[:device])
+            command << opts[:directory] if Kanrisuru::Util.present?(opts[:directory])
           end
         end
 
@@ -75,12 +71,6 @@ module Kanrisuru
         type = opts[:type]
         command = Kanrisuru::Command.new('umount')
 
-        if Kanrisuru::Util.present?(all)
-          command.append_flag('-a')
-          add_type(command, type)
-          add_test_opts(command, opts[:test_opts], type)
-        end
-
         command.append_flag('--fake', opts[:fake])
         command.append_flag('--no-canonicalize', opts[:no_canonicalize])
         command.append_flag('-n', opts[:no_mtab])
@@ -90,6 +80,15 @@ module Kanrisuru
         command.append_flag('-l', opts[:lazy])
         command.append_flag('-f', opts[:force])
 
+        if Kanrisuru::Util.present?(all)
+          command.append_flag('-a')
+          add_type(command, type)
+          add_test_opts(command, opts[:test_opts], type)
+        else
+          command << opts[:device] if Kanrisuru::Util.present?(opts[:device])
+          command << opts[:directory] if Kanrisuru::Util.present?(opts[:directory])
+        end
+
         execute_shell(command)
 
         Kanrisuru::Result.new(command)
@@ -115,7 +114,7 @@ module Kanrisuru
 
         test_types.each do |t|
           device_opts = Kanrisuru::Util::FsMountOpts.get_device(t)
-          raise ArugmentError, "Invalid fstype: #{t}" unless device_opts
+          raise ArgumentError, "Invalid fstype: #{t}" unless device_opts
         end
 
         command.append_arg('-t', type)

data/lib/kanrisuru/core/socket.rb

@@ -59,7 +59,8 @@ module Kanrisuru
         command.append_flag('-w', opts[:raw])
 
         if Kanrisuru::Util.present?(family)
-          raise ArgumentError, 'invalid family type' if !NETWORK_FAMILIES.include?(family)
+          raise ArgumentError, 'invalid family type' unless NETWORK_FAMILIES.include?(family)
+
           command.append_arg('-f', family)
         end
 

data/lib/kanrisuru/core/stream.rb

@@ -95,8 +95,7 @@ module Kanrisuru
         command.append_flag('-b', opts[:number_nonblank])
         command.append_flag('-A', opts[:show_all])
 
-        files = files.instance_of?(String) ? [files] : files
-        command << files.join(' ')
+        command.append_array(files)
 
         append_file(command, opts)
         execute_shell(command)

data/lib/kanrisuru/core/zypper.rb

@@ -181,8 +181,7 @@ module Kanrisuru
         command.append_flag('--metadata', opts[:metadata])
         command.append_flag('--raw-metadata', opts[:raw_metadata])
         command.append_flag('--all', opts[:all])
-
-        command << opts[:repos]
+        command.append_array(opts[:repos])
 
         execute_shell(command)
 
@@ -276,11 +275,7 @@ module Kanrisuru
           command.append_arg('--medium-type', opts[:medium_type])
         end
 
-        repos = opts[:repos]
-        if Kanrisuru::Util.present?(repos)
-          repos = repos.instance_of?(String) ? [repos] : repos
-          command << repos.join(' ')
-        end
+        command.append_array(opts[:repos])
 
         execute_shell(command)
 
@@ -336,11 +331,7 @@ module Kanrisuru
           command.append_arg('--media-type', opts[:media_type])
         end
 
-        repos = opts[:repos]
-        if Kanrisuru::Util.present?(repos)
-          repos = repos.instance_of?(String) ? [repos] : repos
-          command << repos.join(' ')
-        end
+        command.append_array(opts[:repos])
 
         execute_shell(command)
 
@@ -372,11 +363,7 @@ module Kanrisuru
         command.append_flag('--refresh', opts[:refresh])
         command.append_flag('--no-refresh', opts[:no_refresh])
 
-        services = opts[:services]
-        if Kanrisuru::Util.present?(services)
-          services = services.instance_of?(Array) ? services : [services]
-          command << services.join(' ')
-        end
+        command.append_array(opts[:services])
 
         execute_shell(command)
 
@@ -386,15 +373,11 @@ module Kanrisuru
       def zypper_remove_service(opts)
         command = Kanrisuru::Command.new('zypper')
         zypper_global_opts(command, opts)
+
         command << 'removeservice'
         command.append_flag('--loose-auth', opts[:loose_auth])
         command.append_flag('--loose-query', opts[:loose_query])
-
-        services = opts[:services]
-        if Kanrisuru::Util.present?(services)
-          services = services.instance_of?(String) ? [services] : services
-          command << services.join(' ')
-        end
+        command.append_array(opts[:services])
 
         execute_shell(command)
 

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