kanrisuru 0.1.0 → 0.2.1

data/lib/kanrisuru/core/mount.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module Mount
+      extend OsPackage::Define
+
+      os_define :linux, :mount
+      os_define :linux, :umount
+
+      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]
+        rbind_old = opts[:rbind_old]
+        rbind_new = opts[:rbind_new]
+        move_old = opts[:move_old]
+        move_new = opts[:move_new]
+        fs_opts   = opts[:fs_opts]
+
+        command = Kanrisuru::Command.new('mount')
+
+        if Kanrisuru::Util.present?(bind_old) && Kanrisuru::Util.present?(bind_new)
+          command.append_flag('--bind')
+          command << bind_old
+          command << bind_new
+        elsif Kanrisuru::Util.present?(rbind_old) && Kanrisuru::Util.present?(rbind_new)
+          command.append_flag('--rbind')
+          command << rbind_old
+          command << rbind_new
+        elsif Kanrisuru::Util.present?(move_old) && Kanrisuru::Util.present?(move_new)
+          command.append_flag('--move')
+          command << move_old
+          command << move_new
+        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])
+
+          fs_options = nil
+          if Kanrisuru::Util.present?(type)
+            add_type(command, type)
+            fs_options = Kanrisuru::Remote::Fstab::Options.new(type, fs_opts) if fs_opts
+          elsif fs_opts
+            fs_options = Kanrisuru::Remote::Fstab::Options.new('common', fs_opts)
+          end
+
+          if Kanrisuru::Util.present?(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)
+          end
+        end
+
+        execute_shell(command)
+        Kanrisuru::Result.new(command)
+      end
+
+      def umount(opts = {})
+        all = opts[:all]
+        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])
+        command.append_flag('-r', opts[:fail_remount_readonly])
+        command.append_flag('-d', opts[:free_loopback])
+
+        command.append_flag('-l', opts[:lazy])
+        command.append_flag('-f', opts[:force])
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command)
+      end
+
+      private
+
+      def add_type(command, type)
+        return unless Kanrisuru::Util.present?(type)
+
+        test_types = nil
+
+        if type.include?(',')
+          if type.include?('no')
+            test_types = type.gsub('no', '')
+            test_types = test_types.split(',')
+          else
+            test_types = type.split(',')
+          end
+        else
+          test_types = [type]
+        end
+
+        test_types.each do |t|
+          device_opts = Kanrisuru::Util::FsMountOpts.get_device(t)
+          raise ArugmentError, "Invalid fstype: #{t}" unless device_opts
+        end
+
+        command.append_arg('-t', type)
+      end
+
+      def add_test_opts(command, test_opts, type)
+        return unless Kanrisuru::Util.present?(test_opts)
+
+        test_options =
+          if Kanrisuru::Util.present?(type)
+            Kanrisuru::Remote::Fstab::Options.new(type, test_opts)
+          else
+            Kanrisuru::Remote::Fstab::Options.new('common', test_opts)
+          end
+
+        command.append_arg('-O', test_options.to_s)
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/path.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Kanrisuru
+  module Core
+    module Path
+      extend OsPackage::Define
+
+      os_define :linux, :ls
+      os_define :linux, :pwd
+      os_define :linux, :whoami
+      os_define :linux, :which
+      os_define :linux, :realpath
+      os_define :linux, :readlink
+
+      FilePath = Struct.new(:path)
+      FileInfoId = Struct.new(:inode, :mode, :memory_blocks, :uid, :gid, :fsize, :date, :path, :type)
+      FileInfo = Struct.new(:inode, :mode, :memory_blocks, :owner, :group, :fsize, :date, :path, :type)
+      UserName = Struct.new(:user)
+
+      def ls(opts = {})
+        path = opts[:path]
+        all  = opts[:all]
+        id   = opts[:id]
+
+        command = Kanrisuru::Command.new('ls')
+        command.append_flag('-i')
+        command.append_flag('-l')
+        command.append_flag('-a', all)
+        command.append_flag('-n', id)
+
+        command << (path || pwd.path)
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          items = []
+          rows = cmd.to_a
+
+          rows.each.with_index do |row, index|
+            next if index.zero?
+
+            values = row.split
+            date = DateTime.parse("#{values[6]} #{values[7]} #{values[8]}")
+
+            type = values[1].include?('d') ? 'directory' : 'file'
+
+            items <<
+              if id
+                FileInfoId.new(
+                  values[0].to_i,
+                  Kanrisuru::Mode.new(values[1]),
+                  values[2].to_i,
+                  values[3].to_i,
+                  values[4].to_i,
+                  values[5].to_i,
+                  date,
+                  values[9],
+                  type
+                )
+              else
+                FileInfo.new(
+                  values[0].to_i,
+                  Kanrisuru::Mode.new(values[1]),
+                  values[2].to_i,
+                  values[3],
+                  values[4],
+                  values[5].to_i,
+                  date,
+                  values[9],
+                  type
+                )
+              end
+          end
+
+          items
+        end
+      end
+
+      def whoami
+        command = Kanrisuru::Command.new('whoami')
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          UserName.new(cmd.to_s)
+        end
+      end
+
+      def pwd
+        command = Kanrisuru::Command.new('pwd')
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          FilePath.new(cmd.to_s)
+        end
+      end
+
+      def which(program, opts = {})
+        command = Kanrisuru::Command.new('which')
+        command.append_flag('-a', opts[:all])
+        command << program
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          rows = cmd.to_a
+          rows.map do |row|
+            FilePath.new(row)
+          end
+        end
+      end
+
+      def realpath(path, opts = {})
+        command = Kanrisuru::Command.new("realpath #{path}")
+        command.append_flag('-s', opts[:strip])
+
+        execute(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          FilePath.new(cmd.to_s)
+        end
+      end
+
+      def readlink(path, opts = {})
+        command = Kanrisuru::Command.new('readlink')
+        command.append_flag('-f', opts[:canonicalize])
+        command.append_flag('-e', opts[:canonicalize_existing])
+        command.append_flag('-m', opts[:canonicalize_missing])
+
+        command << path
+
+        execute(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          FilePath.new(cmd.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/socket.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+module Kanrisuru
+  module Core
+    module Socket
+      extend OsPackage::Define
+
+      os_define :linux, :ss
+
+      SocketStatistics = Struct.new(
+        :netid, :state, :receive_queue, :send_queue,
+        :local_address, :local_port, :peer_address, :peer_port,
+        :memory
+      )
+
+      SocketStatisticsMemory = Struct.new(
+        :rmem_alloc, :rcv_buf, :wmem_alloc, :snd_buf,
+        :fwd_alloc, :wmem_queued, :ropt_mem, :back_log, :sock_drop
+      )
+
+      TCP_STATES = %w[
+        established syn-sent syn-recv
+        fin-wait-1 fin-wait-2 time-wait
+        closed close-wait last-ack listening closing
+      ].freeze
+
+      OTHER_STATES = %w[
+        all connected synchronized bucket syn-recv
+        big
+      ].freeze
+
+      TCP_STATE_ABBR = {
+        'ESTAB' => 'established', 'LISTEN' => 'listening', 'UNCONN' => 'unconnected',
+        'SYN-SENT' => 'syn-sent', 'SYN-RECV' => 'syn-recv', 'FIN-WAIT-1' => 'fin-wait-1',
+        'FIN-WAIT-2' => 'fin-wait-2', 'TIME-WAIT' => 'time-wait', 'CLOSE-WAIT' => 'close-wait',
+        'LAST-ACK' => 'last-ack', 'CLOSING' => 'closing'
+      }.freeze
+
+      def ss(opts = {})
+        state = opts[:state]
+        expression = opts[:expression]
+
+        command = Kanrisuru::Command.new('ss')
+
+        command.append_flag('-a')
+        command.append_flag('-m')
+
+        command.append_flag('-n', opts[:numeric])
+        command.append_flag('-t', opts[:tcp])
+        command.append_flag('-u', opts[:udp])
+        command.append_flag('-x', opts[:unix])
+        command.append_flag('-w', opts[:raw])
+
+        command.append_arg('-f', opts[:family])
+
+        if Kanrisuru::Util.present?(state)
+          raise ArgumentError, 'invalid filter state' if !TCP_STATES.include?(state) && !OTHER_STATES.include?(state)
+
+          command.append_arg('state', state)
+        end
+
+        command << expression if Kanrisuru::Util.present?(expression)
+
+        execute_shell(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          rows = []
+
+          ## New lines with tabs are from text overflow
+          ## on on stdout of SS command.
+          ## Replace the newline and tab chars with a space.
+          string = cmd.raw_result.join
+          string = string.gsub("\n\t", "\s")
+          lines = string.lines.map(&:strip)
+
+          headers = lines.shift
+
+          lines.each do |line|
+            values = line.split
+            next if values.length < 5
+
+            socket_stats = SocketStatistics.new
+
+            socket_stats.netid = if headers.include?('Netid')
+                                   values.shift
+                                 elsif opts[:tcp]
+                                   'tcp'
+                                 elsif opts[:udp]
+                                   'udp'
+                                 elsif opts[:raw]
+                                   'raw'
+                                 else
+                                   ''
+                                 end
+
+            socket_stats.state = if headers.include?('State')
+                                   TCP_STATE_ABBR[values.shift]
+                                 else
+                                   state
+                                 end
+
+            socket_stats.receive_queue = values.shift.to_i
+            socket_stats.send_queue = values.shift.to_i
+
+            address, port = parse_address_port(values)
+            socket_stats.local_address = address
+            socket_stats.local_port = port
+
+            address, port = parse_address_port(values)
+            socket_stats.peer_address = address
+            socket_stats.peer_port = port
+
+            socket_stats.memory = parse_memory(values.shift)
+
+            rows << socket_stats
+          end
+
+          rows
+        end
+      end
+
+      private
+
+      def parse_memory(string)
+        return if Kanrisuru::Util.blank?(string) ||
+                  Regexp.new(/skmem:\((\S+)\)/).match(string).nil?
+
+        _, string = string.split(/skmem:\((\S+)\)/)
+        values = string.split(',')
+
+        memory = SocketStatisticsMemory.new
+        memory.rmem_alloc  = values[0].split(/(\d+)/)[1].to_i
+        memory.rcv_buf     = values[1].split(/(\d+)/)[1].to_i
+        memory.wmem_alloc  = values[2].split(/(\d+)/)[1].to_i
+        memory.snd_buf     = values[3].split(/(\d+)/)[1].to_i
+        memory.fwd_alloc   = values[4].split(/(\d+)/)[1].to_i
+        memory.wmem_queued = values[5].split(/(\d+)/)[1].to_i
+        memory.ropt_mem    = values[6].split(/(\d+)/)[1].to_i
+        memory.back_log    = values[7].split(/(\d+)/)[1].to_i
+        memory.sock_drop   = values[8].split(/(\d+)/)[1].to_i
+
+        memory
+      end
+
+      def parse_address_port(values)
+        address = values.shift
+        port = nil
+
+        if address == '*' && Regexp.new(/skmem:\((\S+)\)/).match(values[0])
+          port = '*'
+        elsif Regexp.new(/\[(\S+)\]/).match(address)
+          tokens = address.split(/\[(\S+)\]/)
+          address = "[#{tokens[1]}]"
+          _, port = tokens[2].split(/:(\S+)/)
+        elsif Regexp.new(/:\S+/).match(address)
+          address, port = address.split(/:(\S+)/)
+        else
+          port = values.shift
+        end
+
+        port = Kanrisuru::Util.numeric?(port) ? port.to_i : port
+        [address, port]
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/stat.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Kanrisuru
+  module Core
+    module Stat
+      extend OsPackage::Define
+
+      os_define :linux, :dir?
+      os_define :linux, :file?
+      os_define :linux, :block_device?
+      os_define :linux, :char_device?
+      os_define :linux, :symlink?
+      os_define :linux, :file_type?
+      os_define :linux, :inode?
+      os_define :linux, :stat
+
+      FileStat = Struct.new(
+        :mode, :blocks, :device, :file_type,
+        :gid, :group, :links, :inode,
+        :path, :fsize, :uid, :user,
+        :last_access, :last_modified, :last_changed
+      )
+
+      def dir?(path)
+        file_type?(path, 'directory')
+      end
+
+      def file?(path)
+        file_type?(path, 'regular file')
+      end
+
+      def empty_file?(path)
+        file_type?(path, 'regular empty file')
+      end
+
+      def block_device?(path)
+        file_type?(path, 'block special file')
+      end
+
+      def char_device?(path)
+        file_type?(path, 'character special file')
+      end
+
+      def symlink?(path)
+        file_type?(path, 'symbolic link')
+      end
+
+      def inode?(path)
+        command = Kanrisuru::Command.new("stat #{path}")
+        command.append_arg('-c', '%i')
+
+        execute_shell(command)
+        command.success?
+      end
+
+      def file_type?(path, type)
+        command = Kanrisuru::Command.new("stat #{path}")
+        command.append_arg('-c', '%F')
+
+        execute(command)
+
+        result = Kanrisuru::Result.new(command, &:to_s)
+
+        result.success? ? result.data == type : false
+      end
+
+      def stat(path, opts = {})
+        follow = opts[:follow]
+
+        command = Kanrisuru::Command.new('stat')
+        command.append_flag('-L', follow)
+        command.append_arg('-c', '%A,%b,%D,%F,%g,%G,%h,%i,%n,%s,%u,%U,%x,%y,%z')
+        command << path
+
+        execute(command)
+
+        Kanrisuru::Result.new(command) do |cmd|
+          string = cmd.to_s
+          values = string.split(',')
+
+          FileStat.new(
+            Kanrisuru::Mode.new(values[0]),
+            values[1].to_i,
+            values[2],
+            values[3],
+            values[4].to_i,
+            values[5],
+            values[6].to_i,
+            values[7].to_i,
+            values[8],
+            values[9].to_i,
+            values[10].to_i,
+            values[11],
+            values[12] ? DateTime.parse(values[12]) : nil,
+            values[13] ? DateTime.parse(values[13]) : nil,
+            values[14] ? DateTime.parse(values[14]) : nil
+          )
+        end
+      end
+    end
+  end
+end