greenhat 0.1.4

data/lib/greenhat/thing/formatters/time_json.rb

@@ -0,0 +1,21 @@
+# Top
+module GreenHat
+  # Log
+  module Formatters
+    # ==========================================================================
+    # Time Space JSON
+    # 2021-05-04_18:29:28.66542 {"timestamp":"2021-05-04T18:29:28.665Z","pid":3435539,"message":"Use Ctrl-C to stop"}
+    # ==========================================================================
+    def format_time_json
+      self.result = raw.map do |row|
+        time, msg = row.split(' ', 2)
+
+        result =  Oj.load msg
+        result.time = time
+
+        result
+      end
+    end
+    # ==========================================================================
+  end
+end

data/lib/greenhat/thing/formatters/time_shellwords.rb

@@ -0,0 +1,28 @@
+# Top
+module GreenHat
+  # Log
+  module Formatters
+    # ==========================================================================
+    # Formatters Not Handled
+    # ==========================================================================
+    def format_time_shellwords
+      self.result = raw.map do |row|
+        time, msg = row.split(' ', 2)
+
+        result = Shellwords.split(msg).each_with_object({}) do |x, h|
+          key, value = x.split('=')
+          next if value.nil?
+
+          h[key] = value.numeric? ? value.to_f : value
+        end
+
+        # Timestamp Parsing
+        result.ts = Time.parse result.ts if result.key? 'ts'
+        result.time = Time.parse time
+
+        result
+      end
+    end
+    # ==========================================================================
+  end
+end

data/lib/greenhat/thing/formatters/time_space.rb

@@ -0,0 +1,36 @@
+# Top
+module GreenHat
+  # Log
+  module Formatters
+    # ==========================================================================
+    # Formatters Not Handled
+    # ==========================================================================
+    def format_time_space
+      self.result = raw.map do |row|
+        time, msg = row.split(' ', 2)
+
+        {
+          time: Time.parse(time),
+          msg: msg
+        }
+      end
+    end
+    # ==========================================================================
+  end
+end
+
+# def time_space
+#   IO.foreach(file) do |row|
+#     time, msg = row.split(' ', 2)
+#     result = {
+#       time: parse_datetime(time), msg: msg, host: thing.host,
+#       source: path_format
+#     }
+
+#     result[:time] ||= datetime
+#     post result
+#   rescue StandardError => e
+#     puts "Unable to Parse, #{name}:#{e.message}"
+#     post(time: datetime, msg: row, source: path_format, host: thing.host)
+#   end
+# end

data/lib/greenhat/thing/helpers.rb

@@ -0,0 +1,71 @@
+# Global Namespace
+module GreenHat
+  # Accessors / Readers
+  module ThingHelpers
+    # Console Helper
+    def inspect
+      [
+        'Thing'.colorize(:light_black),
+        kind&.to_s&.colorize(:blue),
+        type&.colorize(:light_yellow),
+        name&.colorize(:cyan)
+      ].compact.join(' ')
+    end
+
+    # Format the name of this thing
+    def build_path(divider = '_')
+      tmp_path = file.gsub("#{archive.path}/", '')
+
+      case tmp_path.count('/')
+      when 0
+        tmp_path
+      when 1
+        tmp_path.split('/').last
+      else
+        tmp_path.split('/').last(2).join(divider)
+      end
+    end
+
+    # Check what kind of file we have
+    def type_check
+      if info?
+        :info
+      elsif SuperLog.type?(path)
+        :log
+      else
+        :raw
+      end
+    end
+  end
+end
+
+# Pretty sure this is a bad idea to patch string.
+# https://mentalized.net/journal/2011/04/14/ruby-how-to-check-if-a-string-is-numeric/
+class String
+  def numeric?
+    !Float(self).nil?
+  rescue StandardError
+    false
+  end
+end
+
+# Shims
+class Float
+  def numeric?
+    true
+  end
+end
+
+# Shims
+class TrueClass
+  def to_i
+    1
+  end
+end
+
+# Shims
+class FalseClass
+  def to_i
+    0
+  end
+end

data/lib/greenhat/thing/history.rb

