greenhat 0.1.5 → 0.3.2

data/lib/greenhat/shell/process.rb

@@ -4,8 +4,63 @@ module GreenHat
     # Logs
     module Process
       # Easy Show All
-      def self.ps
-        ShellHelper.file_output GreenHat::Ps.ps
+      # Filter --archive
+
+      def self.ls
+        help
+      end
+
+      def self.help
+        puts "\u2500".pastel(:cyan) * 22
+        puts "#{'Process'.pastel(:yellow)} -  ps helper"
+        puts "\u2500".pastel(:cyan) * 22
+
+        ShellHelper.common_opts
+
+        puts 'Command Summary'.pastel(:blue)
+        puts '  ps'.pastel(:green)
+        puts '    Raw `ps`'
+        puts
+        puts '  filter'.pastel(:green)
+        puts "    Key/Field Filtering.  See #{'filter_help'.pastel(:blue)}"
+        puts '    Examples'
+        puts '      filter --sort=mem --reverse'.pastel(:green)
+        puts '      filter --user=gitlab'.pastel(:green)
+
+        puts
+      end
+
+      def self.filter_help
+        ShellHelper::Filter.help
+      end
+
+      def self.ps(raw = {})
+        # Extract Args
+        files_list, flags, _args = Args.parse(raw)
+
+        # Collect Files
+        files = ShellHelper.files(files_list, GreenHat::Ps.things, flags)
+
+        # Output
+        ShellHelper.file_output(files, flags)
+      end
+
+      def self.filter(raw = {})
+        # Argument Parsing
+        files, flags, args = Args.parse(raw)
+
+        # Prepare Log List
+        file_list = ShellHelper.prepare_list(files, GreenHat::Ps.things)
+
+        results = ShellHelper.filter_start(file_list, flags, args)
+
+        # Check Search Results
+        if results.instance_of?(Hash) && results.values.flatten.empty?
+          puts 'No results'.pastel(:red)
+        else
+          # This causes the key 'colorized' output to also be included
+          ShellHelper.show(results.to_a.compact.flatten, flags)
+        end
       end
     end
   end

data/lib/greenhat/shell/report.rb

@@ -2,11 +2,17 @@ module GreenHat
   # Root Level Shell / Report Helper
   module Shell
     def self.report(raw)
-      args = {
-        raw: raw.include?('--raw')
-      }
+      _files, flags, _args = Args.parse(raw)
 
-      ShellHelper.show(Archive.all.map(&:report).map(&:show).flatten, args)
+      archives = if flags.archive
+                   Archive.all.select do |archive|
+                     flags.archive.any? { |x| archive.name.include? x.to_s }
+                   end
+                 else
+                   Archive.all
+                 end
+
+      ShellHelper.show(archives.map(&:report).map(&:show).flatten, flags)
     end
   end
 end
@@ -19,7 +25,7 @@ module GreenHat
 
     attr_accessor :archive, :host, :os_release, :selinux_status, :cpu, :uname,
                   :timedatectl, :uptime, :meminfo, :gitlab_manifest, :gitlab_status,
-                  :production_log, :api_log, :application_log, :sidekiq_log, :free_m
+                  :production_log, :api_log, :application_log, :sidekiq_log, :free_m, :disk_free
 
     # Find Needed Files for Report
     # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
@@ -40,15 +46,16 @@ module GreenHat
       self.api_log = archive.things.find { |x| x.name == 'gitlab-rails/api_json.log' }
       self.application_log = archive.things.find { |x| x.name == 'gitlab-rails/application_json.log' }
       self.sidekiq_log = archive.things.find { |x| x.name == 'sidekiq/current' }
+      self.disk_free = archive.things.find { |x| x.name == 'df_h' }
     end
 
     def show
       output = [
-        archive.friendly_name.colorize(:blue)
+        archive.friendly_name.pastel(:blue)
       ]
 
       # OS
-      output << 'OS'.colorize(:light_yellow)
+      output << 'OS'.pastel(:bright_yellow)
       output << hostname if host
       output << distro if os_release
       output << selinux if selinux_status
@@ -61,14 +68,20 @@ module GreenHat
 
       # Memory
       if meminfo || free_m
-        output << 'Memory'.colorize(:light_yellow)
-        output << memory if meminfo
+        output << 'Memory'.pastel(:bright_yellow)
+        output << memory_perc if meminfo
         output << memory_free if free_m
         output << ''
       end
 
+      # Disk
+      if disk_free
+        output << disks
+        output << ''
+      end
+
       # Gitlab
-      output << 'GitLab'.colorize(:light_yellow) if gitlab_manifest
+      output << 'GitLab'.pastel(:bright_yellow) if gitlab_manifest
       output << gitlab_version if gitlab_manifest
       output << gitlab_services if gitlab_status
       output << title('Errors') if production_log || api_log || application_log || sidekiq_log
@@ -88,8 +101,8 @@ module GreenHat
       color = count.zero? ? :green : :red
 
       [
-        title('  Production', :light_red, 18),
-        count.to_s.colorize(color)
+        title('  Production', :bright_red, 18),
+        count.to_s.pastel(color)
       ].join
     end
 
@@ -98,8 +111,8 @@ module GreenHat
       color = count.zero? ? :green : :red
 
       [
-        title('  API', :light_red, 18),
-        count.to_s.colorize(color)
+        title('  API', :bright_red, 18),
+        count.to_s.pastel(color)
       ].join
     end
 
