panda-motd 0.0.6 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: b5971befc8f39c5194983b38abb1918e56636c6a35a71e2dc42243983fd6a426
-  data.tar.gz: 7a4c4206471c1ad63dcb231e742d447d415c6ab13f6f1334073d218268a4d89a
+SHA1:
+  metadata.gz: 5e27df79cdab81d15c44ff575075e876eb975b44
+  data.tar.gz: 954bf7eb0ff70fd62b86918dfe1cbd95c84d56bb
 SHA512:
-  metadata.gz: 7d426d6dffe2c208109ad099e6fdb68891e59ae07f42c9cdb80de23f9041776862cf102c9d913441692ddb96ccb1d392084cc473629f387e8165a4c4581160f3
-  data.tar.gz: baf84a939e6a697b6af473b3bf76d216c2e957d15eb67221c07fad3b0f917ccc4698ab7d54e03ed2d00da65f01eadb1fa8098f5285992c074085e5ef2d7a60f5
+  metadata.gz: af66d7e99d7396984468e5824b1902b1e595aea9022a27c1c128df98416f386c89f23f1c5415aca4da26045af458e4b6e5b5844111a3488aabb1e15270d79351
+  data.tar.gz: 306ec97a05b35bfb2a0418018fbfc1b627c0e69007bef88ac7932b29bb319418637f416ec2c3903de1ddfcd44f29e6abe413944b153ec85fc04669177ffbd4fc

data/bin/panda-motd

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'panda_motd'
+require "panda_motd"
 
 motd = PandaMOTD.new_motd
 puts motd

data/lib/panda_motd.rb

@@ -1,12 +1,21 @@
-require 'require_all'
-require_rel 'panda_motd'
+# frozen_string_literal: true
+
+require "require_all"
+require_rel "panda_motd"
 
 class PandaMOTD
+  # Creates a new MOTD instance, assuming a config file has been passed as an
+  # argument to the command.
   def self.new_motd
     if ARGV[0].nil?
-      puts 'You must provide a config file path as an argument to panda-motd.'
+      puts "You must provide a config file path as an argument to panda-motd."
     else
-      return MOTD.new(ARGV[0])
+      MOTD.new(ARGV[0])
     end
   end
+
+  # Gets the root path of the gem.
+  def self.root
+    File.expand_path("..", __dir__)
+  end
 end

data/lib/panda_motd/component.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Component
+  attr_reader :name, :errors, :results, :config
+
+  def initialize(motd, name)
+    @name = name
+    @motd = motd
+    @config = motd.config.component_config(@name)
+    @errors = []
+  end
+
+  # Evaluates the component so that it has some meaningful output when it comes
+  # time to print the MOTD.
+  def process
+    raise NotImplementedError
+  end
+
+  # Gives the output of a component as a string.
+  def to_s
+    raise NotImplementedError
+  end
+
+  # The number of lines to print before the component in the context of the
+  # entire MOTD. 1 by default, if not configured.
+  def lines_before
+    @motd.config.component_config(@name)["lines_before"] || 1
+  end
+
+  # The number of lines to print after the component in the context of the
+  # entire MOTD. 1 by default, if not configured.
+  def lines_after
+    @motd.config.component_config(@name)["lines_after"] || 1
+  end
+end

data/lib/panda_motd/component_error.rb

@@ -1,4 +1,6 @@
-require 'colorize'
+# frozen_string_literal: true
+
+require "colorize"
 
 class ComponentError
   attr_reader :component, :message
@@ -8,6 +10,7 @@ class ComponentError
     @message = message
   end
 
+  # Gets a printable error string in red.
   def to_s
     return "#{@component.name} error: ".red + @message.to_s
   end

data/lib/panda_motd/components/ascii_text_art.rb

@@ -1,29 +1,23 @@
-require 'artii'
-require 'colorize'
+# frozen_string_literal: true
 
-class ASCIITextArt
-  attr_reader :name, :errors, :results
+require "artii"
+require "colorize"
 
+class ASCIITextArt < Component
   def initialize(motd)
