webwatchr 0.0.2

data/lib/webwatchr/base.rb

@@ -0,0 +1,119 @@
+require "fileutils"
+
+module Webwatchr
+  require_relative "alerting"
+  class Main
+    include Loggable
+
+    def initialize(&block)
+      @alerts = []
+      super()
+      setup_logs
+      run!
+      instance_eval(&block)
+      logger.info("Webwatcher finished working")
+    end
+
+    def running?
+      return (File.exist?(PARAMS[:pid_file]) and not PARAMS[:site])
+    end
+
+    def set(key, val)
+      PARAMS[key] = val
+      self
+    end
+
+    def setup_logs
+      FileUtils.mkdir_p(PARAMS[:log_dir])
+      log_out_file = if PARAMS[:verbose] || PARAMS[:test]
+                       $stdout
+                     else
+                       File.join(PARAMS[:log_dir], 'webwatchr.log')
+                     end
+      log_out_file_rotation = 'weekly'
+      log_level = $VERBOSE ? Logger::DEBUG : Logger::INFO
+
+      MyLog.instance.configure(log_out_file, log_out_file_rotation, log_level)
+    end
+
+    def init()
+      logger.debug("Starting WebWatchr")
+
+      FileUtils.mkdir_p(PARAMS[:last_dir])
+      FileUtils.mkdir_p(PARAMS[:cache_dir])
+
+      Dir[File.join(__dir__, '..', 'sites', '*.rb')].sort.each do |site_path|
+        logger.debug("Loading #{site_path}")
+        require site_path
+      end
+    end
+
+    def update(site_class, &block)
+      if (PARAMS[:mode] == :single) && site_class.to_s != PARAMS[:site]
+        logger.info("Running in single site mode, skipping #{site_class} (!= #{PARAMS[:site]})")
+        return
+      end
+
+      site = site_class.create(&block)
+
+      site.alerters = @alerts
+
+      logger.info "Running #{site.name}"
+      if block
+        site.instance_eval(&block)
+      end
+      Timeout.timeout(PARAMS[:site_timeout]) {
+        site.update(test: PARAMS[:test], cache_dir: PARAMS[:cache_dir], last_dir: PARAMS[:last_dir])
+      }
+    rescue Net::OpenTimeout, Errno::ENETUNREACH, Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Zlib::BufError, Errno::ECONNREFUSED, SocketError, Net::ReadTimeout => e
+      logger.warn "Failed pulling #{site}: #{e.message}"
+      # Do nothing, try later
+    rescue SystemExit => e
+      msg = "User requested we quit while updating #{site}\n"
+      logger.error msg
+      warn msg
+      raise e
+    rescue StandardError => e
+      msg = "Issue with #{site_class} : #{e}\n"
+      msg += "#{e.message}\n"
+      logger.error msg
+      msg += e.backtrace.join("\n")
+      logger.debug e.backtrace.join("\n")
+      warn msg
+    end
+
+    def run!
+      if running?
+        logger.info "Already running. Quitting"
+        exit
+      end
+
+      begin
+        File.open(PARAMS[:pid_file], 'w+') { |f|
+          f.puts($$)
+          init()
+        }
+      ensure
+        if File.exist?(PARAMS[:pid_file])
+          FileUtils.rm PARAMS[:pid_file]
+        end
+      end
+    end
+
+    def add_default_alert(type, &block)
+      case type
+      when :email
+        alert = Alerting::EmailAlert.create(&block)
+        @alerts.append(alert)
+      when :telegram
+        alert = Alerting::TelegramAlert.create(&block)
+        @alerts.append(alert)
+      when :stdout
+        alert = Alerting::StdoutAlert.create()
+        @alerts.append(alert)
+      else
+        raise StandardError, "Unknown alert type: #{type}."
+      end
+    end
+  end
+end

data/lib/webwatchr/logger.rb

@@ -0,0 +1,31 @@
+require 'logger'
+require 'singleton'
+
+class MyLog
+  include Singleton
+
+  def initialize
+    @many_loggers = {}
+    @default_level = Logger::DEBUG
+    @default_out = $stdout
+  end
+
+  def logger(class_name)
+    unless @many_loggers[class_name]
+      @many_loggers[class_name] = Logger.new(@default_out, @default_rotation, level: @default_level, progname: class_name)
+    end
+    return @many_loggers[class_name]
+  end
+
+  def configure(out, rotation, level)
+    @default_out = out
+    @default_rotation = rotation
+    @default_level = level
+  end
+end
+
+module Loggable
+  def logger
+    MyLog.instance.logger(self.class.name)
+  end
+end

data/lib/webwatchr/main.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/ruby
+
+require "optparse"
+
+require_relative "logger"
+
+$: << "./lib/" # for telegram to load
+
+trap("INT") do
+  warn "User interrupted"
+  exit
+end
+
+module Webwatchr
+  include Loggable
+
+  PARAMS = { mode: :normal, test: false } # rubocop:disable Style/MutableConstant
+
+  if ARGV.any?
+    OptionParser.new { |o|
+      o.banner = "WebWatchr is a script to poll websites and alert on changes.
+  Exemple uses:
+   * Updates all webpages according to their 'wait' value, and compare against internal state, and update it.
+      ruby #{__FILE__}
+   * Updates sites-available/site.rb, ignoring 'wait' value, and compare against internal state, and update it.
+      ruby #{__FILE__} -s site.rb
+
+  Usage: ruby #{__FILE__} "
+      o.on("-sSITE", "--site=SITE", "Run WebWatcher on one site only. It has to be the name of the class for that site.") do |val|
+        PARAMS[:site] = val
+        PARAMS[:mode] = :single
+      end
+      o.on("-v", "--verbose", "Be verbose (output to STDOUT instead of logfile") do
+        PARAMS[:verbose] = true
+      end
+      o.on("-t", "--test", "Check website and return what we've parsed") do
+        PARAMS[:test] = true
+      end
+      o.on("-h", "--help", "Prints this help") {
+        puts o
+        exit
+      }
+    }.parse!()
+  end
+
+  PARAMS[:cache_dir] = File.join(__dir__, "..", "..", ".cache")
+  PARAMS[:last_dir] = File.join(__dir__, "..", "..", ".lasts")
+  PARAMS[:log_dir] = File.join(__dir__, "..", "..", "logs")
+  PARAMS[:pid_file] = File.join(__dir__, "..", "..", "webwatchr.pid")
+  require "webwatchr/base"
+end