greenhat 0.1.4

data/lib/greenhat/cli.rb

@@ -0,0 +1,448 @@
+# Top level namespace
+module GreenHat
+  # CLI Methods
+  # rubocop:disable Metrics/ModuleLength
+  module Cli
+    def self.cursor
+      @cursor = TTY::Cursor
+    end
+
+    # Input Loop Listener
+    def self.reader
+      @reader ||= reader_setup
+    end
+
+    def self.files
+      @files ||= Thing.all.map(&:name).uniq
+    end
+
+    def self.reader_setup
+      reader = TTY::Reader.new(history_duplicates: false, interrupt: -> { back })
+
+      Settings.cmd_history_clean.each do |line|
+        reader.add_to_history(line)
+      end
+
+      # Blank?
+      reader.add_to_history ''
+
+      # Remove Line
+      reader.on(:keyctrl_u) do |_event|
+        reader.line.remove reader.line.text.size
+      end
+
+      # Navigate Word Left
+      reader.on(:keyctrl_left) { reader.line.move_word_left }
+
+      # Navigate Word Right
+      reader.on(:keyctrl_right) { reader.line.move_word_right }
+
+      # Navigate Beginning
+      reader.on(:keyctrl_a) { reader.line.move_to_start }
+
+      # Navigate End
+      reader.on(:keyctrl_e) { reader.line.move_to_end }
+
+      reader.on(:keyback_tab) { back }
+
+      reader.on(:keytab) do
+        process
+        auto
+      end
+
+      reader.instance_variable_get(:@history)
+
+      # DEBUG PRY
+      reader.on(:keyctrl_p) do |event|
+        binding.pry
+      end
+      reader
+    end
+
+    # =========================================================
+    # Auto Complete
+    # =========================================================
+    def self.auto
+      word = reader.line.word
+
+      if word.blank?
+        help
+      else
+        auto_match(current_methods + current_submodules + cmd_list, word)
+      end
+    end
+
+    def self.auto_match(matches, word)
+      matches.select! { |x| x[/^#{Regexp.escape(word)}/] }
+
+      if submodule?
+        submodule!
+        reader.breaker = true
+      # Only one Match!
+      elsif matches.count == 1
+        auto_update(matches.first, word)
+
+      # Print List of Options
+      elsif matches.count > 1
+        puts matches.join("\t").colorize(:light_green)
+
+      # No other Matches
+      else
+        file_matches = files.select { |x| x[/^#{Regexp.escape(word)}/] }
+        auto_files(file_matches, word) unless file_matches.empty?
+
+      end
+    end
+
+    # Auto Complete File Names
+    def self.auto_files(matches, word)
+      if matches.count == 1
+        auto_update(matches.first, word)
+
+      # Print List of Options
+      elsif matches.count > 1
+        auto_update(common_substr(matches), word)
+        puts matches.join("\t").colorize(:light_green)
+      end
+    end
+
+    # Handle Updates to Reader
+    def self.auto_update(match, word)
+      add = match.split(word, 2).last
+      reader.line.insert add unless add.nil?
+    end
+
+    # Complete as much as possible comparison
+    # https://stackoverflow.com/a/2158481/1678507
+    def self.common_substr(strings)
+      shortest = strings.min_by(&:length)
+      maxlen = shortest.length
+      maxlen.downto(0) do |len|
+        0.upto(maxlen - len) do |start|
+          substr = shortest[start, len]
+          return substr if strings.all? { |str| str.include? substr }
+        end
+      end
+    end
+    # =========================================================
+
+    def self.did_you_mean
+      dictionary = current_methods + current_submodules + cmd_list
+
+      # all.select! { |x| x.include? cmd }
+
+      all = DidYouMean::SpellChecker.new(dictionary: dictionary).correct(cmd)
+
+      if all.empty?
+        puts [
+          'Command not found '.colorize(:red),
+          cmd.colorize(:light_yellow),
+          ' ('.colorize(:light_black),
+          'help'.colorize(:blue),
+          ' to show available commands'.colorize(:light_black),
+          ')'.colorize(:light_black)
+        ].join
+      else
+        puts "#{'Did you mean?'.colorize(:cyan)}  #{all.join("\t").colorize(:green)}"
+      end
+    end
+
+    # Auto/Run Process - Populate and parse: @list
+    def self.process
+      line = reader.line
+      @list = Shellwords.split line.text
+    rescue StandardError => e
+      puts "#{'Invalid Command'.colorize(:red)}: #{e.message.colorize(:green)}"
+    end
+
+    def self.available(list)
+      list.map(&:to_s).map(&:downcase)
+    end
+
+    # Reader helper
+    def self.cmd
+      @list.first
+    end
+
+    def self.run?
+      current_methods.include? cmd
+    end
+
+    # Special Command Overrides
+    def self.cmd_list
+      ['help', '~', '..', 'back', 'clear']
+    end
+
+    def self.cmd?
+      cmd_list.any? cmd
+    end
+
+    def self.submodule?
+      current_submodules.include? @list.first
+    end
+
+    def self.cmd_run
+      case cmd
+      when 'help' then help
+      when '~' then home
+      when '..', 'back' then back
+      when 'clear' then clear_screen
+      end
+
+      @list.shift
+    end
+
+    # Final Command Execution
+    def self.run!
+      # Shift to prevent duplicate Runs / Arity for identifying if Method has params
+      if current_location.method(@list.first).arity.zero?
+        current_location.send(@list.shift.clone)
+      else
+        current_location.send(@list.shift.clone, @list.clone)
+      end
+    end
+
+    def self.run
+      return true if @list.blank?
+
+      if cmd?
+        cmd_run
+      elsif run?
+        run!
+
+        return true # End Early
+
+      elsif current_submodule?
+        @list.shift
+      elsif submodule?
+        submodule!
+      # Prepend Default if exists
+      elsif default?
+        @list.unshift 'default'
+      else
+        did_you_mean
+        @list.shift
+      end
+
+      run # Loop Back
+    rescue StandardError => e
+      LogBot.fatal('CLI Run', e.message)
+      puts e.backtrace[0..4].join("\n").colorize(:red)
+    end
+
+    # Check for `default` method and files
+    def self.default?
+      files.include?(cmd) && current_methods.include?('default')
+    end
+
+    # General Helper
+    def self.help
+      if current_location.methods(false).count.zero?
+        puts 'No Commands'.colorize(:red)
+      else
+        puts 'Commands: '
+        current_location.methods(false).map(&:to_s).sort.each do |item|
+          next if %w[default help].any? { |x| x == item }
+
+          puts "=> #{item.to_s.colorize(:blue)}"
+        end
+
+        current_location.send(:help) if current_methods.include? 'help'
+      end
+
+      puts ''
+
+      if current_location.constants.count.zero?
+        puts 'No Submodules'.colorize(:red)
+      else
+        puts 'Submodules'
+        current_location.constants.each do |item|
+          puts "-> #{item.to_s.demodulize.downcase.colorize(:yellow)}"
+        end
+      end
+    end
+
+    def self.location
+      @location ||= [Shell]
+    end
+
+    # Replace Location
+    def self.move(spot)
+      @location = [spot]
+    end
+
+    # Append to Location
+    def self.submodule!
+      spot = @list.shift
+      reader.line.replace @list.join(' ')
+      @location << current_location.const_get(spot.capitalize.to_sym)
+    end
+
+    def self.home
+      move Shell
+    end
+
+    def self.back
+      move location[-2] if location.count > 1
+    end
+
+    # Reader to Get Last Location's Available Methods / Keep Helper Methods
+    def self.current_methods
+      current_location.methods(false).map(&:to_s)
+      # .reject { |x| x.include? '_help' }
+    end
+
+    def self.current_submodules
+      current_location.constants.map(&:to_s).map(&:downcase)
+    end
+
+    # Full Commands at the Submodule `disk summary` from `disk`
+    def self.current_submodule?
+      current_location.to_s.demodulize.downcase == @list.first
+    end
+
+    def self.current_location
+      location.last
+    end
+
+    def self.location_reader
+      location.map(&:to_s).map(&:downcase).map(&:demodulize).join('/').gsub('shell', '~').colorize(:blue)
+    end
+
+    def self.readline_notch
+      "#{'greenhat'.colorize(:light_black)} #{location_reader} » "
+    end
+
+    def self.clear_screen
+      print cursor.clear_screen + cursor.move_to(0, 0)
+    end
+
+    def self.quiet
+      @quiet
+    end
+
+    # Process any Args
+    # --report
+    # --quiet
+    # --load -- Auto Load Things
+    # TODO: Add Help (--help)
+    def self.startup_args(files)
+      @report = true if files.any? { |x| ['--report', '-r'].include? x }
+      @quiet = true if files.any? { |x| ['--quiet', '-q'].include? x }
+      @load = true if files.any? { |x| ['--load', '-l'].include? x }
+
+      binding.pry if files.include? '--help'
+
+      files.reject! { |x| startup_arg_list.include? x }
+    end
+
+    def self.startup_arg_list
+      ['--load', '--l', '--quiet', '-q', '--report', '-r']
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def self.start(files)
+      # If no arguments Supplied Print and quit - rather than nasty exception
+      # TODO: Add Usage
+
+      Settings.start
+
+      startup_args files
+      clear_screen
+
+      if files.empty? || files.count { |x| File.exist? x }.zero?
+        puts "No arguments or files don't exist".colorize(:red)
+        puts 'Usage: greenhat  <sos-archive.tgz> <sos-archive2.tgz>'
+        Shell.about
+      end
+
+      load_files files
+
+      # Handle Args
+      if @report
+        # Don't Use Pagination
+        GreenHat::Shell.report(['--raw'])
+        return true
+      end
+
+      Thing.all.each(&:process) if @load
+
+      value ||= '' # Empty Start
+
+      loop do
+        line = reader.read_line(readline_notch, value: value)
+        value = '' # Remove Afterwards
+
+        if reader.breaker
+          value = line
+          puts ''
+          next
+        end
+
+        if line =~ /^exit/i
+          Settings.cmd_write
+
+          break
+        end
+
+        Settings.cmd_add(line) unless line.blank?
+
+        process
+        run
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def self.load_files(files)
+      # TODO: Web Helpers?
+      # suppress_output { GreenHat::Web.start }
+
+      # Don't double up on archives / Only Existing files
+      puts 'Loading Archives'.colorize(:blue)
+      files.uniq.each do |file|
+        next unless File.exist?(file)
+
+        puts "- #{file}".colorize(:magenta)
+        ArchiveLoader.load file
+      end
+    end
+
+    def self.suppress_output
+      original_stderr = $stderr.clone
+      original_stdout = $stdout.clone
+      $stderr.reopen(File.new('/dev/null', 'w'))
+      $stdout.reopen(File.new('/dev/null', 'w'))
+      yield
+    ensure
+      $stdout.reopen(original_stdout)
+      $stderr.reopen(original_stderr)
+    end
+
+    def self.template
+      "#{__dir__}/views/index.slim"
+    end
+
+    def self.output
+      'greenhat.html'
+    end
+
+    def self.prompt
+      TTY::Prompt.new(active_color: :cyan)
+    end
+
+    # TODO
+    def self.menu
+      prompt.select('Wat do?') do |menu|
+        menu.choice name: 'exit'
+        menu.choice name: 'Export Kibana Dashboard', value: 'export'
+        menu.choice name: 'console (pry)', value: 'console'
+      end
+    end
+
+    def self.bad_file(archive)
+      puts color("Cannot find archive: #{archive}", :red)
+      exit 1
+    end
+  end
+  # rubocop:enable Metrics/ModuleLength
+end

data/lib/greenhat/host.rb

@@ -0,0 +1,182 @@
+# Individual Host Helper
+class Host < Teron
+  include ActionView::Helpers::DateHelper
+  include ActionView::Helpers::NumberHelper
+
+  field :name
+
+  belongs_to :archive
+
+  # def load(file)
+  #   @file = file
+  #   self.files = Archive.load(file)
+  #   save!
+  # end
+
+  def archive_name
+    File.basename archive
+  end
+
+  def find_file(file_name)
+    files.find { |x| x.name == file_name }
+  end
+
+  def icon
+    release_file = find_file files.map(&:name).grep(/_release/).first
+
+    release = release_file.raw.join
+
+    if release.include? 'ubuntu'
+      'fa-ubuntu'
+    elsif release.include? 'suse'
+      'fa-suse'
+    elsif release.include? 'redhat'
+      'fa-redhat'
+    elsif release.include? 'centos'
+      'fa-centos'
+    else
+      'fa-linux'
+    end
+  end
+
+  # ----------------------------
+  # Helpers
+  # ----------------------------
+  def percent(value, total)
+    (value.to_i / total.to_f).round(2) * 100
+  end
+
+  def systemctl_color(entry)
+    case entry.status
+    when 'enabled'  then :green
+    when 'static'   then :orange
+    when 'disabled' then :red
+    else
+      :grey
+    end
+  end
+  # ---------------------------
+
+  def manifest
+    file = find_file 'gitlab_version_manifest_json'
+    return nil unless file
+
+    Oj.load file.raw.join
+  end
+
+  def uptime
+    file = find_file 'uptime'
+    return nil unless file
+
+    file.raw
+  end
+
+  def uname
+    file = find_file 'uname'
+    return nil unless file
+
+    file.raw.join
+  end
+
+  def cpuinfo
+    file = find_file 'cpuinfo'
+    return nil unless file
+
+    file.raw.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
+    file = find_file 'lscpu'
+    return nil unless file
+
+    details = file.raw.find { |x| x.include? 'MHz' }
+    details.reverse.split(' ', 2).map(&:reverse).reverse
+  end
+
+  def total_memory
+    file = find_file 'free_m'
+    return nil unless file
+
+    value = file.raw.dig(1, 1).to_i
+    number_to_human_size(value * 1024 * 1024)
+  end
+
+  def free_m
+    file = find_file 'free_m'
+    return nil unless file
+
+    file.raw
+  end
+
+  def df_h
+    file = find_file 'df_h'
+    return nil unless file
+
+    file.raw
+  end
+
+  def netstat
+    file = find_file 'netstat'
+    return nil unless file
+
+    file.raw
+  end
+
+  def ulimit
+    file = find_file 'ulimit'
+    return nil unless file
+
+    results = file.raw.map do |entry|
+      {
+        value: entry.split[-1],
+        details: entry.split('  ').first
+      }
+    end
+
+    results.sort_by { |x| x[:details].downcase }
+  end
+
+  def processes
+    file = find_file 'ps'
+    return nil unless file
+
+    headers = file.raw.first.split(' ', 11)
+    list = file.raw[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 systemctl_unit_files
+    file = find_file 'systemctl_unit_files'
+    return nil unless file
+
+    all = file.raw[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
+end
+
+# # Slim Wrapper
+# class List
+#   attr_accessor :hosts
+
+#   def initialize
+#     self.hosts = []
+#   end
+
+#   def slim(file, host = nil)
+#     Slim::Template.new("#{__dir__}/views/#{file}.slim").render(host)
+#   end
+# end