@@ -108,8 +121,8 @@ module GreenHat
       color = count.zero? ? :green : :red
 
       [
-        title('  Application', :light_red, 18),
-        count.to_s.colorize(color)
+        title('  Application', :bright_red, 18),
+        count.to_s.pastel(color)
       ].join
     end
 
@@ -118,32 +131,16 @@ module GreenHat
       color = count.zero? ? :green : :red
 
       [
-        title('  Sidekiq', :light_red, 18),
-        count.to_s.colorize(color)
+        title('  Sidekiq', :bright_red, 18),
+        count.to_s.pastel(color)
       ].join
     end
 
     def gitlab_services
-      list = gitlab_status.data.keys.sort.map do |service|
-        color = gitlab_status.data.dig(service, 0, :status) == 'run' ? :green : :red
-        service.colorize(color)
-      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
-
       [
         title('Services'),
         "\n   ",
-        table.render(:unicode, padding: [0, 1, 0, 1], indent: 3)
+        GitLab.services(archive, 3)
       ].join
     rescue StandardError => e
       LogBot.fatal('GitLab Services', message: e.message, backtrace: e.backtrace.first)
@@ -166,7 +163,7 @@ module GreenHat
     def distro
       [
         title('Distro'),
-        "[#{os_release.data.ID}] ".colorize(:light_black),
+        "[#{os_release.data.ID}] ".pastel(:bright_black),
         os_release.data.PRETTY_NAME
       ].join
     end
@@ -177,7 +174,7 @@ module GreenHat
 
       [
         title('SeLinux'),
-        status.colorize(status_color),
+        status.pastel(status_color),
         ' (',
         selinux_status.data['Current mode'],
         ')'
@@ -197,7 +194,7 @@ module GreenHat
       [
         title('Kernel'),
         value,
-        " (#{build})".colorize(:light_black)
+        " (#{build})".pastel(:bright_black)
       ].join
     end
 
@@ -209,6 +206,9 @@ module GreenHat
     end
 
     def sys_time
+      # Ignore if Empty
+      return false if timedatectl.data.nil?
+
       ntp_statuses = timedatectl.data.slice(*ntp_keys).values.compact
 
       enabled = %w[active yes] & ntp_statuses
@@ -221,9 +221,9 @@ module GreenHat
       [
         title('Sys Time'),
         timedatectl.data['Local time'],
-        ' (ntp: '.colorize(:light_black),
-        ntp_status.colorize(ntp_color),
-        ')'.colorize(:light_black)
+        ' (ntp: '.pastel(:bright_black),
+        ntp_status.pastel(ntp_color),
+        ')'.pastel(:bright_black)
       ].join
     end
 
@@ -248,38 +248,30 @@ module GreenHat
         [
           interval,
           ' (',
-          "#{value}%".colorize(color),
+          "#{value}%".pastel(color),
           ')'
         ].join
       end
 
       [
         title('LoadAvg'),
-        "[CPU #{cpu_count}] ".colorize(:light_white),
+        "[CPU #{cpu_count}] ".pastel(:bright_white),
         intervals_text.join(', ')
       ].join
     end
 
-    def memory
+    def memory_perc
       total = ShellHelper.human_size_to_number(meminfo.data['MemTotal'])
       free = ShellHelper.human_size_to_number(meminfo.data['MemFree'])
       used = percent((total - free), total)
+
       [
-        title('MemUsed'),
-        '['.colorize(:light_black),
-        '='.colorize(:green) * (used / 2),
+        title('Usage'),
+        '  ['.pastel(:bright_black),
+        '='.pastel(:green) * (used / 2),
         ' ' * (50 - used / 2),
-        ']'.colorize(:light_black),
-        " #{100 - percent(free, total)}%".colorize(:green), # Inverse
-        "\n",
-        title('Total'),
-        number_to_human_size(total).colorize(:light_white),
-        "\n",
-        title('Used'),
-        number_to_human_size(total - free),
-        "\n",
-        title('Free'),
-        number_to_human_size(free)
+        ']'.pastel(:bright_black),
+        " #{100 - percent(free, total)}%".pastel(:green) # Inverse
       ].join
     end
 
@@ -288,6 +280,8 @@ module GreenHat
 
       return unless free
 
+      formatted_mem = free_m.data.map { |x| GreenHat::Memory.memory_row x }
+
       [
         title('Total', :cyan, 14),
         number_to_human_size(free.total.to_i * 1024**2),
@@ -299,7 +293,23 @@ module GreenHat
         number_to_human_size(free.free.to_i * 1024**2),
         "\n",
         title('Available', :green, 14),
-        number_to_human_size(free.available.to_i * 1024**2)
+        number_to_human_size(free.available.to_i * 1024**2),
+        "\n\n",
+        formatted_mem.map { |x| x.prepend ' ' * 2 }.join("\n")
+      ].join
+    end
+
+    def disks
+      # GreenHat::Disk.df({archive: []})
+      file = GreenHat::Disk.df({ archive: [archive.name] })
+
+      disk_list = GreenHat::Disk.format_output(file.first, false, 3)
+
+      # Preapre / Indent List
+      [
+        'Disks'.pastel(:bright_yellow) + ' (Top % Usage)'.pastel(:bright_black),
+        "\n",
+        disk_list.each { |x| x.prepend(' ' * 4) }.join("\n")
       ].join
     end
 
@@ -312,7 +322,7 @@ module GreenHat
 
     # Helper to Make Cyan Titles
     def title(name, color = :cyan, ljust = 12)
-      "  #{name}:".ljust(ljust).colorize(color)
+      "  #{name}:".ljust(ljust).pastel(color)
     end
   end
   # rubocop:enable Metrics/ClassLength