@@ -0,0 +1,51 @@
+module GreenHat
+  # Helper for Remembering what files were
+  module ThingHistory
+    def self.files
+      @files ||= read
+
+      @files
+    end
+
+    # Read File / Remove Old Entries
+    def self.read
+      if File.exist? file
+        results = Oj.load File.read(file)
+
+        results.reject { |_k, v| Time.at(v.time) < Time.now }
+      else
+        {}
+      end
+    ensure
+      {}
+    end
+
+    def self.file
+      Settings.history_file
+    end
+
+    # Initial Entry Point
+    def self.match?(name)
+      files.key? name.to_sym
+    end
+
+    def self.match(name)
+      files.dig(name.to_sym, :type)
+    end
+
+    def self.add(name, type)
+      files[name] = { type: type, time: expire }
+
+      write
+    end
+
+    # Date to Expire
+    def self.expire
+      2.weeks.from_now.to_i
+    end
+
+    def self.write
+      File.write(file, Oj.dump(files))
+    end
+  end
+end

data/lib/greenhat/thing/info_format.rb

@@ -0,0 +1,193 @@
+module GreenHat
+  # Info Formatter
+  module InfoFormat
+    # Is this something that can be formatted by info?
+    def info?
+      methods.include? "format_#{path}".to_sym
+    end
+
+    # Handle Info Formatting
+    def info_format
+      self.result = send("format_#{path}")
+    end
+
+    def format_headers_n_lines
+      # Headers to Readable Symbol
+      headers = raw.first.split(' ', 6).map(&:downcase).map do |x|
+        x.gsub(/\s+/, '_').gsub(/[^0-9A-Za-z_]/, '')
+      end.map(&:to_sym)
+
+      output = []
+
+      # Put fields into a Hash based on Location/Key
+      raw[1..].map(&:split).each do |row|
+        result = {}
+        row.each_with_index do |detail, i|
+          result[headers[i]] = detail
+        end
+        output.push result
+      end
+
+      self.result = output
+    end
+
+    # All Similar to Header and Lines
+    alias format_df_inodes format_headers_n_lines
+    alias format_df_h format_headers_n_lines
+
+    def format_mount(data)
+      data.select { |x| x.include? ':' }
+    end
+
+    def format_free_m
+      split_white_space raw
+    end
+
+    def format_meminfo
+      raw.map { |x| x.split(' ', 2) }
+    end
+
+    def format_netstat_conn_headers
+      [
+        'Proto', 'Recv-Q', 'Send-Q', 'Local Address', 'Foreign Address', 'State', 'PID/Program name'
+      ]
+    end
+
+    def format_netstat_socket_headers
+      [
+        'Proto', 'RefCnt', 'Flags', 'Type', 'State', 'I-Node', 'PID/Program name', 'Path'
+      ]
+    end
+
+    def format_netstat
+      # Data can return blank or single item array
+      conns, sockets = raw.split { |x| x.include? 'Active' }.reject(&:empty?)
+
+      formatted_conns = conns[1..].map do |entry|
+        entry.split(' ', 7).map(&:strip).each_with_index.map do |field, idx|
+          [format_netstat_conn_headers[idx], field]
+        end.to_h
+      end
+
+      formatted_sockets = sockets[1..].map do |entry|
+        entry.split('  ').map(&:strip).reject(&:blank?).each_with_index.map do |field, idx|
+          [format_netstat_socket_headers[idx], field]
+        end.to_h
+      end
+
+      {
+        connections: formatted_conns,
+        sockets: formatted_sockets
+      }
+    end
+
+    def format_netstat_i
+      headers = raw[1].split
+      result = raw[2..].map do |row|
+        row.split.each_with_index.map do |x, idx|
+          [headers[idx], x]
+        end
+      end
+
+      result.map(&:to_h)
+    end
+
+    def split_white_space(data)
+      data.map(&:split)
+    end
+
+    def ps_format
+      headers = info.ps.first.split(' ', 11)
+      list = info.ps[1..].each.map do |row|
+        row.split(' ', 11).each_with_index.each_with_object({}) do |(v, i), obj|
+          obj[headers[i]] = v
+        end
+      end
+      { headers: headers, list: list }
+    end
+
+    def manifest_json_format
+      Oj.load info[:gitlab_version_manifest_json].join
+    end
+
+    def cpuinfo_format
+      info.cpuinfo.join("\n").split("\n\n").map do |cpu|
+        all = cpu.split("\n").map do |row|
+          row.delete("\t").split(': ')
+        end
+        { details: all[1..], order: all[0].last }
+      end
+    end
+
+    def cpu_speed
+      return nil unless data? :lscpu
+
+      info.lscpu.find { |x| x.include? 'MHz' }.split('               ')
+    end
+
+    def total_memory
+      return nil unless data? :free_m
+
+      value = info.free_m.dig(1, 1).to_i
+      number_to_human_size(value * 1024 * 1024)
+    end
+
+    def ulimit
+      return nil unless data? :ulimit
+
+      results = info.ulimit.map do |entry|
+        {
+          value: entry.split[-1],
+          details: entry.split('  ').first
+        }
+      end
+
+      results.sort_by { |x| x[:details].downcase }
+    end
+
+    def systemctl_format
+      return nil unless data? :systemctl_unit_files
+
+      all = info.systemctl_unit_files[1..-2].map do |x|
+        unit, status = x.split
+        { unit: unit, status: status }
+      end
+      all.reject! { |x| x[:unit].nil? }
+      all.sort_by(&:unit)
+    end
+
+    # Helper to color the status files
+    def systemctl_color(entry)
+      case entry.status
+      when 'enabled'  then :green
+      when 'static'   then :orange
+      when 'disabled' then :red
+      else
+        :grey
+      end
+    end
+
+    def vmstat_format
+      return nil unless data? :vmstat
+
+      info.vmstat[2..].map(&:split)
+    end
+
+    def uptime
+      info.uptime.join.split(',', 4).map(&:lstrip) if info.key? :uptime
+    end
+
+    def mount
+      return nil unless info.key? :mount
+      return nil if info.mount.empty?
+
+      MountFormat.parse(info.mount)
+    end
+
+    def format_single_json
+      Oj.load raw.join("\n")
+    end
+
+    alias format_gitlab_version_manifest_json format_single_json
+  end
+end

