log2mail 0.0.1.pre2

data/lib/log2mail/config.rb

@@ -0,0 +1,216 @@
+module Log2mail
+  class Config
+
+    class <<self
+      def parse_config(config_path)
+        Log2mail::Config.new(config_path)
+        # pp config.config
+        # config.files.each do |f|
+        #   puts "File: #{f}"
+        #   config.patterns_for_file(f).each do |pattern|
+        #     puts "  Pattern: #{pattern}; mailto: " + config.mailtos_for_pattern( f, pattern ).join(', ')
+        #   end
+        # end
+      end
+    end
+
+    # attr_reader :config
+
+    INT_OPTIONS = [:sendtime, :resendtime, :maxlines]
+    STR_OPTIONS = [:fromaddr, :sendmail]
+    PATH_OPTIONS = [:template]
+
+    def initialize(config_paths)
+      $logger.debug "Reading configuration from #{config_paths}"
+      @config_paths = Array(config_paths)
+      expand_paths
+      read_configuration
+      validate_configuration
+    end
+
+    # returns all the paths of all files needed to be watched
+    def files
+      @config.keys - [:defaults]
+    end
+
+    def file_patterns
+      h = {}
+      files.each do |file|
+        h[file] = patterns_for_file(file)
+      end
+      h
+    end
+
+    def patterns_for_file( file )
+      Hash(@config[file][:patterns]).keys + \
+      Hash(defaults[:patterns]).keys
+    end
+
+    def mailtos_for_pattern( file, pattern )
+      m = []
+      m.concat Hash( config_file_pattern(file, pattern)[:mailtos] ).keys
+      m.concat Hash(Hash(Hash(defaults[:patterns])[pattern])[:mailtos]).keys
+      m.concat Array(defaults[:mailtos]) if m.empty?
+      m.uniq
+    end
+
+    def settings_for_mailto( file, pattern, mailto )
+      h = defaults.reject {|k,v| k==:mailtos}
+      h.merge config_file_mailto(file, pattern, mailto)
+    end
+
+    def defaults
+      Hash(@config[:defaults])
+    end
+
+    def formatted( show_effective )
+      Terminal::Table.new do |t|
+        settings_header = show_effective ? 'Effective Settings' : 'Settings'
+        t << ['File', 'Pattern', 'Recipient', settings_header]
+        t << :separator
+        files.each do |file|
+          patterns_for_file(file).each do |pattern|
+            mailtos_for_pattern(file, pattern).each do |mailto|
+              settings = []
+              if show_effective
+                settings_for_mailto(file, pattern, mailto).each_pair \
+                  { |k,v| settings << '%s=%s' % [k,v] }
+              else
+                config_file_mailto(file, pattern, mailto).each_pair \
+                  { |k,v| settings << '%s=%s' % [k,v] }
+              end
+              t.add_row [file, pattern, mailto, settings.join($/)]
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def config_file(file)
+      Hash(@config[file])
+    end
+
+    def config_file_pattern(file, pattern)
+      Hash( Hash( config_file(file)[:patterns] )[pattern] )
+    end
+
+    def config_file_mailtos(file, pattern)
+      Hash( config_file_pattern(file, pattern)[:mailtos] )
+    end
+
+    def config_file_mailto(file, pattern, mailto)
+      Hash( config_file_mailtos(file, pattern)[mailto] )
+    end
+
+    def expand_paths
+      expanded_paths = []
+      @config_paths.each do |path|
+        if ::File.directory?(path)
+          expanded_paths.concat Dir.glob( ::File.join( path, '*[^~#]' ) )
+        else
+          expanded_paths << path
+        end
+      end
+      @config_paths = expanded_paths
+    end
+
+    # tries to follow original code at https://github.com/lordlamer/log2mail/blob/master/config.cc#L192
+    def read_configuration
+      @config = {}
+      @config_paths.each do |file|
+        @section = nil; @pattern = nil; @mailto = nil
+        # section, pattern, mailto are reset for every file (but not when included by 'include')
+        parse_file( file )
+      end
+    end
+
+    def parse_file( filename )
+      IO.readlines(filename).each_with_index do |line, lineno|
+        parse(filename, line, lineno + 1)
+      end
+    rescue Errno::ENOENT
+      fail Error, "Configuration file or directory not found (or not readable): #{filename}"
+    end
+
+    def parse(file, line, lineno)
+      line.strip!
+      return if line =~ /^#/
+      return if line =~ /^$/
+      line =~ /^(\S+)\s*=?\s*"?(.*?)"?(\s*#.*)?$/  # drop double quotes on right hand side; drop comments
+      key, value = $1.to_sym, $2.strip
+      if key == :include # include shall work everywhere
+        parse_file( ::File.join(Pathname(file).parent, value) )
+        return
+      end
+      if key == :defaults and value.empty?  # section: specifies top level; must be 'defaults' or 'file'
+        @section = key
+        @pattern = nil; @mailto = nil
+        fail Error, "Invalid section. Section 'defaults' already specified." if @config[@section]
+        @config[@section] = {}
+      elsif key == :file
+        @section = value
+        @pattern = nil; @mailto = nil
+        @config[@section] ||= {}
+      elsif key == :pattern # must come inside 'file' (or 'defaults')
+        # fail "Invalid section. All statements must appear after 'defaults' or 'file=...'" unless @section
+        @pattern = value; @mailto = nil
+        @config[@section][:patterns] ||= {}
+        warning { "Redefining pattern section '#{value}' which has been defined already for '#{@section}'." } \
+          if @config[@section][:patterns][value]
+        @config[@section][:patterns][value] = {}
+      elsif key == :mailto and @section != :defaults # must come inside 'pattern' (or 'defaults')
+        fail Error, "'mailto' statements only allowed inside 'pattern' or 'defaults'." unless @pattern
+        @mailto = value
+        @config[@section][:patterns][@pattern][:mailtos] ||= {}
+        warning { "Redefining mailto section '#{value}' which has been defined already for '#{@section}'." } \
+          if @config[@section][:patterns][@pattern][:mailtos][value]
+        @config[@section][:patterns][@pattern][:mailtos][value] = {}
+      else # everything else must come inside 'defaults' or 'mailto'
+        fail Error, "'#{key}' must be set within 'defaults' or 'mailto'." unless @section == :defaults or @mailto
+        if INT_OPTIONS.include?(key)
+          value = value.to_i
+        elsif STR_OPTIONS.include?(key)
+        elsif PATH_OPTIONS.include?(key)
+          value = ::File.expand_path( value, Pathname(file).parent ) unless Pathname(value).absolute?
+        elsif key == :mailto # special handling for 'mailto' in 'defaults' section
+          @config[:defaults][:mailtos] ||= []
+          @config[:defaults][:mailtos] << value
+          return # skip the 'mailto' entry itself
+        else
+          fail Error, "'#{key}' is an unknown configuration statement."
+        end
+        if @section == :defaults and !@pattern and !@mailto
+          warning { "Redefining value for '#{key}'." } if @config[@section][key]
+          @config[@section][key] = value
+        else
+          warning { "Redefining value for '#{key}'." } \
+            if @config[@section][:patterns][@pattern][:mailtos][@mailto][key]
+          @config[@section][:patterns][@pattern][:mailtos][@mailto][key] = value
+        end
+      end
+    rescue
+      fail Error, "#{file} (line #{lineno}): #{$!.message}#$/[#{$!.class} at #{$!.backtrace.first}]"
+    end
+
+    def validate_configuration
+      files.each do |file|
+        patterns_for_file(file).each do |pattern|
+          mailtos = mailtos_for_pattern(file, pattern)
+          $logger.warn "Pattern #{file}:#{pattern} has no recipients." if mailtos.empty?
+        end
+      end
+      # FIXME: empty configuration should cause FATAL error
+      # TODO: illegal regexp pattern should cause ERROR
+    end
+
+    def warning(&block)
+      file = block.binding.eval('file')
+      lineno = block.binding.eval('lineno')
+      message = block.call
+      $logger.warn "#{file} (line #{lineno}): #{message}#$/[at #{caller.first}]"
+    end
+
+  end
+end

data/lib/log2mail/console/commands.rb

@@ -0,0 +1,56 @@
+module Log2mail
+
+  module Console::Commands
+
+    class <<self
+
+      def desc(description)
+        @desc = description
+      end
+
+      def method_added(meth)
+        @@meths ||= []
+        meth = meth.to_s
+        @@meths << [meth.gsub('_', ' '), @desc] if @desc
+        # puts "Added method #{meth}. Desc: #{@desc.inspect}."
+        # puts @@meths.inspect
+        # meth
+        # super
+      end
+
+    end
+
+    protected
+
+    def commands
+      @@meths.map { |m| m.first.gsub(' ', '_') }
+    end
+
+    public
+
+    desc "show list of available commands"
+    def help
+      @command_table ||= Terminal::Table.new :headings => ['command','description'], :rows => @@meths.sort
+      puts @command_table
+      true
+    end
+
+    desc "end console session"
+    def quit; end
+    def exit; end
+
+    desc "show configuration"
+    def config
+      config_path = ask('configuration path? ').chomp
+      config = Log2mail::Config.parse_config config_path
+      puts "Defaults:"
+      puts config.defaults
+      puts "Settings:"
+      puts config.formatted(false)
+      puts "Effective settings:"
+      puts config.formatted(true)
+    end
+
+  end
+
+end

data/lib/log2mail/console/logger.rb

@@ -0,0 +1,23 @@
+module Log2mail
+
+  module Console::Logger
+
+    def info(msg)
+      puts msg
+    end
+
+    def fatal(msg)
+      puts "FATAL: " + msg
+    end
+
+    def warn(msg)
+      puts "WARNING: " + msg
+    end
+
+    def debug(msg)
+      puts "DEBUG: " + msg
+    end
+
+  end
+
+end

data/lib/log2mail/console.rb

@@ -0,0 +1,35 @@
+class Log2mail::Console
+
+  require_relative 'console/logger'
+  require_relative 'console/commands'
+  include Log2mail::Console::Commands
+  require 'highline/import'
+
+  def run
+
+    # PFUSCH!!!
+    # Log2mail::Config.extend Log2mail::Console::Logger
+    # Log2mail::Config.include Log2mail::Console::Logger
+
+    loop do
+      input = ask('log2mail.rb % ').chomp
+      # command, *params = input.split /\s/
+      command = input
+      next if command.empty?
+      command.gsub!(' ', '_')
+      (quit; return) if ['quit', 'exit'].include?(command)
+      if self.commands.include?(command)
+        send(command)
+      else
+        puts "Unknown command. Use 'help' for more information."
+      end
+    end
+  rescue EOFError
+    quit; return
+  end
+
+  def quit
+    puts "quitting..."
+  end
+
+end

data/lib/log2mail/error.rb

@@ -0,0 +1,5 @@
+module Log2mail
+
+  class Error < RuntimeError; end
+
+end

data/lib/log2mail/file/parser.rb

@@ -0,0 +1,49 @@
+module Log2mail
+
+  module File::Parser
+
+    def parse(multiline_text)
+      return [] unless multiline_text
+      empty_buf! unless @buf
+      # add new text to parse buffer
+      @buf = @buf << multiline_text
+      hits = []
+      @patterns.each do |pattern|
+        matches = []
+        if pattern.from_string?
+          matches.concat @buf.lines.find_all{ |line| line.match(pattern) }
+          matches.map!(&:chomp)
+        else
+          matches.concat @buf.gsub(pattern).collect.to_a
+        end
+        hits.concat matches.map { |match| Hit.new( match, pattern, @path ) }
+      end
+      unless hits.empty?
+        log 'pattern match: ' + hits.inspect
+        empty_buf! # match -> clear buffer
+      else
+        cleanup_buf! # no match -> just keep what's necessary
+      end
+      hits
+    end
+
+    # ---------------------
+    # - Buffer management -
+    # ---------------------
+
+    def empty_buf!
+      @buf = ''
+    end
+
+    def cleanup_buf!
+      # FIXME: cleanup should clean up to latest match only OR upto last line (if from_string true)
+      if @patterns.all? {|p| p.from_string? }
+        empty_buf!
+      else
+        @buf = @buf.byteslice(-@maxbufsize/32,@maxbufsize) if @buf.bytesize > @maxbufsize
+      end
+    end
+
+  end
+
+end

data/lib/log2mail/file.rb

@@ -0,0 +1,95 @@
+
+module Log2mail
+
+  class File
+
+    require_relative 'file/parser'
+    include Parser
+
+
+    # FIXME: redundant
+    def log(msg, sev = ::Logger::DEBUG)
+      $logger.log sev, '%s: %s%s  [%s]' % [@path, msg, $/, caller.first]
+    end
+
+    def warn(msg)
+      log(msg, ::Logger::WARN)
+    end
+
+    attr_reader :path, :patterns
+
+    def initialize( path, patterns, maxbufsize = 65536 )
+      @path = path
+      self.patterns = patterns
+      @maxbufsize = maxbufsize
+      log "Maximum buffer size: #{@maxbufsize}"
+      log "Patterns: #{patterns.inspect}"
+    end
+
+    def patterns=(patterns)
+      @patterns = patterns.map(&:to_r)
+    end
+
+    # ----------------------------
+    # - File management (public) -
+    # ----------------------------
+
+    def open
+      @f = ::File.open(@path, 'r', :encoding => "BINARY")
+      log "file opened"
+      @ino = @f.stat.ino
+      @size = 0
+      @f
+    rescue Errno::ENOENT
+      warn "does not exist"
+      false
+    end
+
+    def seek_to_end
+      @f.seek(0, IO::SEEK_END)
+      @size = @f.stat.size
+      @f
+    end
+
+    def read_to_end
+      return unless @f
+      s = @f.gets(nil)
+      @size += s.length
+      s
+    end
+
+    def eof?
+      !@f or @f.eof?
+    end
+
+    def rotated?
+      if inum_changed?
+        log "inode number changed"
+        true
+      elsif file_size_changed?
+        log "file size changed; probably truncated"
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    # -------------------
+    # - File management -
+    # -------------------
+
+    def inum_changed?
+      ::File.stat(@path).ino != @ino
+    rescue Errno::ENOENT
+      true
+    end
+
+    def file_size_changed?
+      @f.stat.size != @size
+    end
+
+  end
+
+end

data/lib/log2mail/hit.rb

@@ -0,0 +1,13 @@
+module Log2mail
+  class Hit
+
+    attr_reader :matched_text, :pattern, :file
+
+    def initialize( text, pattern, file )
+      @matched_text = text
+      @pattern      = pattern
+      @file         = file
+    end
+
+  end
+end

data/lib/log2mail/logger_formatter.rb

@@ -0,0 +1,30 @@
+# provides a formatter to be used on TTY
+module Log2mail::LoggerFormatter
+
+  class <<self
+
+    LEVELS = ["DEBUG", "INFO", "WARN", "ERROR", "FATAL", "UNKNOWN"]
+
+    # http://blog.bigbinary.com/2014/03/03/logger-formatting-in-rails.html
+    def msg2str(msg)
+      case msg
+      when ::String
+        msg
+      when ::Exception
+        "#{ msg.message } (#{ msg.class })\n  [" <<
+        ( $verbose ? \
+           (msg.backtrace || []).join("#$/  ") : \
+           (msg.backtrace || []).first
+        ) << ']'
+      else
+        msg.inspect
+      end
+    end
+
+    def call(severity, datetime, progname, msg)
+      sev = severity.instance_of?(Fixnum) ? LEVELS[severity] : severity
+      '%s: %s' % [sev, msg2str(msg)] + $/
+    end
+  end
+
+end

data/lib/log2mail/main.rb

@@ -0,0 +1,148 @@
+Main {
+
+  CONFIG_DEFAULT = '/etc/log2mail/config'
+  PID_DEFAULT    = '/var/run/log2mail.rb.pid'
+  LOG_DEFAULT    = '/var/log/log2mail.rb'
+
+  version Log2mail::VERSION
+
+  ### daemonizes!  DOES NOT WORK CORRECTLY => implementing own forking
+  # daemonizes!
+
+  $logger = logger
+  logger_level Logger::INFO
+  logger.formatter = Log2mail::LoggerFormatter if logger.tty?
+
+  environment('LOG2MAIL_CONF') {
+    argument_required
+    defaults CONFIG_DEFAULT
+    description 'the configuration file or directory'
+    synopsis 'env LOG2MAIL_CONF=config_path'
+  }
+  option('config', 'c') {
+    argument_required
+    defaults CONFIG_DEFAULT
+    # synopsis '--config=config_path, -c'
+    description 'path of configuration file or directory'
+  }
+  # option('pidfile', 'p') {
+  #   description 'path of PID file'
+  # }
+  option('verbose', 'v')
+
+  usage['MAN PAGE'] = "type 'gem man log2mail' for more information"
+
+  # usage['EXAMPLE USAGE'] = <<-EXAMPLES
+  #   env LOG2MAIL_CONF=/usr/local/etc/log2mail.conf #{$0} start
+  #     starts as daemon using configuration from '/usr/local/etc/log2mail.conf'
+  # EXAMPLES
+  #
+  # usage['CONFIGURATION FILE EXAMPLE'] = <<-EXAMPLES
+  #   defaults
+  #     mailto = your@mail.address
+  #   file = /var/log/mail.log
+  #     pattern = status=bounced       # report bounced mail
+  #   file = /var/log/syslog
+  #     pattern = /(warning|error)/i   # report warnings and errors from syslog
+  # EXAMPLES
+
+  def after_parse_parameters
+    if params['verbose'].given?
+      logger.level = Logger::DEBUG
+      $verbose = true
+    else
+      logger.level = logger_level
+    end
+    @config_path = params['config'].given? ? params['config'].value : params['LOG2MAIL_CONF'].value
+    @config_path ||= CONFIG_DEFAULT
+  end
+
+  # returns the pid(s) of the daemon
+  def daemon_pids
+    prog_name = Log2mail::PROGNAME
+    own_pid = Process.pid
+    # FIXME: finding daemon pids by using pgrep is NOT 'optimal' :-)
+    `pgrep -f #{prog_name}`.split.map(&:to_i) - [own_pid]
+  end
+
+  def daemon_running?
+    !daemon_pids.empty?
+  end
+
+  mode 'start' do
+    # option('daemonize', '-D') { description 'daemonize into background'}
+    option('nofork', '-N') { description 'no daemonizing, stay in foreground'}
+    option('sleeptime') {
+      argument_required
+      description 'polling interval [seconds]'
+      cast :int
+      defaults 60
+    }
+    option('maxbufsize') { argument_required; cast :int; default 65536 }
+    def run
+      fail "Not starting. Daemon running." if daemon_running? and !params['nofork'].value
+      config = Log2mail::Config.parse_config @config_path
+      unless params['nofork'].value
+        Process.daemon
+        $PROGRAM_NAME = Log2mail::PROGNAME
+        $logger = Syslog::Logger.new(Log2mail::PROGNAME)
+        $logger.formatter = Log2mail::LoggerFormatter
+        def $logger.log(*a,&b)
+          add(*a,&b)
+        end
+        logger $logger
+        logger.info{'Deamon started.'}
+        trap(:INT) do
+          # for whatever reason, SIGINT is NOT LOGGED automatically like other signals (SIGTERM)
+          fatal "SIGINT"
+          exit(1)
+        end
+      end
+      Log2mail::Watcher.new(config, params['sleeptime'].value).run
+    end
+  end
+
+  mode 'stop' do
+    def run
+      if daemon_running?
+        daemon_pids.each do |pid|
+          info "Interrupting pid #{pid}..."
+          Process.kill(:INT, pid)
+        end
+      else
+        warn "No running daemon found."
+      end
+    rescue Errno::ENOENT
+      fail "Require 'pgrep' on path."
+    end
+  end
+
+  # TODO: add restart mode
+
+  mode 'status' do
+    def run
+      unless daemon_running?
+        warn "No running daemon found."
+        exit 1
+      else
+        info 'Daemon running. PID: %s' % daemon_pids.join(', ')
+      end
+    end
+  end
+
+  mode 'configtest' do
+    option('effective', 'e') { description 'show effective settings' }
+    def run
+      config = Log2mail::Config.parse_config @config_path
+      puts config.formatted(params['effective'].value)
+    end
+  end
+
+  mode 'console' do
+    def run
+      Log2mail::Console.new.run
+    end
+  end if Log2mail.const_defined?(:Console)
+
+  alias_method :run, :help!
+}