kanrisuru 0.1.0 → 0.2.1

data/lib/kanrisuru/os_package.rb

@@ -0,0 +1,235 @@
+# 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)
+        base.instance_variable_set(:@os_method_cache, {})
+      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.
+          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
+
+          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
+          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)
+              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.
+          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)
+
+          class_eval do
+            define_method namespace do
+              namespace_instance.instance_variable_set(:@host, self)
+              namespace_instance
+            end
+          end
+        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
+
+                  if os_method_cache.key?(method_name)
+                    unbound_method = os_method_cache[method_name]
+                  else
+                    host = namespace_instance.instance_variable_get(:@host)
+
+                    ## 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[method_name] = unbound_method
+                  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
+
+                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
+
+                  ## 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
+                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/remote.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'remote/host'
+require_relative 'remote/cluster'
+require_relative 'remote/os'
+require_relative 'remote/env'
+require_relative 'remote/memory'
+require_relative 'remote/cpu'
+require_relative 'remote/file'
+require_relative 'remote/fstab'

data/lib/kanrisuru/remote/cluster.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Remote
+    class Cluster
+      extend OsPackage::Collection
+      include Enumerable
+
+      def initialize(hosts)
+        @hosts = {}
+        hosts.each do |host_opts|
+          add_host(host_opts)
+        end
+      end
+
+      def [](hostname)
+        @hosts[hostname]
+      end
+
+      def <<(host_opts)
+        add_host(host_opts)
+      end
+
+      def execute(command)
+        @hosts.map do |host_addr, host|
+          ## Need to evaluate each host independently for the command.
+          cmd = Kanrisuru::Command.new(command)
+
+          { host: host_addr, result: host.execute(cmd) }
+        end
+      end
+
+      def execute_shell(command)
+        @hosts.map do |host_addr, host|
+          ## Need to evaluate each host independently for the command.
+          cmd = Kanrisuru::Command.new(command)
+
+          { host: host_addr, result: host.execute_shell(cmd) }
+        end
+      end
+
+      def each(&block)
+        @hosts.each { |_host_addr, host| block.call(host) }
+      end
+
+      def hostname
+        map_host_results(:hostname)
+      end
+
+      def ping?
+        map_host_results(:ping?)
+      end
+
+      def su(user)
+        @hosts.each do |_host_addr, host|
+          host.su(user)
+        end
+      end
+
+      def chdir(path = '~')
+        cd(path)
+      end
+
+      def cd(path = '~')
+        @hosts.each do |_host_addr, host|
+          host.cd(path)
+        end
+      end
+
+      def disconnect
+        @hosts.each do |_host_addr, host|
+          host.disconnect
+        end
+      end
+
+      private
+
+      def map_host_results(action)
+        @hosts.map do |host_addr, host|
+          { host: host_addr, result: host.send(action) }
+        end
+      end
+
+      def add_host(host_opts)
+        if host_opts.instance_of?(Hash)
+          @hosts[host_opts[:host]] = Kanrisuru::Remote::Host.new(host_opts)
+        elsif host_opts.instance_of?(Kanrisuru::Remote::Host)
+          @hosts[host_opts.host] = host_opts
+        else
+          raise 'Not a valid host option'
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/remote/cpu.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Remote
+    class Cpu
+      def initialize(host)
+        @host = host
+
+        raise 'Not implemented' unless @host.os && @host.os.kernel == 'Linux'
+
+        initialize_linux
+      end
+
+      def load_average
+        @host.load_average.to_a
+      end
+
+      def load_average1
+        load_average[0]
+      end
+
+      def load_average5
+        load_average[1]
+      end
+
+      def load_average15
+        load_average[2]
+      end
+
+      def sockets
+        @sockets_count
+      end
+
+      def cores
+        @logical_cores_count
+      end
+
+      def total
+        @logical_cores_count
+      end
+
+      def count
+        @logical_cores_count
+      end
+
+      def threads_per_core
+        @threads_per_core_count
+      end
+
+      def cores_per_socket
+        @cores_per_socket_count
+      end
+
+      def hyperthreading?
+        threads_per_core > 1
+      end
+
+      private
+
+      def initialize_linux
+        @sockets_count          = @host.cpu_info('sockets').to_i
+        @cores_per_socket_count = @host.cpu_info('cores_per_socket').to_i
+        @threads_per_core_count = @host.cpu_info('threads').to_i
+        @logical_cores_count    = @host.cpu_info('cores').to_i
+      end
+    end
+  end
+end

