panda-motd 0.0.6 → 0.0.12

data/lib/panda_motd/components/service_status.rb

@@ -1,68 +1,76 @@
-require 'colorize'
+# frozen_string_literal: true
 
-class ServiceStatus
-  attr_reader :name, :errors
-  attr_reader :results
+require "colorize"
 
+class ServiceStatus < Component
   def initialize(motd)
-    @name = 'service_status'
-    @motd = motd
-    @config = motd.config.component_config(@name)
-    @errors = []
+    super(motd, "service_status")
   end
 
+  # @see Component#process
   def process
-    @services = @config['services']
+    @services = @config["services"]
     @results = parse_services(@services)
   end
 
+  # Gets a printable string to be printed in the MOTD. If there are no services
+  # found in the result, it prints a warning message.
   def to_s
-    if @results.any?
-      result = "Services:\n"
-      longest_name_size = @results.keys.map { |k| k.to_s.length }.max + 1 # add 1 for the ':' at the end
-      @results.each_with_index do |(name, status), i|
-        name_part = (name.to_s + ':').ljust(longest_name_size, ' ')
-        status_part = status.to_s.send(service_colors[status])
-        result += "  #{name_part} #{status_part}"
-        result += "\n" unless i == @results.count - 1 # don't print newline for last entry
-      end
+    return "Services:\n  No matching services found." unless @results.any?
 
-      return result
-    else
-      return "Services:\n  No matching services found."
-    end
+    longest_name_size = @results.keys.map { |k| k.to_s.length }.max
+    result = <<~HEREDOC
+      Services:
+      #{@results.map do |(name, status)|
+      spaces = (" " * (longest_name_size - name.to_s.length + 1))
+      status_part = status.to_s.colorize(service_colors[status.to_sym])
+      "  #{name}#{spaces}#{status_part}"
+    end.join("\n")}
+    HEREDOC
+
+    result.gsub(/\s$/, "")
   end
 
   private
 
-  def parse_services(services)
-    results = {}
-
-    cmd_result = `systemctl | grep '\.service'`
-
+  # Runs a `systemd` command to determine the state of a service. If the state
+  # of the service was unable to be determined, an error will be added to the
+  # component.
+  #
+  # @param service [String] the name of the systemd service
+  #
+  # @return [String] the state of the systemd service
+  def parse_service(service)
+    cmd_result = `systemd is-active #{service[0]}`.strip
     if cmd_result.empty?
-      @errors << ComponentError.new(self, 'Unable to parse systemctl output')
-    end
-
-    cmd_result.split("\n").each do |line|
-      parsed_name = line.split[0].gsub('.service', '')
-      parsed_status = line.split[3]
-
-      matching_service = services.find { |service, _name| service == parsed_name }
-
-      if matching_service
-        results[parsed_name.to_sym] = parsed_status.to_sym
-      end
+      @errors << ComponentError.new(self, "systemctl output was blank.")
     end
+    cmd_result
+  end
 
-    return results
+  # Takes a list of services from a configuration file, and turns them into a
+  # hash with the service states as values.
+  #
+  # @param services [Array] a two-element array where the first element is the
+  #   name of the systemd service, and the second is the pretty name that
+  #   represents it.
+  #
+  # @return [Hash]
+  #   * `key`: The symbolized name of the systemd service
+  #   * `value`: The symbolized service state
+  def parse_services(services)
+    services.map { |s| [s[1].to_sym, parse_service(s).to_sym] }.to_h
   end
 
+  # A hash of mappings between a service state and a color which represents it.
+  # The hash has a default value of red in order to handle unexpected service
+  # status strings returned by `systemctl`.
   def service_colors
-    return {
-      running: :green,
-      exited: :white,
-      failed: :red
-    }
+    colors = Hash.new(:red)
+    colors[:active] = :green
+    colors[:inactive] = :yellow
+    colors[:failed] = :red
+
+    colors
   end
 end

