greenhat 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79572c7389cb4cd519007f185a7fc249a771c08fa1fcbde8645d99786db42736
-  data.tar.gz: 6904a95f759a1dc0e866733f0a6220c62b47f3985998f82e2efd4619fdabe390
+  metadata.gz: efcb59b0a89d4abb6fbb20d17c96a163e53f3534a1df492bf8f82bd1ab108123
+  data.tar.gz: 630b4544301df24d0f3eadbf71dd61d3506d3bd273f1269e2c9b49687e5d6e49
 SHA512:
-  metadata.gz: d44e38727ce532ddbdcf8cc9aad1f5d7ee26a113ee589489bb5f15a99e616d06f66d304dc1e7735a679a707ed99323a45184234779066ca9f1f2cdea3e1b87e9
-  data.tar.gz: 6fb959d970482e244bea30f39ccd7357ce442fbc886df0084f425c3540b662a86972889213273ed5e734cace0f6b2b710c356c5585f98f76ffc4763ce2c68b10
+  metadata.gz: 504e6a2e265cb92f769e2b70978bf66cf5b758b78ace1f38b1f3e80e8ce33344672dbf5825ab97f0e46155084b36615f42a6d6e942e2d5a9536d8e9ace25c772
+  data.tar.gz: f9bb1c92bf6522bf74f8c5b643cd5c32249b8f1476745972805607b42bcbab394bbe44e7528e5edfe1774bb99a4fb53fa58c419993ed3403474ea528d292f5e2

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
@@ -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
 
-    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
 
@@ -387,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