data/lib/greenhat/thing/kind.rb

@@ -0,0 +1,97 @@
+module GreenHat
+  # Overall Type Parsing
+  module Kind
+    # rubobop:disable *
+    def kind_collect
+      # If Direct Match
+      if types.key? name
+        self.type = name
+
+        return true
+      end
+
+      # Check Pattern Matches
+      matches = types.select do |_k, v|
+        v.pattern.any? { |x| x =~ name }
+      end
+
+      # If there is only one match
+      if matches.keys.count == 1
+        self.type = matches.keys.first
+
+        true
+
+      # TODO: Prompt for smaller selection
+      elsif matches.keys.count > 1
+        puts 'Multiple!'
+      # History Match
+      elsif ThingHistory.match? name
+        self.type = ThingHistory.match(name)
+      else
+        prompt_for_kind
+      end
+    end
+
+    # File Identifier
+    def kind_setup
+      self.kind = types.dig(type, :format)
+      self.log = types.dig(type, :log)
+    end
+
+    def prompt
+      # Quiet Exit
+      @prompt ||= TTY::Prompt.new(interrupt: :exit)
+    end
+
+    def check_oj_parse?(first_line)
+      Oj.load(first_line)
+      true
+    rescue StandardError
+      false
+    end
+
+    # rubocop:disable Style/SymbolProc
+    def prompt_for_kind
+      binding.pry if ENV['DEBUG']
+
+      # Default to everything
+      prompt_list = types.clone
+
+      first_line = File.open(file) { |f| f.readline }
+      json = check_oj_parse?(first_line)
+
+      if json
+        prompt_list.select! do |_k, v|
+          v.to_s.include? 'json'
+        end
+      end
+
+      puts "Unable to determine file type for #{name.colorize(:yellow)}"
+      puts "Use '#{'json'.colorize(:cyan)}' and '#{'raw'.colorize(:cyan)}' if you cannot find any matches"
+
+      option = prompt.select('Wat is this?', prompt_list.keys.sort_by(&:length), filter: true)
+
+      # Store for later
+      ThingHistory.add(name, option)
+
+      self.type = option
+    end
+    # rubocop:enable Style/SymbolProc
+
+    # Pattern Match / Look for `match_` patterns and then strip name for kind type
+    def kind_pattern_match(name)
+      pattern_match = methods.grep(/^match_/).find do |pattern|
+        send(pattern).any? { |x| name =~ x }
+      end
+
+      if pattern_match
+        pattern_match.to_s.split('match_', 2).last.to_sym
+      else
+        false
+      end
+    end
+  end
+end
+
+# Load All Formatters
+require_all "#{File.dirname(__FILE__)}/formatters"