data/lib/panda_motd/components/ssl_certificates.rb

@@ -1,85 +1,148 @@
-require 'date'
+# frozen_string_literal: true
 
-class SSLCertificates
-  attr_reader :name, :errors, :results
+require "date"
 
+class SSLCertificates < Component
   def initialize(motd)
-    @name = 'ssl_certificates'
-    @motd = motd
-    @config = motd.config.component_config(@name)
-    @errors = []
+    super(motd, "ssl_certificates")
   end
 
+  # @see Component#process
   def process
-    @certs = @config['certs']
+    @certs = @config["certs"]
     @results = cert_dates(@certs)
   end
 
+  # Prints the list of SSL certificates with their statuses. If a certificate
+  # is not found at the configured location, a message will be printed which
+  # explains this.
   def to_s
-    result = "SSL Certificates:\n"
-    longest_name_size = @results.map { |r| r[0].length }.max
+    <<~HEREDOC
+      SSL Certificates:
+      #{sorted_results.map do |cert|
+      return "  #{cert}" if cert.is_a? String # print the not found message
 
-    @results.each_with_index do |cert, i|
-      if cert.is_a? String # print the not found message
-        result += "  #{cert}"
-      else
-        name_portion = "  #{cert[0]}".ljust(longest_name_size + 6, ' ')
-
-        status = cert_status(cert[1])
+      parse_cert(cert)
+    end.join("\n")}
+    HEREDOC
+  end
 
-        date_portion = "#{cert_status_strings[status]} ".send(cert_status_colors[status]) + cert[1].strftime('%e %b %Y %H:%M:%S%p').to_s
-        result += name_portion + date_portion
-      end
+  private
 
-      result += "\n" unless i == @results.count - 1 # don't print newline for last entry
-    end
+  # Takes an entry from `@results` and formats it in a way that is conducive
+  # to being printed in the context of the MOTD.
+  #
+  # @param cert [Array] a two-element array in the same format as the return
+  #   value of {#parse_result}
+  def parse_cert(cert)
+    name_portion = cert[0].ljust(longest_cert_name_length + 6, " ")
+    status_sym = cert_status(cert[1])
+    status = cert_status_strings[status_sym].to_s
+    colorized_status = status.colorize(cert_status_colors[status_sym])
+    date_portion = cert[1].strftime("%e %b %Y %H:%M:%S%p")
+    "  #{name_portion} #{colorized_status} #{date_portion}"
+  end
 
-    return result
+  # Determines the length of the longest SSL certificate name for use in
+  # formatting the output of the component.
+  #
+  # @return [Integer] the length of the longest certificate name
+  def longest_cert_name_length
+    @results.map { |r| r[0].length }.max
   end
 
-  private
+  # Takes the results array and sorts it according to the configured sort
+  # method. If the option is not set or is set improperly, it will default to
+  # alphabetical.
+  def sorted_results
+    if @config["sort_method"] == "alphabetical"
+      @results.sort_by { |c| c[0] }
+    elsif @config["sort_method"] == "expiration"
+      @results.sort_by { |c| c[1] }
+    else # default to alphabetical
+      @results.sort_by { |c| c[0] }
+    end
+  end
 
+  # Takes a list of certificates and compiles a list of results for each
+  # certificate. If a certificate was not found, a notice will be returned
+  # instead.
+  #
+  # @return [Array] An array of parsed results. If there was an error, the
+  #   element will be just a string. If it was successful, the element will be
+  #   another two-element array in the same format as the return value of
+  #   {#parse_result}.
   def cert_dates(certs)
-    return certs.map do |name, path|
+    certs.map do |name, path|
       if File.exist?(path)