-    @name = 'ascii_text_art'
-    @motd = motd
-    @config = motd.config.component_config(@name)
-    @errors = []
+    super(motd, "ascii_text_art")
   end
 
   def process
-    @text = `hostname`
-
-    begin
-      @art = Artii::Base.new font: @config['font']
-      @results = @art.asciify(@text)
-      @results = @results.send(@config['color'].to_sym) if @config['color']
-    rescue Errno::EISDIR # Artii doesn't handle invalid font names very well
-      @errors << ComponentError.new(self, 'Invalid font name')
-    end
+    @text = `#{@config["command"]}`
+    @art = Artii::Base.new font: @config["font"]
+    @results = @art.asciify(@text)
+    @results = @results.colorize(@config["color"].to_sym) if @config["color"]
+  rescue Errno::EISDIR # Artii doesn't handle invalid font names very well
+    @errors << ComponentError.new(self, "Invalid font name")
   end
 
   def to_s
-    return @results
+    @results
   end
 end

data/lib/panda_motd/components/fail_2_ban.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Fail2Ban < Component
+  def initialize(motd)
+    super(motd, "fail_2_ban")
+  end
+
+  def process
+    @results = {
+      jails: {},
+    }
+
+    @config["jails"].each do |jail|
+      status = jail_status(jail)
+      @results[:jails][jail] = {
+        total: status[:total],
+        current: status[:current],
+      }
+    end
+  end
+
+  def to_s
+    result = +"Fail2Ban:\n"
+    @results[:jails].each do |name, stats|
+      result << "  #{name}:\n"
+      result << "    Total bans:   #{stats[:total]}\n"
+      result << "    Current bans: #{stats[:current]}\n"
+    end
+
+    result.gsub!(/\s$/, "")
+  end
+
+  private
+
+  def jail_status(jail)
+    cmd_result = `fail2ban-client status #{jail}`
+    if cmd_result =~ /Sorry but the jail '#{jail}' does not exist/
+      @errors << ComponentError.new(self, "Invalid jail name '#{jail}'.")
+    else
+      total = cmd_result.match(/Total banned:\s+([0-9]+)/)[1].to_i
+      current = cmd_result.match(/Currently banned:\s+([0-9]+)/)[1].to_i
+    end
+
+    { total: total, current: current }
+  end
+end

data/lib/panda_motd/components/filesystems.rb

@@ -1,121 +1,137 @@
-require 'ruby-units'
-require 'colorize'
+# frozen_string_literal: true
 
-class Filesystems
-  attr_reader :name, :errors
-  attr_reader :results
+require "ruby-units"
+require "colorize"
 
+class Filesystems < Component
   def initialize(motd)
-    @name = 'filesystems'
-    @motd = motd
-    @config = motd.config.component_config(@name)
-    @errors = []
+    super(motd, "filesystems")
   end
 
   def process
-    @results = parse_filesystem_usage(@config['filesystems'])
+    @results = parse_filesystem_usage(@config["filesystems"])
   end
 
   def to_s
-    name_col_size = @results.select { |r| r.is_a? Hash }.map { |r| r[:pretty_name].length }.max
-    name_col_size = 0 if name_col_size.nil?
+    name_col_size = @results.select { |r| r.is_a? Hash }
+                            .map { |r| r[:pretty_name].length }
+                            .max || 0
 
-    name_col_size_with_padding = (name_col_size + 6) > 13 ? (name_col_size + 6) : 13
+    size_w_padding = (name_col_size + 6) > 13 ? (name_col_size + 6) : 13
 
-    result = 'Filesystems'.ljust(name_col_size_with_padding, ' ')
-    result += "Size  Used  Free  Use%\n"
+    result = +"Filesystems".ljust(size_w_padding, " ")
+    result << "Size  Used  Free  Use%\n"
 
     @results.each do |filesystem|
