greenhat 0.2.0 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79572c7389cb4cd519007f185a7fc249a771c08fa1fcbde8645d99786db42736
-  data.tar.gz: 6904a95f759a1dc0e866733f0a6220c62b47f3985998f82e2efd4619fdabe390
+  metadata.gz: ac7b0e70e5a13dc6f8f88a4f12fec812e38e7d838537abe83b7d4dc2e8b43663
+  data.tar.gz: 84246bc31bd38af74e9f4f8d95f2f7ffa1ca33978dc0d0862ec0b50eaff20196
 SHA512:
-  metadata.gz: d44e38727ce532ddbdcf8cc9aad1f5d7ee26a113ee589489bb5f15a99e616d06f66d304dc1e7735a679a707ed99323a45184234779066ca9f1f2cdea3e1b87e9
-  data.tar.gz: 6fb959d970482e244bea30f39ccd7357ce442fbc886df0084f425c3540b662a86972889213273ed5e734cace0f6b2b710c356c5585f98f76ffc4763ce2c68b10
+  metadata.gz: ba104ea8d7b4e52babf8bdf27ea4f3dbdb9e92820589881bab639a01e8558c355389a0f10b3c17dbe5c7ac881f10364ad06ec0c973934f06d735f948bb57fbd3
+  data.tar.gz: a2013229826758ca61335f5cf8d58c3a4a4206e656dce084f90781c264e4930c5c3fd09b7475a43dd31819bc2562e85e5799de775cc5db9dfaa3f73c0228ac3a

data/lib/greenhat/accessors/disk.rb

@@ -48,30 +48,30 @@ module GreenHat
 
       # Headers
       output << [
-        'Mount'.ljust(pad_mount).colorize(:blue),
-        'Size'.ljust(pad_size).colorize(:magenta),
-        'Used'.ljust(pad_used).colorize(:cyan),
-        'Avail'.ljust(pad_avail).colorize(:white),
-        '% Use'.ljust(pad_avail).colorize(:green)
+        '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).colorize(:green),
-          '  ['.colorize(:blue),
-          ('=' * (disk.use.to_i / 2)).colorize(:green),
+          disk.use.rjust(5).ljust(5).pastel(:green),
+          '  ['.pastel(:blue),
+          ('=' * (disk.use.to_i / 2)).pastel(:green),
           ' ' * (50 - disk.use.to_i / 2),
-          ']'.colorize(:blue)
+          ']'.pastel(:blue)
         ].join
 
         # Whole Thing
         output << [
-          disk.mounted_on.ljust(pad_mount).colorize(:blue),
-          disk[:size].to_s.ljust(pad_size).colorize(:magenta),
-          disk.used.to_s.ljust(pad_used).colorize(:cyan),
-          disk.avail.to_s.ljust(pad_avail).colorize(:white),
+          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

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

@@ -9,5 +9,9 @@ module GreenHat
 
       things
     end
+
+    def self.things
+      Thing.where(name: 'ps')
+    end
   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
+
+      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
 
@@ -387,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
 

data/lib/greenhat/settings.rb

@@ -5,14 +5,25 @@ module GreenHat
     def self.settings
       @settings ||= {
         history: [],
+        assume_json: true,
+        fuzzy_file_match: true,
 
         # round: [2],
         # page: [:true] Automatic,
-        truncate: [TTY::Screen.width * 4]
-
+        truncate: TTY::Screen.width * 4,
+        color: true
       }
     end
 
+    def self.assume_json?
+      settings.assume_json
+    end
+
+    # Allow for future disabling of color output
+    def self.color?
+      settings.color
+    end
+
     # Load User Settings and drop them into settings
     def self.settings_load
       return true unless File.exist?(settings_file)
@@ -26,12 +37,21 @@ module GreenHat
       "#{dir}/settings.json"
     end
 
-    # Set any Log Arguments that weren't set otherwise
-    def self.default_log_args(args, skip_args)
-      args[:round] ||= settings.round unless skip_args.include?(:round)
-      args[:page] ||= settings.page unless skip_args.include?(:page)
-      args[:truncate] ||= settings.truncate unless skip_args.include?(:truncate)
+    # Set any Log Arguments that weren't set otherwise | Conditional assign applied on bool
+    # rubocop:disable Style/GuardClause
+    def self.default_log_flags(flags, skip_flags)
+      flags[:round] = settings.round if !(skip_flags.include?(:round) || flags.key?(:round)) && settings.round
+
+      flags[:page] = settings.page if !(skip_flags.include?(:page) || flags.key?(:page)) && settings.page
+
+      flags[:truncate] = settings.truncate unless skip_flags.include?(:truncate) || flags.key?(:truncate)
+
+      # Fuzzy File Match
+      unless skip_flags.include?(:fuzzy_file_match) || flags.key?(:fuzzy_file_match)
+        flags[:fuzzy_file_match] = settings.fuzzy_file_match
+      end
     end
+    # rubocop:enable Style/GuardClause
 
     def self.start
       Dir.mkdir dir unless Dir.exist? dir