greenhat 0.1.4 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbb51c051ab366c7bb7a172c4a917d7646bd5bdbc00c894217403655130bb2f3
-  data.tar.gz: b4e997388954091b257df23a1f67093490b8c1996635c860b3e462fa3f44213c
+  metadata.gz: cf89eef7afeef6861dde013e8cc7992a92d1c9f4dca79ca0a438913f6d9a7a89
+  data.tar.gz: eed033653f4723f19962f5643ac02c71d9f950f97aa4a68375cc3174152e5513
 SHA512:
-  metadata.gz: 965baad78deb383ed1c1cb569a219439daa4c73adf7fd8b3f2852ee1b9703e758e91b0784ac1c1ac999045dd8a0d871927680d2718829ebcc3740dcc4c334a00
-  data.tar.gz: 17111df14082319b62bca88224ccf4b0b433ac9bcda5d1fe9c922e08477632a6c0831f61dc8615f633f0d8c4b70c58d54fe765c63172c4f4573b6812fc61aee1
+  metadata.gz: 90c1a58ef0334bd864480ad422957758850ecacd39bc85db1fd47233192e09bda768e15331dc179d8860f4842aed58fafb439f4f9499ff22d1c25e3ebf8bff74
+  data.tar.gz: aea2b938e6b1a5956d7811084b1ab725cf41f2d0766affffed696755ac497cc41a67ebfc562ce516ce448ebb983e6e504a493e772348fd536f1e5c711954f612

data/README.md

@@ -14,20 +14,15 @@ Experimental SOS and Log Parser for GitLab
 
 ## Installation
 
-While potentially so in the future, this is currently not a published gem. To install:
-
 ```
-git clone https://gitlab.com/gitlab-com/support/toolbox/greenhat
-cd greenhat
-bundle install
-bundle exec rake install
+gem install greenhat
 ```
 
 ## Usage
 
 ```
 greenhat sos-archive.tar.gz
-greenhat production_log.json
+greenhat production_json.log
 # launches a console
 >> help # the program is self-documented through the builtin help command
 ```

data/lib/greenhat/accessors/disk.rb

@@ -20,8 +20,64 @@ module GreenHat
       end
     end
 
-    def self.df
-      Thing.where(name: 'df_h')
+    def self.df(args = {})
+      things = Thing.where(name: 'df_h')
+
+      # Host / Archive
+      things.select! { |x| x.archive? args.archive } if args.archive
+
+      things
+    end
+
+    # Unified Output Handler
+    # rubocop:disable Metrics/MethodLength
+    def self.format_output(file, name = false, limit = nil, filter = %w[tmpfs loop])
+      output = []
+
+      output << file.friendly_name if name
+
+      # Reject TMPFS
+      disks = file.data.sort_by { |x| x.use.to_i }.reverse
+
+      # Filter
+      disks.reject! { |x| filter.any? { |y| x.filesystem.include? y } }
+
+      disks = disks[0..limit - 1] if limit
+
+      pad_mount, pad_size, pad_used, pad_avail = GreenHat::Disk.padding(disks)
+
+      # Headers
+      output << [
+        'Mount'.ljust(pad_mount).pastel(:blue),
+        'Size'.ljust(pad_size).pastel(:magenta),
+        'Used'.ljust(pad_used).pastel(:cyan),
+        'Avail'.ljust(pad_avail).pastel(:white),
+        '% Use'.ljust(pad_avail).pastel(:green)
+      ].join
+
+      # Table Summary
+      disks.map do |disk|
+        # Pretty Disk Use
+        use = [
+          disk.use.rjust(5).ljust(5).pastel(:green),
+          '  ['.pastel(:blue),
+          ('=' * (disk.use.to_i / 2)).pastel(:green),
+          ' ' * (50 - disk.use.to_i / 2),
+          ']'.pastel(:blue)
+        ].join
+
+        # Whole Thing
+        output << [
+          disk.mounted_on.ljust(pad_mount).pastel(:blue),
+          disk[:size].to_s.ljust(pad_size).pastel(:magenta),
+          disk.used.to_s.ljust(pad_used).pastel(:cyan),
+          disk.avail.to_s.ljust(pad_avail).pastel(:white),
+          use
+        ].join
+      end
+
+      output
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/greenhat/accessors/gitlab.rb