-      # handle filesystem not found
-      if filesystem.is_a? String
-        result += "  #{filesystem}\n"
-        next
-      end
-
-      result += "  #{filesystem[:pretty_name]}".ljust(name_col_size_with_padding, ' ')
-
-      [:size, :used, :avail].each do |metric|
-        units = if filesystem[metric] > 10**12
-                  'terabytes'
-                elsif filesystem[metric] > 10**9
-                  'gigabytes'
-                elsif filesystem[metric] > 10**6
-                  'megabytes'
-                elsif filesystem[metric] > 10**3
-                  'kilobytes'
-                else
-                  'bytes'
-                end
-
-        value = Unit.new("#{filesystem[metric]} bytes").convert_to(units)
-
-        # we have 4 characters of space to include the number, a potential decimal point, and
-        # the unit character at the end. if the whole number component is 3+ digits long then
-        # we omit the decimal point and just display the whole number component. if the whole
-        # number component is 2 digits long, we can't afford to use a decimal point, so we still
-        # only display the whole number component. if the whole number component is 1 digit long,
-        # we use the single whole number component digit, a decimal point, a single fractional
-        # digit, and the unit character.
-        whole_number_length = value.scalar.floor.to_s.length
-        round_amount = whole_number_length > 1 ? 0 : 1
-        formatted_value = value.scalar.round(round_amount).to_s + units[0].upcase
-        result += formatted_value.rjust(4, ' ') + '  '
-      end
-
-      percentage_used = ((filesystem[:used].to_f / filesystem[:size].to_f) * 100).round
-      result += (percentage_used.to_s.rjust(3, ' ') + '%').send(percentage_color(percentage_used))
-
-      result += "\n"
-
-      total_ticks = name_col_size_with_padding + 18
-      used_ticks = (total_ticks * (percentage_used.to_f / 100)).round
-
-      result += "  [#{('=' * used_ticks).send(percentage_color(percentage_used))}#{('=' * (total_ticks - used_ticks)).light_black}]"
-      result += "\n" unless filesystem == @results.last
+      result << format_filesystem(filesystem, size_w_padding)
     end
 
-    return result
+    result
   end
 
   private
 
-  def percentage_color(percentage)
-    return :green  if (0..75).cover?   percentage
-    return :yellow if (75..95).cover?  percentage
-    return :red    if (95..100).cover? percentage
-    return :white
+  def format_filesystem(filesystem, size)
+    return "  #{filesystem}\n" if filesystem.is_a? String # handle fs not found
+
+    # filesystem name
+    result = +""
+    result << "  #{filesystem[:pretty_name]}".ljust(size, " ")
+
+    # statistics (size, used, free, use%)
+    [:size, :used, :avail].each do |metric|
+      result << format_metric(filesystem, metric)
+    end
+
+    percent_used = calc_percent_used(filesystem)
+    result << format_percent_used(percent_used)
+    result << "\n"
+
+    # visual bar representation of use%
+    result << generate_usage_bar(filesystem, size, percent_used)
+
+    result
   end
 
-  def find_header_id_by_text(header_array, text)
-    return header_array.each_index.select { |i| header_array[i].downcase.include? text }.first
+  def generate_usage_bar(filesystem, size, percent_used)
+    result = +""
+    total_ticks = size + 18
+    used_ticks = (total_ticks * (percent_used.to_f / 100)).round
+    result << "  [#{("=" * used_ticks).send(pct_color(percent_used))}" \
+              "#{("=" * (total_ticks - used_ticks)).light_black}]"
+    result << "\n" unless filesystem == @results.last
+    result
   end
 
