kanrisuru 0.11.1 → 0.14.0

data/lib/kanrisuru/core/system/parsers/kernel_statistics.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module System
+      module Parser
+        class KernelStatistics
+          def self.parse(command)
+            lines = command.to_a
+
+            result = Kanrisuru::Core::System::KernelStatistic.new
+            result.cpus = []
+
+            lines.each do |line|
+              values = line.split
+              field = values[0]
+              values = values[1..-1].map(&:to_i)
+
+              case field
+              when /^cpu/
+                cpu_stat = Kanrisuru::Core::System::KernelStatisticCpu.new
+                cpu_stat.user = values[0]
+                cpu_stat.nice = values[1]
+                cpu_stat.system = values[2]
+                cpu_stat.idle = values[3]
+                cpu_stat.iowait = values[4]
+                cpu_stat.irq = values[5]
+                cpu_stat.softirq = values[6]
+                cpu_stat.steal = values[7]
+                cpu_stat.guest = values[8]
+                cpu_stat.guest_nice = values[9]
+
+                case field
+                when /^cpu$/
+                  result.cpu_total = cpu_stat
+                when /^cpu\d+/
+                  result.cpus << cpu_stat
+                end
+              when 'intr'
+                result.interrupt_total = values[0]
+                result.interrupts = values[1..-1]
+              when 'softirq'
+                result.softirq_total = values[0]
+                result.softirqs = values[1..-1]
+              else
+                result[field] = values[0]
+              end
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/system/parsers/last.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module System
+      module Parser
+        class Last
+          class << self
+            def parse(command, opts)
+              lines = command.to_a
+
+              mapping = {}
+
+              lines.each do |line|
+                next if Kanrisuru::Util.blank?(line)
+                next if line.include?('wtmp') || line.include?('btmp')
+
+                line = line.gsub('  still logged in', '- still logged in') if line.include?('still logged in')
+
+                values = line.split(/\s{2,}/, 4)
+                user   = values[0]
+                tty    = values[1]
+                ip     = IPAddr.new(values[2])
+
+                date_range = values[3]
+                login, logout = date_range.split(' - ')
+
+                login = parse_last_date(login) if login
+                logout = parse_last_date(logout) if logout
+
+                detail = Kanrisuru::Core::System::SessionDetail.new
+                detail.tty = tty
+                detail.ip_address = ip
+                detail.login_at = login
+                detail.logout_at = logout
+
+                detail.success = !Kanrisuru::Util.present?(opts[:failed_attemps])
+
+                mapping[user] = Kanrisuru::Core::System::LoginUser.new(user, []) unless mapping.key?(user)
+
+                mapping[user].sessions << detail
+              end
+
+              mapping.values
+            end
+
+            def parse_last_date(string)
+              tokens = string.split
+
+              return if tokens.length < 4
+
+              month_abbr = tokens[1]
+              day = tokens[2]
+              timestamp = tokens[3]
+              year = tokens[4]
+
+              DateTime.parse("#{day} #{month_abbr} #{year} #{timestamp}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/system/parsers/load_average.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module System
+      module Parser
+        class LoadAverage
+          def self.parse(command)
+            command.to_s.split.map(&:to_f)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/system/parsers/load_env.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module System
+      module Parser
+        class LoadEnv
+          def self.parse(command)
+            string = command.to_s
+            hash = {}
+
+            rows = string.split("\n")
+            rows.each do |row|
+              key, value = row.split('=', 2)
+              hash[key] = value
+            end
+
+            hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/system/parsers/lscpu.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module System
+      module Parser
+        class Lscpu
+          def self.parse(command)
+            lines = command.to_a
+
+            result = Kanrisuru::Core::System::CPUArchitecture.new
+            result.vulnerabilities = []
+            result.numa_nodes = []
+
+            lines.each do |line|
+              values = line.split(': ', 2)
+
+              field = values[0].strip
+              data = values[1].strip
+
+              case field
+              when 'Architecture'
+                result.architecture = data
+              when 'CPU op-mode(s)'
+                result.operation_modes = data.split(', ')
+              when 'Byte Order'
+                result.byte_order = data
+              when 'Address sizes'
+                result.address_sizes = data.split(', ')
+              when 'CPU(s)'
+                result.cores = data.to_i
+              when 'On-line CPU(s) list'
+                result.online_cpus = data.to_i
+              when 'Thread(s) per core'
+                result.threads_per_core = data.to_i
+              when 'Core(s) per socket'
+                result.cores_per_socket = data.to_i
+              when 'Socket(s)'
+                result.sockets = data.to_i
+              when 'NUMA node(s)'
+                result.numa_nodes = data.to_i
+              when 'Vendor ID'
+                result.vendor_id = data
+              when 'CPU family'
+                result.cpu_family = data.to_i
+              when 'Model'
+                result.model = data.to_i
+              when 'Model name'
+                result.model_name = data
+              when 'Stepping'
+                result.stepping = data.to_i
+              when 'CPU MHz'
+                result.cpu_mhz = data.to_f
+              when 'CPU max MHz'
+                result.cpu_max_mhz = data.to_f
+              when 'CPU min MHz'
+                result.cpu_min_mhz = data.to_f
+              when 'CPUBogoMIPS'
+                result.bogo_mips = data.to_f
+              when 'Virtualization'
+                result.virtualization = data
+              when 'Hypervisor vendor'
+                result.hypervisor_vendor = data
+              when 'Virtualization type'
+                result.virtualization_type = data
+              when 'L1d cache'
+                result.l1d_cache = data
+              when 'L1i cache'
+                result.l1i_cache = data
+              when 'L2 cache'
+                result.l2_cache = data
+              when 'L3 cache'
+                result.l3_cache = data
+              when /^Numa node/
+                result.numa_nodes << data.split(',')
+              when /^Vulnerability/
+                name = field.split('Vulnerability ')[1]
+                result.vulnerabilities << Kanrisuru::Core::System::CPUArchitectureVulnerability.new(name, data)
+              when 'Flags'
+                result.flags = data.split
+              end
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/system/parsers/lsof.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module System
+      module Parser
+        class Lsof
+          class << self
+            def parse(command)
+              lines = command.to_a
+
+              current_row = nil
+              current_pid = nil
+              current_user = nil
+              current_command = nil
+
+              rows = []
+
+              lines.each do |line|
+                case line
+                when /^p/
+                  current_pid = parse_lsof(line, 'p').to_i
+                when /^c/
+                  current_command = parse_lsof(line, 'c')
+                when /^u/
+                  current_user = parse_lsof(line, 'u').to_i
+                when /^f/
+                  rows << current_row if current_row
+
+                  current_row = Kanrisuru::Core::System::OpenFile.new
+                  current_row.pid = current_pid
+                  current_row.command = current_command
+                  current_row.uid = current_user
+
+                  current_row.file_descriptor = parse_lsof(line, 'f')
+                when /^t/
+                  current_row.type = parse_lsof(line, 't')
+                when /^D/
+                  current_row.device = parse_lsof(line, 'D')
+                when /^s/
+                  current_row.fsize = parse_lsof(line, 's').to_i
+                when /^i/
+                  current_row.inode = parse_lsof(line, 'i').to_i
+                when /^n/
+                  current_row.name = parse_lsof(line, 'n')
+                end
+              end
+
+              rows << current_row if current_row
+
+              rows
+            end
+
+            def parse_lsof(line, char)
+              line.split(char, 2)[1]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/system/parsers/ps.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module System
+      module Parser
+        class Ps
+          class << self
+            def parse(command)
+              ## Have found issues with regular newline parsing from command
+              ## most likely a buffer overflow from SSH buffer.
+              ## Join string then split by newline.
+              result_string = command.raw_result.join
+              rows = result_string.split("\n")
+
+              build_process_list(rows)
+            end
+
+            def build_process_list(rows)
+              rows.map do |row|
+                values = *row.split(/\s+/, 15)
+                values.shift if values[0] == ''
+
+                Kanrisuru::Core::System::ProcessInfo.new(
+                  values[0].to_i,
+                  values[1],
+                  values[2].to_i,
+                  values[3],
+                  values[4].to_i,
+                  values[5].to_i,
+                  values[6].to_f,
+                  values[7].to_f,
+                  values[8],
+                  values[9].to_i,
+                  values[10].to_i,
+                  values[11],
+                  parse_policy_abbr(values[11]),
+                  values[12],
+                  values[13]
+                )
+              end
+            end
+
+            def parse_policy_abbr(value)
+              case value
+              when '-'
+                'not reported'
+              when 'TS'
+                'SCHED_OTHER'
+              when 'FF'
+                'SCHED_FIFO'
+              when 'RR'
+                'SCHED_RR'
+              when 'B'
+                'SCHED_BATCH'
+              when 'ISO'
+                'SCHED_ISO'
+              when 'IDL'
+                'SCHED_IDLE'
+              when 'DLN'
+                'SCHED_DEADLINE'
+              else
+                'unknown value'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/system/parsers/uptime.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module System
+      module Parser
+        class Uptime
+          def self.parse(command)
+            seconds = command.to_s.split[0].to_i
+            minutes = seconds / 60
+            hours = seconds / 3600
+            days = seconds / 86_400
+
+            seconds_dur = seconds
+            days_dur = seconds_dur / 86_400
+            seconds_dur -= days_dur * 86_400
+            hours_dur = seconds_dur / 3600
+            seconds_dur -= hours_dur * 3600
+            minutes_dur = seconds_dur / 60
+            seconds_dur -= minutes_dur * 60
+            uptime_s = "#{days_dur}:#{hours_dur}:#{minutes_dur}:#{seconds_dur}"
+
+            boot_time = Time.now - seconds
+
+            Kanrisuru::Core::System::Uptime.new(
+              boot_time,
+              uptime_s,
+              seconds,
+              minutes,
+              hours,
+              days
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/system/parsers/w.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module System
+      module Parser
+        class W
+          def self.parse(command)
+            result_string = command.raw_result.join
+            rows = result_string.split("\n")
+
+            rows.map do |row|
+              values = *row.split(/\s+/, 8)
+              Kanrisuru::Core::System::UserLoggedIn.new(
+                values[0],
+                values[1],
+                IPAddr.new(values[2]),
+                values[3],
+                values[4],
+                values[5].to_f,
+                values[6].to_f,
+                values[7]
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kanrisuru/core/system/types.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Kanrisuru
+  module Core
+    module System
+      CPUArchitectureVulnerability = Struct.new(
+        :name,
+        :data
+      )
+
+      CPUArchitecture = Struct.new(
+        :architecture,
+        :cores,
+        :byte_order,
+        :address_sizes,
+        :operation_modes,
+        :online_cpus,
+        :threads_per_core,
+        :cores_per_socket,
+        :sockets,
+        :numa_mode,
+        :vendor_id,
+        :cpu_family,
+        :model,
+        :model_name,
+        :stepping,
+        :cpu_mhz,
+        :cpu_max_mhz,
+        :cpu_min_mhz,
+        :bogo_mips,
+        :virtualization,
+        :hypervisor_vendor,
+        :virtualization_type,
+        :l1d_cache,
+        :l1i_cache,
+        :l2_cache,
+        :l3_cache,
+        :numa_nodes,
+        :vulnerabilities,
+        :flags
+      )
+
+      KernelStatisticCpu = Struct.new(
+        :user,
+        :nice,
+        :system,
+        :idle,
+        :iowait,
+        :irq,
+        :softirq,
+        :steal,
+        :guest,
+        :guest_nice
+      )
+
+      KernelStatistic = Struct.new(
+        :cpu_total,
+        :cpus,
+        :interrupt_total,
+        :interrupts,
+        :ctxt,
+        :btime,
+        :processes,
+        :procs_running,
+        :procs_blocked,
+        :softirq_total,
+        :softirqs
+      )
+
+      ProcessInfo = Struct.new(
+        :uid, :user, :gid, :group, :ppid, :pid,
+        :cpu_usage, :memory_usage, :stat, :priority,
+        :flags, :policy_abbr, :policy, :cpu_time, :command
+      )
+
+      Uptime = Struct.new(
+        :boot_time, :uptime, :seconds, :minutes, :hours, :days
+      )
+
+      UserLoggedIn = Struct.new(:user, :tty, :ip, :login, :idle, :jcpu, :pcpu, :command)
+
+      OpenFile = Struct.new(
+        :command,
+        :pid,
+        :uid,
+        :file_descriptor,
+        :type,
+        :device,
+        :fsize,
+        :inode,
+        :name
+      )
+
+      SessionDetail = Struct.new(
+        :tty,
+        :login_at,
+        :logout_at,
+        :ip_address,
+        :success
+      )
+
+      LoginUser = Struct.new(
+        :user,
+        :sessions
+      )
+    end
+  end
+end