@@ -0,0 +1,75 @@
+module GreenHat
+  # GitLab App Helpers
+  module GitLab
+    def self.node_types
+      [
+        {
+          name: 'Web Service', pattern: %w[puma unicorn]
+        },
+        {
+          name: 'Sidekiq', pattern: %w[sidekiq]
+        },
+        {
+          name: 'Gitaly', pattern: %w[gitaly]
+        },
+        {
+          name: 'Redis', pattern: %w[redis]
+        },
+        {
+          name: 'PostgreSQL', pattern: %w[postgresql]
+        },
+        {
+          name: 'PGBouncer', pattern: %w[pgbouncer]
+        }
+      ]
+    end
+
+    def self.identify_node(archive)
+      gitlab_status = archive.things.find { |x| x.name == 'gitlab_status' }&.data&.keys
+      hostname = archive.things.find { |x| x.type == 'hostname' }.data.first
+
+      {
+        host: hostname,
+        services: gitlab_status || []
+      }
+    end
+
+    # Show GitLab Services in a grid / include versions
+    def self.services(archive, indent = 0)
+      manifest = archive.things.find { |x| x.type == 'gitlab/version-manifest.json' }
+      gitlab_status = archive.things.find { |x| x.name == 'gitlab_status' }
+
+      return nil unless gitlab_status
+
+      list = gitlab_status.data.keys.sort.map do |service|
+        color = gitlab_status.data.dig(service, 0, :status) == 'run' ? :green : :red
+
+        # Collect Service version from manifest
+        version = manifest.data.software[service.to_sym]&.display_version
+
+        # If able to identify version use / fallback
+        if version
+          [
+            service.pastel(color),
+            "(#{version})".pastel(:bright_black)
+          ].join(' ')
+        else
+          service.pastel(color)
+        end
+      end
+
+      # Keep Alphabetical Sort
+      groups = list.each_slice((list.size / 3.to_f).round).to_a
+
+      table = TTY::Table.new do |t|
+        loop do
+          break if groups.all?(&:empty?)
+
+          t << groups.map(&:shift)
+        end
+      end
+
+      table.render(:unicode, padding: [0, 1, 0, 1], indent: indent)
+    end
+  end
+end

data/lib/greenhat/accessors/memory.rb

@@ -18,24 +18,24 @@ module GreenHat
       used_name = number_to_human_size(mem.used.to_i.megabytes)
 
       bar = [
-        '|'.colorize(:green) * percentage(mem.used, total),
-        '|'.colorize(:blue) * percentage(mem.shared, total),
-        '|'.colorize(:teal) * percentage(mem.buffcache, total),
+        '|'.pastel(:green) * percentage(mem.used, total),
+        '|'.pastel(:blue) * percentage(mem.shared, total),
+        '|'.pastel(:cyan) * percentage(mem.buffcache, total),
         ' ' * percentage(mem.free, total)
       ].join
 
       # Make Even
-      padding = 125 - bar.uncolorize.size
+      padding = 125 - bar.unpastel.size
       bar += ' ' * padding if padding.positive?
 
       [
-        mem.kind.ljust(4).colorize(:cyan),
-        ' ['.colorize(:light_black),
+        mem.kind.ljust(4).pastel(:cyan),
+        ' ['.pastel(:bright_black),
         bar.ljust(120),
-        used_name.colorize(:magenta),
-        ' / '.colorize(:light_black),
-        total_name.colorize(:blue),
-        ']'.colorize(:light_black)
+        used_name.pastel(:magenta),
+        ' / '.pastel(:bright_black),
+        total_name.pastel(:blue),
+        ']'.pastel(:bright_black)
       ].join
     end
 

data/lib/greenhat/accessors/process.rb

@@ -1,7 +1,16 @@
 module GreenHat
   # Sidekiq Log Helpers
   module Ps
-    def self.ps
+    def self.ps(args)
+      things = Thing.where(name: 'ps')
+
+      # Host / Archive
+      things.select! { |x| x.archive? args.archive } if args.archive
+
+      things
+    end
+
+    def self.things
       Thing.where(name: 'ps')
     end
   end

data/lib/greenhat/cli.rb

@@ -54,7 +54,9 @@ module GreenHat
 
       # DEBUG PRY
       reader.on(:keyctrl_p) do |event|
