greenhat 0.1.5 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6b9e87957f5dfc919379519552041ce83b8daa5923b0e89fc64424e050d8981
-  data.tar.gz: 412b2c4db6613c707c8aad3e39e41a3fb018d1834f5ef17000b11b3af582c639
+  metadata.gz: db336e98cd2a446c371d866d068eb9b485f9782b2ea7182f4b4da651011e2083
+  data.tar.gz: 90b1858171c14ebe93e3a0ff42dffe2965602835f8f2cc98178f6a81ec816352
 SHA512:
-  metadata.gz: da4b45b6433d2c4c786bca4b46dc0cfad9b879796e6040b9efceb5ba5181f329c7d3792aef458fde54698791f03830168aad17b9b7d31191aa2e717407444662
-  data.tar.gz: 3d53ed5c45398acc3a317cc41a5573b82ab1c263e947c94cc419f235efd5bc527905f4484867968535f12aed15c3fbb79abe1d63093402f845c572557b7e288d
+  metadata.gz: 94d78c52d3e4b800ac90798d8030dfa9962c7e7c628bd8b636f5471fcf2c35044aa044a91edbd412827db2daf36117ab47cfecc4c6a85e49875e3e6d7756e1d0
+  data.tar.gz: fad9f87be4735b5d028ccc7e251fce423de9cf0d440253b65dbaddbc36b268234ffedc7277f9207131692bcf8ea74cd9a4b70c433f55e158b6cd30aae73edf1d

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
@@ -63,7 +65,9 @@ module GreenHat
     # Auto Complete
     # =========================================================
     def self.auto
-      word = reader.line.word
+      word = @list.last
+      # This is being weird with auto complete
+      # word = reader.line.word
 
       if word.blank?
         help
@@ -72,6 +76,10 @@ module GreenHat
       end
     end
 
+    def self.file_matches(word)
+      files.select { |x| x[/^#{Regexp.escape(word)}/] }
+    end
+
     def self.auto_match(matches, word)
       matches.select! { |x| x[/^#{Regexp.escape(word)}/] }
 
@@ -84,13 +92,16 @@ 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
-        file_matches = files.select { |x| x[/^#{Regexp.escape(word)}/] }
-        auto_files(file_matches, word) unless file_matches.empty?
+      # General Filename Matching
+      elsif !file_matches(word).empty?
+        auto_files(file_matches(word), word)
 
+      # Submodule Autocompletion
+      elsif current_methods.include?('auto_complete')
+        update_text = current_location.auto_complete(@list, word)
+        auto_update(update_text, word) unless update_text.blank?
       end
     end
 
@@ -102,7 +113,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 +146,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 +163,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 +238,50 @@ 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
+
+    def self.current_commands
+      current_location.methods(false).map(&:to_s).sort - %w[auto_complete]
     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|
+        current_commands.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 +328,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 +343,100 @@ 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 '  greenhat  <sos-archive.tgz> -q --command=df'
+      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
 
-    def self.startup_arg_list
-      ['--load', '--l', '--quiet', '-q', '--report', '-r']
+      puts '  --command, -c'.pastel(:green)
+      puts '    Run and then exit a GreenHat Shell command'
+      puts
+
+      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 +450,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 +458,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

data/lib/greenhat/color.rb

@@ -0,0 +1,27 @@
+# Top level namespace
+module GreenHat
+  # Replace Colorize with Pastel Monkey Patch String Shim
+  # https://github.com/piotrmurach/pastel#features
+
+  # Looping in GreenHat to allow disabling of Color
+  module Color
+    def self.pastel
+      @pastel ||= Pastel.new
+    end
+
+    def self.decorate(args)
+      Settings.color? ? pastel.decorate(*args) : args.first
+    end
+  end
+end
+
+# Monkey Patch
+class String
+  def pastel(*args)
+    GreenHat::Color.decorate(args.unshift(self))
+  end
+
+  def unpastel
+    GreenHat::Color.pastel.strip self
+  end
+end

data/lib/greenhat/logbot.rb

@@ -6,11 +6,11 @@ module LogBot
   end
 
   def self.output(name, message, level, duration = nil)
-    time = Time.now.to_s.colorize(:light_black)
+    time = Time.now.to_s.pastel(:bright_black)
     output = time
     output += "  #{color_level(level)}"
-    output += " - #{name.to_s.colorize(:light_blue)} "
-    output += "(#{duration.round(2)}) ".colorize(:magenta) if duration
+    output += " - #{name.to_s.pastel(:bright_blue)} "
+    output += "(#{duration.round(2)}) ".pastel(:magenta) if duration
 
     output += ' '
     if message
@@ -21,21 +21,21 @@ module LogBot
                 end
     end
 
-    puts output unless ENV['TESTING']
+    puts output unless ENV['TESTING'] || GreenHat::Cli.quiet
   end
 
   def self.color_level(level)
     case level
     when :debug
-      level.to_s.upcase.colorize(:light_cyan)
+      level.to_s.upcase.pastel(:bright_cyan)
     when :info
-      level.to_s.upcase.colorize(:cyan)
+      level.to_s.upcase.pastel(:cyan)
     when :warn
-      level.to_s.upcase.colorize(:yellow)
+      level.to_s.upcase.pastel(:yellow)
     when :error
-      level.to_s.upcase.colorize(:light_red)
+      level.to_s.upcase.pastel(:bright_red)
     when :fatal
-      level.to_s.upcase.colorize(:red)
+      level.to_s.upcase.pastel(:red)
     end
   end