-  def parse_filesystem_usage(filesystems)
-    command_result = `BLOCKSIZE=1024 df`.split("\n")
-    header = command_result[0].split
-    entries = command_result[1..command_result.count]
-
-    name_index  = find_header_id_by_text(header, 'filesystem')
-    size_index  = find_header_id_by_text(header, 'blocks')
-    used_index  = find_header_id_by_text(header, 'used')
-    avail_index = find_header_id_by_text(header, 'avail')
-
-    results = filesystems.map do |filesystem, name|
-      matching_entry = entries.find { |e| e.split[name_index] == filesystem }
-
-      if matching_entry
-        {
-          pretty_name: name,
-          filesystem_name: matching_entry.split[name_index],
-          size: matching_entry.split[size_index].to_i * 1024,
-          used: matching_entry.split[used_index].to_i * 1024,
-          avail: matching_entry.split[avail_index].to_i * 1024
-        }
-      else
-        "#{filesystem} was not found"
-      end
+  def pct_color(percentage)
+    case percentage
+    when 0..75 then :green
+    when 76..95 then :yellow
+    when 96..100 then :red
+    else :white
     end
+  end
 
-    return results
+  def calc_percent_used(filesystem)
+    ((filesystem[:used].to_f / filesystem[:size].to_f) * 100).round
+  end
+
+  def format_percent_used(percent_used)
+    (percent_used.to_s.rjust(3, " ") + "%").send(pct_color(percent_used))
+  end
+
+  def calc_metric(value)
+    Unit.new("#{value} bytes").convert_to(calc_units(value))
+  end
+
+  def format_metric(filesystem, metric)
+    # we have 4 characters of space to include the number, a potential
+    # decimal point, and the unit character at the end. if the whole number
+    # component is 3+ digits long then we omit the decimal point and just
+    # display the whole number component. if the whole number component is
+    # 2 digits long, we can't afford to use a decimal point, so we still
+    # only display the whole number component. if the whole number
+    # component is 1 digit long, we use the single whole number component
+    # digit, a decimal point, a single fractional digit, and the unit
+    # character.
+
+    value = calc_metric(filesystem[metric])
+    whole_number_length = value.scalar.floor.to_s.length
+    round_amount = whole_number_length > 1 ? 0 : 1
+    formatted = value.scalar.round(round_amount).to_s + value.units[0].upcase
+
+    formatted.rjust(4, " ") + "  "
+  end
+
+  def calc_units(value)
+    if value > 10 ** 12
+      "terabytes"
+    elsif value > 10 ** 9
+      "gigabytes"
+    elsif value > 10 ** 6
+      "megabytes"
+    elsif value > 10 ** 3
+      "kilobytes"
+    else
+      "bytes"
+    end
+  end
+
+  def parse_filesystem_usage(filesystems)
+    entries = `BLOCKSIZE=1024 df --output=source,size,used,avail`.lines.drop(1)
+
+    filesystems.map do |filesystem, pretty_name|
+      matching_entry = entries.map(&:split).find { |e| e.first == filesystem }
+      next "#{filesystem} was not found" unless matching_entry
+
+      filesystem_name, size, used, avail = matching_entry
+      {
+        pretty_name: pretty_name,
+        filesystem_name: filesystem_name,
+        size: size.to_i * 1024,
+        used: used.to_i * 1024,
+        avail: avail.to_i * 1024,
+      }
+    end
   end
 end

data/lib/panda_motd/components/last_login.rb

@@ -1,70 +1,104 @@
-require 'date'
+# frozen_string_literal: true
 
-class LastLogin
-  attr_reader :name, :errors, :results
+require "date"
 
+class LastLogin < Component
   def initialize(motd)
-    @name = 'last_login'
-    @motd = motd
-    @config = motd.config.component_config(@name)
-    @errors = []
+    super(motd, "last_login")
   end
 
+  # @see Component#process
   def process
-    @users = @config['users']
-    @results = parse_last_logins(@users)
+    @users = @config["users"]
+    @results = parse_last_logins
   end
 
+  # @see Component#to_s
   def to_s
-    result = "Last Login:\n"
-
-    @results.each do |user, logins|
-      result += "  #{user}:\n"
-      location_string_size = logins.map { |l| l[:location].length }.max
-      logins.each do |login|
-        location_part = login[:location].ljust(location_string_size, ' ')
-        start_part = login[:time_start].strftime('%m/%d/%Y %I:%M%p')
-
-        end_part = if login[:time_end].is_a? String # still logged in text
-                     login[:time_end].green
-                   else
-                     "#{((login[:time_end] - login[:time_start]) * 24 * 60).to_i} minutes"
-                   end
+    <<~HEREDOC
+      Last Login:
+      #{@results.map { |u, l| parse_result(u, l) }.join("\n")}
+    HEREDOC
+  end
 