+        # rubocop:disable Lint/Debugger
         binding.pry
+        # rubocop:enable Lint/Debugger
       end
       reader
     end
@@ -84,7 +86,7 @@ module GreenHat
 
       # Print List of Options
       elsif matches.count > 1
-        puts matches.join("\t").colorize(:light_green)
+        puts matches.join("\t").pastel(:bright_green)
 
       # No other Matches
       else
@@ -102,7 +104,7 @@ module GreenHat
       # Print List of Options
       elsif matches.count > 1
         auto_update(common_substr(matches), word)
-        puts matches.join("\t").colorize(:light_green)
+        puts matches.join("\t").pastel(:bright_green)
       end
     end
 
@@ -135,15 +137,15 @@ module GreenHat
 
       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)
+          'Command not found '.pastel(:red),
+          cmd.pastel(:bright_yellow),
+          ' ('.pastel(:bright_black),
+          'help'.pastel(:blue),
+          ' to show available commands'.pastel(:bright_black),
+          ')'.pastel(:bright_black)
         ].join
       else
-        puts "#{'Did you mean?'.colorize(:cyan)}  #{all.join("\t").colorize(:green)}"
+        puts "#{'Did you mean?'.pastel(:cyan)}  #{all.join("\t").pastel(:green)}"
       end
     end
 
@@ -152,7 +154,7 @@ module GreenHat
       line = reader.line
       @list = Shellwords.split line.text
     rescue StandardError => e
-      puts "#{'Invalid Command'.colorize(:red)}: #{e.message.colorize(:green)}"
+      puts "#{'Invalid Command'.pastel(:red)}: #{e.message.pastel(:green)}"
     end
 
     def self.available(list)
@@ -227,39 +229,46 @@ module GreenHat
       run # Loop Back
     rescue StandardError => e
       LogBot.fatal('CLI Run', e.message)
-      puts e.backtrace[0..4].join("\n").colorize(:red)
+      puts e.backtrace[0..4].join("\n").pastel(:red)
     end
 
     # Check for `default` method and files
     def self.default?
-      files.include?(cmd) && current_methods.include?('default')
+      @list.any? { |x| x.include?(cmd) } && current_methods.include?('default')
     end
 
     # General Helper
-    def self.help
+    def self.help(long = true)
       if current_location.methods(false).count.zero?
-        puts 'No Commands'.colorize(:red)
+        puts 'No Commands'.pastel(: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)}"
+          puts "=> #{item.to_s.pastel(:blue)}"
         end
 
-        current_location.send(:help) if current_methods.include? 'help'
       end
 
       puts ''
 
       if current_location.constants.count.zero?
-        puts 'No Submodules'.colorize(:red)
+        puts 'No Submodules'.pastel(:red)
       else
         puts 'Submodules'
         current_location.constants.each do |item|
-          puts "-> #{item.to_s.demodulize.downcase.colorize(:yellow)}"
+          puts "-> #{item.to_s.demodulize.downcase.pastel(:yellow)}"
         end
       end
+
+      # Execute local help last if exists
+      if current_methods.include?('help') && long
+        puts
+        current_location.send(:help)
+      end
+
+      puts ''
     end
 
     def self.location
@@ -306,11 +315,11 @@ module GreenHat
     end
 
     def self.location_reader
-      location.map(&:to_s).map(&:downcase).map(&:demodulize).join('/').gsub('shell', '~').colorize(:blue)
+      location.map(&:to_s).map(&:downcase).map(&:demodulize).join('/').gsub('shell', '~').pastel(:blue)
     end
 
     def self.readline_notch
-      "#{'greenhat'.colorize(:light_black)} #{location_reader} » "
+      "#{'greenhat'.pastel(:bright_black)} #{location_reader} » "
     end
 
     def self.clear_screen
@@ -321,51 +330,99 @@ module GreenHat
       @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 }
+    # Toggle Quiet Settings
+    def self.quiet!
+      @quiet = !@quiet
+    end
 
-      binding.pry if files.include? '--help'
+    def self.cli_help
+      Shell.version
+      puts
+      puts 'Usage'.pastel(:yellow)
+      puts '  greenhat  <sos-archive.tgz> <sos-archive2.tgz> '
+      puts
 