-        cmd_result = `openssl x509 -in #{path} -dates`
-        parsed = cmd_result.match(/notAfter=([\w\s:]+)\n/)
-        if parsed.nil?
-          @errors << ComponentError.new(self, 'Unable to find certificate expiration date')
-        else
-          begin
-            expiry_date = DateTime.parse(parsed[1])
-            [name, expiry_date]
-          rescue ArgumentError
-            @errors << ComponentError.new(self, 'Found expiration date, but unable to parse as date')
-          end
-        end
+        parse_result(name, path)
       else
         "Certificate #{name} not found at path: #{path}"
       end
+    end.compact # remove nil entries, will have nil if error ocurred
+  end
+
+  # Uses `openssl` to obtain and parse and expiration date for the certificate.
+  #
+  # @param name [String] the name of the SSL certificate
+  # @param path [String] the file path to the SSL certificate
+  #
+  # @return [Array] A pair where the first element is the configured name of
+  #   the SSL certificate, and the second element is the expiration date of
+  #   the certificate.
+  def parse_result(name, path)
+    cmd_result = `openssl x509 -in #{path} -dates`
+    # match indices: 1 - month, 2 - day, 3 - time, 4 - year, 5 - zone
+    exp = /notAfter=([A-Za-z]+) +(\d+) +([\d:]+) +(\d{4}) +([A-Za-z]+)\n/
+    parsed = cmd_result.match(exp)
+
+    if parsed.nil?
+      @errors << ComponentError.new(self, "Unable to find certificate " \
+                                          "expiration date")
+      nil
+    else
+      expiry_date = Time.parse([1, 2, 4, 3, 5].map { |n| parsed[n] }.join(" "))
+      [name, expiry_date]
     end
+  rescue ArgumentError
+    @errors << ComponentError.new(self, "Found expiration date, but unable " \
+                                        "to parse as date")
+    [name, Time.now]
   end
 
+  # Maps an expiration date to a symbol representing the expiration status of
+  # an SSL certificate.
+  #
+  # @param expiry_date [Time] the time at which the certificate expires
+  #
+  # @return [Symbol] A symbol representing the expiration status of the
+  #   certificate. Valid values are `:expiring`, `:expired`, and `:valid`.
   def cert_status(expiry_date)
-    status = :valid
-    status = :expiring if (DateTime.now...DateTime.now + 30).cover? expiry_date # ... range excludes end
-    status = :expired if DateTime.now >= expiry_date
-    return status
+    if (Time.now...Time.now + 30).cover? expiry_date # ... range excludes last
+      :expiring
+    elsif Time.now >= expiry_date
+      :expired
+    else
+      :valid
+    end
   end
 
+  # Maps a certificate expiration status to a color that represents it.
   def cert_status_colors