-        result += "    from #{location_part} at #{start_part} (#{end_part})\n"
-      end
-      result += '    no logins found for user.' if logins.empty?
-    end
+  private
 
-    return result
+  # Takes the list of processed results and generates a complete printable
+  # component string.
+  #
+  # @param user [String] the username to generate a string for
+  # @param logins [Array<Hash>] an array of hashes with username keys and hash
+  #   values containing the login data (see {#hashify_login})
+  #
+  # @return [String] the printable string for a single user
+  def parse_result(user, logins)
+    logins_part = if logins.empty?
+                    "    no logins found for user."
+                  else
+                    longest_size = logins.map { |l| l[:location].length }.max
+                    logins.map { |l| parse_login(l, longest_size) }.join("\n")
+                  end
+    <<~HEREDOC
+        #{user}:
+      #{logins_part}
+    HEREDOC
   end
 
-  private
+  # Takes login data and converts it to a heplful printable string.
+  #
+  # @param login [Hash] the login data, see {#hashify_login}
+  # @param longest_size [Integer] the longest string length to help with string
+  #   formatting
+  #
+  # @return [String] the formatted string for printing
+  def parse_login(login, longest_size)
+    location = login[:location].ljust(longest_size, " ")
+    start = login[:time_start].strftime("%m/%d/%Y %I:%M%p")
+    finish = if login[:time_end].is_a? String # not a date
+               if login[:time_end] == "still logged in"
+                 login[:time_end].green
+               else
+                 login[:time_end].yellow
+               end
+             else
+               "#{((login[:time_end] - login[:time_start]) / 60).to_i} minutes"
+             end
+    "    from #{location} at #{start} (#{finish})"
+  end
 
-  def parse_last_logins(users)
-    all_logins = {}
-    users.each_with_index do |(username, num_logins), i|
-      user_logins = []
+  # Takes a list of configured usernames and grabs login data from the system.
+  #
+  # @return [Hash{Symbol => Hash}] a hash with username keys and hash values
+  #   containing the login data (see {#hashify_login})
+  def parse_last_logins
+    @users.map do |(username, num_logins)|
       cmd_result = `last --time-format=iso #{username}`
-      cmd_result.split("\n").each do |entry|
-        next unless entry.start_with? username
-        data = entry.split(/(?:\s{2,})|(?:\s-\s)/)
+      logins = cmd_result.lines
+                         .select { |entry| entry.start_with?(username) }
+                         .take(num_logins)
 
-        time_end = data[4] == 'still logged in' ? data[4] : DateTime.parse(data[4])
-
-        user_logins << {
-          username: username,
-          location: data[2],
-          time_start: DateTime.parse(data[3]),
-          time_end: time_end
-        }
+      [username.to_sym, logins.map! { |l| hashify_login(l, username) }]
+    end.to_h
+  end
 
-        break if user_logins.count >= num_logins
-      end
+  # A hash representation of a single login.
+  #
+  # @param login [String] the raw string result from the call to the system
+  #   containing various bits of login information
+  # @param username [String] the username of the logged user
+  #
+  # @return [Hash] the parsed login entry data, with symbol keys
+  def hashify_login(login, username)
+    re = login.chomp.split(/(?:\s{2,})|(?<=\d)(?:\s-\s)/)
+    date = re[4].scan(/\d{4}-\d{2}-[\dT:]+-\d{4}/)
 
-      all_logins[username.to_sym] = user_logins
-    end
+    time_end = date.any? ? Time.parse(re[4]) : re[4]
 
-    return all_logins
+    {
+      username: username,             # string username
+      location: re[2],                # string login location, an IP address
+      time_start: Time.parse(re[3]),
+      time_end: time_end,             # Time or string, could be "still logged in"
+    }
   end
 end