data/lib/kanrisuru/remote/env.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Remote
+    class Env
+      def initialize
+        @env = {}
+      end
+
+      def to_h
+        @env
+      end
+
+      def to_s
+        string = ''
+        @env.each.with_index do |(key, value), index|
+          string += "export #{key}=#{value};"
+          string += ' ' if index < @env.length - 1
+        end
+
+        string
+      end
+
+      def [](key)
+        @env[key.to_s.upcase]
+      end
+
+      def []=(key, value)
+        @env[key.to_s.upcase] = value
+      end
+    end
+  end
+end

data/lib/kanrisuru/remote/file.rb

@@ -0,0 +1,354 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Kanrisuru
+  module Remote
+    class File
+      include Enumerable
+
+      WRITE_LINE_COUNT = 5_000
+      READ_FILE_SIZE = 3_000_000
+
+      attr_reader :mode, :blocks, :size, :type, :gid, :group, :uid, :user, :inode, :last_access, :last_modified,
+                  :last_changed, :lines, :words, :chars, :path
+
+      def initialize(path, host, backup = nil)
+        @path = path
+        @host = host
+        @backup = backup
+
+        @file_lines = []
+
+        reload! if exists?
+      end
+
+      def expand_path
+        return '' unless exists?
+
+        result = @host.realpath(@path)
+        result.success? ?	result.path : ''
+      end
+
+      def exists?
+        @host.inode?(@path)
+      end
+
+      def file?
+        @host.file?(@path)
+      end
+
+      def [](index)
+        if chunk_read_file? && index < @lines
+          chunk_read_line_by_index(index)
+        elsif index < @lines
+          @file_lines[index]
+        else
+          raise ArgumentError, "Out of bounds index access for #{index}"
+        end
+      end
+
+      def dir?
+        @host.dir?(@path)
+      end
+
+      def zero?
+        @host.empty_file?(@path)
+      end
+
+      def chmod(mode)
+        result = @host.chmod(@path, mode)
+        update_file_attributes(result) if result.success?
+      end
+
+      def chown(owner, group)
+        result = @host.chown(@path, owner: owner, group: group)
+        update_file_attributes(result) if result.success?
+      end
+
+      def writeable?
+        return @writeable if [true, false].include?(@writeable)
+
+        if !file? && !zero?
+          @writeable = false
+          return false
+        end
+
+        current_user = @host.remote_user
+        result = @host.get_user(current_user)
+
+        raise 'Invalid result' unless result.success?
+
+        groups = result.groups.map(&:name)
+
+        @writeable = @mode.other.write? ||
+                     (@mode.group.write? && groups.include?(@group)) ||
+                     (@mode.owner.write? && @user == current_user)
+      end
+
+      def find_and_replace_value(regex, value)
+        new_lines = []
+
+        each do |existing_line|
+          new_lines << if regex.match(existing_line)
+                         existing_line.gsub(regex, value)
+                       else
+                         existing_line
+                       end
+        end
+
+        write_lines_to_file(new_lines, 'write')
+      end
+
+      def find_and_replace_line(regex, new_line)
+        new_lines = []
+
+        each do |existing_line|
+          new_lines << if regex.match(existing_line)
+                         new_line
+                       else
+                         existing_line
+                       end
+        end
+
+        write_lines_to_file(new_lines, 'write')
+      end
+
+      def find_and_append(regex, new_line)
+        new_lines = []
+
+        each do |existing_line|
+          new_lines << existing_line
+          new_lines << new_line if regex.match(existing_line)
+        end
+
+        write_lines_to_file(new_lines, 'write')
+      end
+
+      def find_and_prepend(regex, new_line)
+        new_lines = []
+
+        each do |existing_line|
+          new_lines << new_line if regex.match(existing_line)
+          new_lines << existing_line
+        end
+
+        write_lines_to_file(new_lines, 'write')
+      end
+
+      def find_and_remove(regex)
+        new_lines = []
+
+        each do |existing_line|
+          new_lines << existing_line unless regex.match(existing_line)
+        end
+
+        write_lines_to_file(new_lines, 'write')
+      end
+
+      def write(&block)
+        return unless writeable?
+
+        new_lines = []
+        block.call(new_lines)
+
+        backup_file if should_backup?
+        write_lines_to_file(new_lines, 'write')
+      end
+
+      def append(&block)
+        return unless writeable?
+
+        new_lines = []
+        block.call(new_lines)
+
+        backup_file if should_backup?
+        write_lines_to_file(new_lines, 'append')
+      end
+
+      def prepend(&block)
+        return unless writeable?
+
+        new_lines = []
+        block.call(new_lines)
+
+        backup_file if should_backup?
+
+        ## If large file, use tmp file to prepend to
+        if chunk_read_file?
+          tmp_file = "/tmp/kanrisuru-tempfile-#{Time.now.strftime('%Y-%m-%d-%H-%M-%S-%L')}"
+
+          @host.echo(new_lines.join('\\n'), new_file: tmp_file, backslash: true, mode: 'write')
+          @host.cat(@path, new_file: tmp_file, mode: 'append')
+          @host.cp(tmp_file, @path)
+
+          @host.rm(tmp_file)
+          reload!
+        else
+          all_lines = new_lines + @file_lines
+          write_lines_to_file(all_lines, 'write')
+        end
+      end
+
+      def rename(new_path)
+        # @host.mv()
+      end
+
+      def touch
+        result = @host.touch(@path)
+        update_file_attributes(result[0]) if result.success?
+      end
+
+      def delete
+        result = @host.unlink(@path)
+
+        init_file_attirbutes if result.success?
+
+        result.success?
+      end
+
+      def each(&block)
+        if chunk_read_file?
+          each_chunk(&block)
+        else
+          @file_lines.each { |line| block.call(line) }
+        end
+      end
+
+      def reload!
+        @writeable = nil
+        @file_lines = []
+
+        wc_file
+        stat_file
+        read
+      end
+
+      private
+
+      def should_backup?
+        Kanrisuru::Util.present?(@backup)
+      end
+
+      def backup_file
+        result = @host.cp(@path, @backup)
+        raise "Backup of #{@path} failed" if result.failure?
+      end
+
+      def each_chunk(&block)
+        chunk_size = @lines >> 1
+        index = 1
+
+        loop do
+          result = @host.read_file_chunk(@path, index, index + chunk_size - 1)
+          break if result.failure?
+
+          lines = result.data
+          lines.each { |line| block.call(line) }
+
+          break if index >= @lines
+
+          index += chunk_size
+        end
+      end
+
+      def read
+        return if chunk_read_file?
+
+        result = @host.cat(@path)
+        raise 'Error reading remote file' if result.failure?
+
+        @file_lines = result.data
+      end
+
+      def write_lines_to_file(lines, mode)
+        if lines.length < WRITE_LINE_COUNT
+          write_to_file(lines, mode)
+        else
+          chunk_write_to_file(lines, mode)
+        end
+      end
+
+      def write_to_file(lines, mode)
+        result = @host.echo(lines.join('\\n'), new_file: @path, backslash: true, mode: mode)
+
+        reload! if result.success?
+      end
+
+      def chunk_write_to_file(lines, mode)
+        ## Clear initial file to write new data
+        if mode == 'write'
+          @host.unlink(@path)
+          @host.touch(@path)
+        end
+
+        lines.each_slice(WRITE_LINE_COUNT) do |lines_slice|
+          result = @host.echo(lines_slice.join('\\n'), new_file: @path, backslash: true, mode: 'append')
+          raise 'Error appending lines to file' if result.failure?
+        end
+
+        reload!
+      end
+
+      def chunk_read_file?
+        @size >= READ_FILE_SIZE
+      end
+
+      def chunk_read_line_by_index(index)
+        result = @host.read_file_chunk(@path, index + 1, index + 1)
+        result.success? ? result[0] : nil
+      end
+
+      def wc_file
+        result = @host.wc(@path)
+
+        return if result.failure?
+
+        @lines = result.lines
+        @words = result.words
+        @chars = result.characters
+      end
+
+      def stat_file
+        result = @host.stat(@path)
+
+        update_file_attributes(result) if result.success?
+      end
+
+      def update_file_attributes(result)
+        @mode = result.mode
+        @blocks = result.blocks
+        @size = result.fsize
+        @type = result.file_type
+        @gid = result.gid
+        @group = result.group
+        @uid = result.uid
+        @user = result.user
+        @inode = result.inode
+        @last_access = result.last_access
+        @last_modified = result.last_modified
+        @last_changed = result.last_changed
+      end
+
+      def init_file_attirbutes
+        @writeable = nil
+        @mode = nil
+        @blocks = nil
+        @size = nil
+        @type = nil
+        @gid = nil
+        @group = nil
+        @uid = nil
+        @user = nil
+        @inode = nil
+        @last_access = nil
+        @last_modified = nil
+        @last_changed = nil
+
+        @lines = nil
+        @words = nil
+        @chars = nil
+      end
+    end
+  end
+end