-    return {
+    {
       valid: :green,
       expiring: :yellow,
-      expired: :red
+      expired: :red,
     }
   end
 
+  # Maps a certificate expiration status to a string which can be prefixed to
+  # the expiration date, to aid in explaining when the certificate expires.
   def cert_status_strings
-    return {
-      valid: 'valid until',
-      expiring: 'expiring at',
-      expired: 'expired at'
+    {
+      valid: "valid until",
+      expiring: "expiring at",
+      expired: "expired at",
     }
   end
 end

data/lib/panda_motd/components/uptime.rb

@@ -1,30 +1,47 @@
-require 'sysinfo'
+# frozen_string_literal: true
 
-class Uptime
-  attr_reader :name, :errors
+require "sysinfo"
+
+class Uptime < Component
   attr_reader :days, :hours, :minutes
 
   def initialize(motd)
-    @name = 'uptime'
-    @motd = motd
-    @config = motd.config.component_config(@name)
-    @errors = []
+    super(motd, "uptime")
   end
 
+  # Calculates the number of days, hours, and minutes based on the current
+  # uptime value.
+  #
+  # @see Component#process
   def process
-    sysinfo = SysInfo.new
-    uptime = sysinfo.uptime
+    uptime = SysInfo.new.uptime
 
     @days = (uptime / 24).floor
     @hours = (uptime - @days * 24).floor
     @minutes = ((uptime - @days * 24 - hours) * 60).floor
   end
 
+  # Gets a printable uptime string with a prefix. The prefix can be configured,
+  # and defaults to "up".
   def to_s
-    result = ''
-    result += "#{@days} day#{'s' if @days != 1}, " unless @days.zero?
-    result += "#{@hours} hour#{'s' if @hours != 1}, " unless @hours.zero? && @days.zero?
-    result += "#{@minutes} minute#{'s' if @minutes != 1}"
-    return "#{@config['prefix'] || 'up'} #{result}"
+    "#{@config["prefix"] || "up"} #{format_uptime}"
+  end
+
+  private
+
+  # Formats the uptime values in such a way that it is easier to read. If any
+  # of the measurements are zero, that part is omitted. Words are properly
+  # pluralized.
+  #
+  # Examples:
+  #
+  # `3d 20h 55m` becomes `3 days, 20 hours, 55 minutes`
+  #
+  # `3d 0h 55m` becomes `3 days, 55 minutes`
+  def format_uptime
+    [@days, @hours, @minutes].zip(%w[day hour minute])
+                             .reject { |n, _word| n.zero? }
+                             .map { |n, word| "#{n} #{word}#{"s" if n != 1}" }
+                             .join(", ")
   end
 end

data/lib/panda_motd/config.rb

@@ -1,9 +1,15 @@
-require 'yaml'
-require 'fileutils'
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
 
 class Config
+  attr_reader :file_path
+
+  # @param file_path [String] The file path to look for the configuration file.
+  #   If not provided, the default file path will be used.
   def initialize(file_path = nil)
-    @file_path = file_path.nil? ? File.join(Dir.home, '.config', 'panda-motd.yaml') : file_path
+    @file_path = file_path || File.join(Dir.home, ".config", "panda-motd.yaml")
     unless File.exist?(@file_path)
       create_config(@file_path)
       puts "panda-motd created a default config file at: #{@file_path}"
@@ -11,37 +17,53 @@ class Config
     load_config(@file_path)
   end
 
+  # A list of enabled components' class constants.
   def components_enabled
-    # first iterate through the config hash and grab all names of enabled components
-    enabled_list = @config['components'].map { |component, setting| component if setting['enabled'] }.compact
+    # iterate config hash and grab names of enabled components
+    enabled = @config["components"].map { |c, s| c if s["enabled"] }.compact
     # get the class constant
-    return enabled_list.map { |e| component_classes[e.to_sym] }
+    enabled.map { |e| Config.component_classes[e.to_sym] }
   end
 
+  # Gets the configuration for a component.
+  #
+  # @param component_name [String] the name of the component to fetch the
+  #   configuration for
   def component_config(component_name)
-    return @config['components'][component_name.to_s]
+    @config["components"][component_name.to_s]
   end
 
-  private
-
-  def component_classes
-    return {
+  # The mapping of component string names to class constants.
+  def self.component_classes
+    {
       ascii_text_art: ASCIITextArt,
       service_status: ServiceStatus,
       uptime: Uptime,
       ssl_certificates: SSLCertificates,
       filesystems: Filesystems,
-      last_login: LastLogin
+      last_login: LastLogin,
+      fail_2_ban: Fail2Ban,
     }
   end
 
+  private
+
+  # Creates a configuration file at a given file path, from the default
+  # configuration file.
+  #
+  # @param file_path [String] the file path at which to create the config
   def create_config(file_path)
-    default_config_path = File.join(File.dirname(__dir__), 'panda_motd', 'default_config.yaml')
+    default_config_path = File.join(
+      File.dirname(__dir__), "panda_motd", "default_config.yaml"
+    )
     FileUtils.cp(default_config_path, file_path)
   end
 
+  # Loads a configuration file.
+  #
+  # @param file_path [String] the file path of the config to load
   def load_config(file_path)
     @config = YAML.safe_load(File.read(file_path))
-    @config['components'] = [] if @config['components'].nil?
+    @config["components"] = [] if @config["components"].nil?
   end
 end