kanrisuru 0.1.0 → 0.2.1

data/lib/kanrisuru/remote/memory.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Remote
+    class Memory
+      def initialize(host)
+        @host = host
+      end
+
+      method_names = %w[total free swap swap_free]
+      method_names.each do |method_name|
+        define_method(method_name.to_s) do |metric = :kb|
+          value = @host.free(method_name).to_i
+          metric == :kb ? value : Kanrisuru::Util::Bits.convert_from_kb(value, metric)
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/remote/os.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Remote
+    class Os
+      attr_reader :processor, :operating_system, :release, :version
+
+      def initialize(host)
+        Kanrisuru.logger.info('Gathering OS details')
+
+        @host = host
+        @kernel_name = uname(kernel_name: true)
+
+        case @kernel_name
+        when 'Linux'
+          initialize_linux
+        end
+      end
+
+      def kernel
+        @kernel_name
+      end
+
+      def linux?
+        kernel == 'Linux'
+      end
+
+      def uname(opts = {})
+        command = Kanrisuru::Command.new('uname')
+
+        if opts[:all]
+          command.append_flag('-a', opts[:all])
+        else
+          command.append_flag('-s', opts[:kernel_name])
+          command.append_flag('-n', opts[:node_name])
+          command.append_flag('-r', opts[:kernel_release])
+          command.append_flag('-v', opts[:kernel_version])
+          command.append_flag('-m', opts[:machine])
+          command.append_flag('-p', opts[:processor])
+          command.append_flag('-i', opts[:hardware_platform])
+          command.append_flag('-o', opts[:operating_system])
+        end
+
+        @host.execute(command)
+
+        return unless command.success?
+
+        if opts.keys.length > 1 || opts[:all]
+          command.to_a
+        else
+          command.to_s
+        end
+      end
+
+      private
+
+      def initialize_linux
+        @kernel_version   = uname(kernel_version: true)
+        machine           = uname(machine: true)
+        processor         = uname(processor: true)
+        @operating_system  = uname(operating_system: true)
+        @hardware_platform = uname(hardware_platform: true)
+
+        @processor = processor == 'unknown' ? machine : processor
+
+        @release = parse_os_release
+        @version = parse_os_version
+      end
+
+      def parse_os_release
+        command = Kanrisuru::Command.new("cat /etc/os-release | grep '^ID=' | awk -F= '{ print $2}'")
+        result = @host.execute(command)
+        raise 'Invalid os release' if result.failure?
+
+        result.to_s.gsub(/"/, '')
+      end
+
+      def parse_os_version
+        command = Kanrisuru::Command.new("cat /etc/os-release | grep '^VERSION_ID=' | awk -F= '{ print $2}'")
+        result = @host.execute(command)
+        raise 'Invalid os version' if result.failure?
+
+        result.to_s.gsub(/"/, '').to_f
+      end
+    end
+  end
+end

data/lib/kanrisuru/result.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  class Result
+    include Enumerable
+
+    attr_reader :error, :data, :command
+
+    def initialize(command, &block)
+      @command = command
+      @data = nil
+
+      @data = block.call(@command) if @command.success? && block_given?
+      @error = @command.to_a if @command.failure?
+
+      ## Define getter methods on result that maps to
+      ## the same methods of a data struct.
+      return unless @command.success? && Kanrisuru::Util.present?(@data) && @data.class.ancestors.include?(Struct)
+
+      method_names = @data.members
+      self.class.class_eval do
+        method_names.each do |method_name|
+          define_method method_name do
+            @data[method_name]
+          end
+        end
+      end
+    end
+
+    def [](prop)
+      @data[prop]
+    end
+
+    def to_a
+      @data.instance_of?(Array) ? @data : [@data]
+    end
+
+    def to_i
+      if @data.instance_of?(Integer)
+        @data
+      elsif @data.instance_of?(String)
+        @data.to_i
+      elsif @data.instance_of?(Array)
+        @data.map(&:to_i)
+      elsif @data.instance_of?(NilClass)
+        nil
+      else
+        raise NoMethodError, "(undefined method `to_i' for Kanrisuru::Result)"
+      end
+    end
+
+    def inspect
+      if success?
+        format('#<Kanrisuru::Result:0x%<object_id>s @status=%<status>s @data=%<data>s @command=%<command>s>',
+               object_id: object_id, status: status, data: @data.inspect, command: command.prepared_command)
+      else
+        format('#<Kanrisuru::Result:0x%<object_id>s @status=%<status>s @error=%<error>s @command=%<command>s>',
+               object_id: object_id, status: status, error: @error.inspect, command: command.prepared_command)
+      end
+    end
+
+    def failure?
+      @command.failure?
+    end
+
+    def success?
+      @command.success?
+    end
+
+    def status
+      @command.exit_status
+    end
+
+    def each(&block)
+      @data.each { |item| block.call(item) } if @data.instance_of?(Array)
+    end
+  end
+end

data/lib/kanrisuru/template.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Kanrisuru
+  class Template
+    attr_writer :trim_mode
+
+    def initialize(path, args = {})
+      @path = path
+      @trim_mode = '-'
+
+      args.each do |variable_name, value|
+        instance_variable_set("@#{variable_name}", value)
+      end
+    end
+
+    def render
+      erb.result(binding)
+    end
+
+    def read
+      StringIO.new(render)
+    end
+
+    private
+
+    def erb
+      ERB.new(File.read(@path), trim_mode: @trim_mode)
+    end
+  end
+end

data/lib/kanrisuru/util.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'util/bits'
+require_relative 'util/os_family'
+require_relative 'util/fs_mount_opts'
+require_relative 'util/signal'
+
+module Kanrisuru
+  class Util
+    def self.blank?(value)
+      value.respond_to?(:empty?) ? value.empty? : !value
+    end
+
+    def self.present?(value)
+      !Kanrisuru::Util.blank?(value)
+    end
+
+    def self.array_join_string(arg)
+      arg.instance_of?(Array) ? arg.join(',') : arg
+    end
+
+    def self.string_join_array(arg)
+      array = arg.instance_of?(String) ? [arg] : arg
+      array.join(',')
+    end
+
+    def self.numeric?(value)
+      !Float(value).nil?
+    rescue StandardError
+      false
+    end
+
+    def self.camelize(string)
+      string = string.to_s
+      string = string.sub(/^[a-z\d]*/, &:capitalize)
+      string.gsub!(%r{(?:_|(/))([a-z\d]*)}i) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }
+      string
+    end
+  end
+end

data/lib/kanrisuru/util/bits.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  class Util
+    class Bits
+      def self.convert_from_kb(value, metric)
+        convert_bytes(value, :kilobyte, metric)
+      end
+
+      def self.convert_from_mb(value, metric)
+        convert_bytes(value, :megabyte, metric)
+      end
+
+      def self.convert_from_gb(value, metric)
+        convert_bytes(value, :gigabyte, metric)
+      end
+
+      def self.convert_from_tb(value, metric)
+        convert_bytes(value, :terabyte, metric)
+      end
+
+      def self.convert_from_pb(value, metric)
+        convert_bytes(value, :petabyte, metric)
+      end
+
+      def self.convert_bytes(value, from, to)
+        from = from.downcase.to_sym
+        to   = to.downcase.to_sym
+
+        byte_translations = {
+          b: :deca,
+          kb: :kilo,
+          mb: :mega,
+          gb: :giga,
+          tb: :tera,
+          pb: :peta,
+          byte: :deca,
+          kilobyte: :kilo,
+          megabyte: :mega,
+          gigabyte: :giga,
+          terabyte: :tera,
+          petabyte: :peta
+        }
+
+        bit_translations = {
+          kib: :kilo,
+          mib: :mega,
+          gib: :giga,
+          tib: :tera,
+          pib: :peta,
+          bit: :deca,
+          kilobit: :kilo,
+          megabit: :mega,
+          gigabit: :giga,
+          terabit: :tera,
+          petabit: :peta
+        }
+
+        bit_translation_from = false
+        bit_translation_to   = false
+
+        from =
+          if bit_translations.key?(from)
+            bit_translation_from = true
+            bit_translations[from]
+          elsif byte_translations.key?(from)
+            byte_translations[from]
+          else
+            raise ArgumentError, 'Invalid data type'
+          end
+
+        to =
+          if bit_translations.key?(to)
+            bit_translation_to = true
+            bit_translations[to]
+          elsif byte_translations.key?(to)
+            byte_translations[to]
+          else
+            raise ArgumentError, 'Invalid data type'
+          end
+
+        multiplier = if bit_translation_from && !bit_translation_to
+                       (1.to_f / 8).to_f
+                     elsif !bit_translation_from && bit_translation_to
+                       8
+                     else
+                       1
+                     end
+
+        power = convert_power(from, to)
+
+        (value * 1000.pow(power).to_f) * multiplier
+      end
+
+      def self.convert_power(from_metric, to_metric)
+        @conversions ||= {
+          deca: {
+            deca: 0,
+            kilo: -1,
+            mega: -2,
+            giga: -3,
+            tera: -4,
+            peta: -5,
+            exa: -6,
+            zetta: -7,
+            yotta: -8
+          },
+          kilo: {
+            deca: 1,
+            kilo: 0,
+            mega: -1,
+            giga: -2,
+            tera: -3,
+            peta: -4,
+            exa: -5,
+            zetta: -6,
+            yotta: -7
+          },
+          mega: {
+            deca: 2,
+            kilo: 1,
+            mega: 0,
+            giga: -1,
+            tera: -2,
+            peta: -3,
+            exa: -4,
+            zetta: -5,
+            yotta: -6
+          },
+          giga: {
+            deca: 3,
+            kilo: 2,
+            mega: 1,
+            giga: 0,
+            tera: -1,
+            peta: -2,
+            exa: -3,
+            zetta: -4,
+            yotta: -5
+          },
+          tera: {
+            deca: 4,
+            kilo: 3,
+            mega: 2,
+            giga: 1,
+            tera: 0,
+            peta: -1,
+            exa: -2,
+            zetta: -3,
+            yotta: -4
+          },
+          peta: {
+            deca: 5,
+            kilo: 4,
+            mega: 3,
+            giga: 2,
+            tera: 1,
+            peta: 0,
+            exa: -1,
+            zetta: -2,
+            yotta: -3
+          },
+          exa: {
+            deca: 6,
+            kilo: 5,
+            mega: 4,
+            giga: 3,
+            tera: 2,
+            peta: 1,
+            exa: 0,
+            zetta: -1,
+            yotta: -2
+          },
+          zetta: {
+            deca: 7,
+            kilo: 6,
+            mega: 5,
+            giga: 4,
+            tera: 3,
+            peta: 2,
+            exa: 1,
+            zetta: 0,
+            yotta: -1
+          },
+          yotta: {
+            deca: 8,
+            kilo: 7,
+            mega: 6,
+            giga: 5,
+            tera: 4,
+            peta: 3,
+            exa: 2,
+            zetta: 1,
+            yotta: 0
+          }
+        }
+
+        values = @conversions[from_metric]
+        values ? values[to_metric] : nil
+      end
+    end
+  end
+end