-      files.reject! { |x| startup_arg_list.include? x }
-    end
+      puts 'Options'.pastel(:yellow)
+      puts '  --report, -r'.pastel(:green)
+      puts '    Run `report` against archives and exit'
+      puts
+
+      puts '  --quiet, -r'.pastel(:green)
+      puts '    Surpress GreenHat logging output'
+      puts
+
+      puts '  --load, -l'.pastel(:green)
+      puts '    Automatically attempt to read/parse/preload all included files'
+      puts
+
+      puts '  --command, -c'.pastel(:green)
+      puts '    Run and then exit a GreenHat Shell command'
+      puts
 
-    def self.startup_arg_list
-      ['--load', '--l', '--quiet', '-q', '--report', '-r']
+      puts '  --version, -v'.pastel(:green)
+      puts '    Print version and exit'
+      puts
     end
 
-    # rubocop:disable Metrics/MethodLength
-    def self.start(files)
-      # If no arguments Supplied Print and quit - rather than nasty exception
-      # TODO: Add Usage
+    # Arguments before general processing
+    def self.pre_args(flags, files)
+      # Help
+      if flags?(%i[help h], flags)
+        cli_help
+        exit 0
+      end
 
-      Settings.start
+      # Version
+      if flags?(%i[version v], flags)
+        Shell.version
+        exit 0
+      end
 
-      startup_args files
-      clear_screen
+      # Quiet Flag
+      @quiet = true if flags?(%i[quiet q], flags)
 
+      # rubocop:disable Style/GuardClause
+      # MIA Files
       if files.empty? || files.count { |x| File.exist? x }.zero?
-        puts "No arguments or files don't exist".colorize(:red)
+        puts "No arguments or files don't exist".pastel(:red)
         puts 'Usage: greenhat  <sos-archive.tgz> <sos-archive2.tgz>'
-        Shell.about
+        cli_help
+        Shell.version
       end
+      # rubocop:enable Style/GuardClause
+    end
 
-      load_files files
-
-      # Handle Args
-      if @report
+    # Arguments to be handled after general processing
+    def self.post_args(flags)
+      # Run report and exit / Don't Clear for reports
+      if flags?(%i[report r], flags)
+        @quiet = true
         # Don't Use Pagination
         GreenHat::Shell.report(['--raw'])
-        return true
+        exit 0
+      else
+        clear_screen
       end
 
-      Thing.all.each(&:process) if @load
+      # CTL Tails need to be parsed for new 'things'
+      Thing.where(kind: :gitlab_tail)&.map(&:process)
+
+      Thing.all.each(&:process) if flags?(%i[load l], flags)
+    end
+
+    # Helper to Simplify checking flags
+    def self.flags?(list = [], flags = {})
+      list.any? { |x| flags.key? x }
+    end
+
+    # If no arguments Supplied Print and quit - rather than nasty exception
+    def self.start(raw)
+      Settings.start
+      files, flags, args = Args.parse(raw)
+      pre_args(flags, files)
+      load_files files
+      run_command(args) if args.any? { |arg| run_command?(arg) }
+      post_args(flags)
 
       value ||= '' # Empty Start
 
@@ -379,11 +436,7 @@ module GreenHat
           next
         end
 
-        if line =~ /^exit/i
-          Settings.cmd_write
-
-          break
-        end
+        break if line =~ /^exit/i
 
         Settings.cmd_add(line) unless line.blank?
 
@@ -391,18 +444,36 @@ module GreenHat
         run
       end
     end
-    # rubocop:enable Metrics/MethodLength
+
+    def self.run_command?(arg)
+      %i[command c].any? do |x|
+        arg[:field] == x
+      end
+    end
+
+    # Run and Exit Command Helper
+    def self.run_command(args)
+      args.each do |arg|
+        # Quick Validation
+        next unless run_command?(arg) && !arg.value.empty?
+
+        reader.line = ''
+        @list = Shellwords.split arg.value
+        run
+      end
+      exit 0
+    end
 
     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)
+      puts 'Loading Archives'.pastel(:blue) unless Cli.quiet
       files.uniq.each do |file|
         next unless File.exist?(file)
 
-        puts "- #{file}".colorize(:magenta)
+        puts "- #{file}".pastel(:magenta) unless Cli.quiet
         ArchiveLoader.load file
       end
     end