watch_list 0.1.0

data/lib/watch_list/dsl/converter.rb

@@ -0,0 +1,107 @@
+class WatchList::DSL::Converter
+  TYPE_ATTRS = [
+    :SubType,
+    :Port,
+    :KeywordType,
+    :KeywordValue,
+    :HTTPUsername,
+    :HTTPPassword,
+  ]
+
+  class << self
+    def convert(exported, opts = {})
+      self.new(exported, opts).convert
+    end
+  end # of class methods
+
+  def initialize(exported, options = {})
+    @exported = exported
+    @options = options
+  end
+
+  def convert
+    [
+      output_monitors(@exported[:monitors]),
+      output_alert_contacts(@exported[:alert_contacts]),
+    ].join("\n\n")
+  end
+
+  private
+
+  def output_monitors(monitors)
+    (monitors || []).map {|friendlyname, monitor|
+      output_monitor(monitor)
+    }.join("\n\n")
+  end
+
+  def output_monitor(monitor)
+    alert_contacts = monitor[:AlertContacts]
+    has_type_attr  = TYPE_ATTRS.any? {|i| monitor[i] }
+    monitor_type = WatchList::Monitor::Type.key(monitor[:Type]).to_sym
+    paused = (monitor[:Status] == UptimeRobot::Monitor::Status::Paused)
+
+    output {|buf|
+      buf << "monitor #{monitor[:FriendlyName].inspect} do"
+      buf << "  target #{monitor[:URL].inspect}"
+      buf << "  interval #{monitor[:Interval].inspect}"
+      buf << "  paused #{paused.inspect}"
+
+      unless alert_contacts.empty?
+        output_monitor_alert_contacts(alert_contacts, buf)
+      end
+
+      buf << ""
+      buf << "  type #{monitor_type.inspect}" + (has_type_attr ? " do" : "")
+
+      if has_type_attr
+        output_monitor_type_attrs(monitor, buf)
+        buf << "  end"
+      end
+
+      buf << "end"
+    }.join("\n")
+  end
+
+  def output_monitor_alert_contacts(alert_contacts, buf)
+    alert_contacts.each do |alert_contact|
+      type = WatchList::AlertContact::Type.key(alert_contact[:Type]).to_sym
+      buf << "  alert_contact #{type.inspect}, #{alert_contact[:Value].inspect}"
+    end
+  end
+
+  def output_monitor_type_attrs(monitor, buf)
+    TYPE_ATTRS.each do |key|
+      value = monitor[key]
+      next unless value
+
+      if WatchList::Monitor.const_defined?(key)
+        const = WatchList::Monitor.const_get(key)
+        buf << "    #{key.to_s.downcase} " + const.key(value).to_sym.inspect
+      else
+        buf << "    #{key.to_s.downcase} #{value.inspect}"
+      end
+    end
+  end
+
+  def output_alert_contacts(alert_contacts)
+    (alert_contacts || []).map {|alert_contact|
+      output_alert_contact(alert_contact)
+    }.join("\n\n")
+  end
+
+  def output_alert_contact(alert_contact)
+    alert_contact_type = WatchList::AlertContact::Type.key(alert_contact[:Type]).to_sym
+
+    output {|buf|
+      buf << "alert_contact do"
+      buf << "  type #{alert_contact_type.inspect}"
+      buf << "  value #{alert_contact[:Value].inspect}"
+      buf << "end"
+    }.join("\n")
+  end
+
+  def output(buf = [])
+    yield(buf)
+    buf
+  end
+end

data/lib/watch_list/exporter.rb

@@ -0,0 +1,145 @@
+class WatchList::Exporter
+  class << self
+    def export(uptimerobot, opts = {})
+      self.new(uptimerobot, opts).export
+    end
+
+    def export_status(uptimerobot, opts = {})
+      self.new(uptimerobot, opts).export_status
+    end
+  end # of class methods
+
+  def initialize(uptimerobot, options = {})
+    @uptimerobot = uptimerobot
+    @options = options
+  end
+
+  def export
+    monitors = @uptimerobot.getMonitors(showMonitorAlertContacts: 1)
+    alert_contacts = @uptimerobot.getAlertContacts
+
+    {
+      :monitors       => normalize_monitors(monitors),
+      :alert_contacts => normalize_alert_contacts(alert_contacts),
+    }
+  end
+
+  def export_status
+    monitors = @uptimerobot.getMonitors(
+      :logs                 => 1,
+      :responseTimes        => 1,
+      :showTimezone         => 1,
+    )
+
+    {
+      :timezone => monitors['timezone'],
+      :monitors => normalize_monitors_status(monitors),
+    }
+  end
+
+  private
+
+  def normalize_monitors(monitors)
+    monitors = monitors.fetch('monitors', {}).fetch('monitor', [])
+    monitor_hash = {}
+
+    monitors.each do |monitor|
+      friendlyname = monitor['friendlyname']
+      type = monitor['type'].to_i
+
+      monitor_hash[friendlyname] = {
+        :ID            => monitor['id'],
+        :FriendlyName  => friendlyname,
+        :URL           => monitor['url'],
+        :Type          => type,
+        :AlertContacts => monitor.fetch('alertcontact', []).map {|alert_contact|
+          {
+            :Type  => alert_contact['type'].to_i,
+            :Value => alert_contact['value'],
+          }
+        },
+        :Interval      => nil_if_blank(monitor['interval'], :to_i) / 60,
+        :Status        => monitor['status'].to_i,
+      }
+
+      case WatchList::Monitor::Type.key(type)
+      when 'http'
+        monitor_hash[friendlyname].update(
+          :HTTPUsername => nil_if_blank(monitor['httpusername']),
+          :HTTPPassword => nil_if_blank(monitor['httppassword']),
+        )
+      when 'keyword'
+        monitor_hash[friendlyname].update(
+          :KeywordType  => nil_if_blank(monitor['keywordtype'], :to_i),
+          :KeywordValue => nil_if_blank(monitor['keywordvalue']),
+          :HTTPUsername => nil_if_blank(monitor['httpusername']),
+          :HTTPPassword => nil_if_blank(monitor['httppassword']),
+        )
+      when 'ping'
+      when 'port'
+        monitor_hash[friendlyname].update(
+          :SubType => nil_if_blank(monitor['subtype'], :to_i),
+          :Port    => nil_if_blank(monitor['port'], :to_i),
+        )
+      end
+    end
+
+    monitor_hash
+  end
+
+  def normalize_alert_contacts(alert_contacts)
+    alert_contacts = alert_contacts.fetch('alertcontacts', {}).fetch('alertcontact', [])
+
+    alert_contacts.map do |alert_contact|
+      {
+        :ID    => alert_contact['id'],
+        :Type  => alert_contact['type'].to_i,
+        :Value => alert_contact['value'],
+      }
+    end
+  end
+
+  def normalize_monitors_status(monitors)
+    monitors = monitors.fetch('monitors', {}).fetch('monitor', [])
+    monitor_hash = {}
+
+    monitors.each do |monitor|
+      friendlyname = monitor['friendlyname']
+
+      monitor_hash[friendlyname] = {
+        :status             => WatchList::Monitor::Status.key(monitor['status'].to_i),
+        :alltimeuptimeratio => monitor['alltimeuptimeratio'].to_i,
+        :log                => normalize_monitor_log(monitor),
+        :responsetime       => normalize_monitor_responsetime(monitor),
+      }
+    end
+
+    monitor_hash
+  end
+
+  def normalize_monitor_log(monitor)
+    monitor.fetch('log', []).map do |log|
+      {
+        :datetime => log['datetime'],
+        :type     => WatchList::Log::Type.key(log['type'].to_i),
+      }
+    end
+  end
+
+  def normalize_monitor_responsetime(monitor)
+    monitor.fetch('responsetime', []).map do |responsetime|
+      {
+        :datetime => responsetime['datetime'],
+        :value    => responsetime['value'].to_i,
+      }
+    end
+  end
+
+  def nil_if_blank(str, conv = nil)
+    if str.empty?
+      nil
+    else
+      conv ? str.send(conv) : str
+    end
+  end
+end

data/lib/watch_list/ext/string_ext.rb

@@ -0,0 +1,25 @@
+class String
+  @@colorize = false
+
+  class << self
+    def colorize=(value)
+      @@colorize = value
+    end
+
+    def colorize
+      @@colorize
+    end
+  end # of class methods
+
+  Term::ANSIColor::Attribute.named_attributes.map do |attribute|
+    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      def #{attribute.name}
+        if @@colorize
+          Term::ANSIColor.send(#{attribute.name.inspect}, self)
+        else
+          self
+        end
+      end
+    EOS
+  end
+end

data/lib/watch_list/logger.rb

@@ -0,0 +1,30 @@
+class WatchList::Logger < ::Logger
+  include Singleton
+
+  def initialize
+    super($stdout)
+
+    self.formatter = proc do |severity, datetime, progname, msg|
+      "#{msg}\n"
+    end
+
+    self.level = INFO
+  end
+
+  def set_debug(value)
+    self.level = value ? DEBUG : INFO
+  end
+
+  module Helper
+    def log(level, message, opts = {})
+      opts = (@options || {}).merge(opts)
+
+      message = "[#{level.to_s.upcase}] #{message}" unless level == :info
+      message << ' (dry-run)' if opts[:dry_run]
+      message = message.send(opts[:color]) if opts[:color]
+
+      logger = opts[:logger] || WatchList::Logger.instance
+      logger.send(level, message)
+    end
+  end
+end

data/lib/watch_list/utils.rb

@@ -0,0 +1,14 @@
+class WatchList::Utils
+  class << self
+    def const_to_hash(const)
+      hash = {}
+
+      const.constants.map do |c|
+        key = c.to_s.gsub(/[A-Z]+/, '_\0').sub(/\A_/, '').downcase
+        hash[key] = const.const_get(c)
+      end
+
+      hash
+    end
+  end # of class methods
+end

data/lib/watch_list/version.rb

@@ -0,0 +1,3 @@
+module WatchList
+  VERSION = '0.1.0'
+end

data/spec/alert_contact_spec.rb

@@ -0,0 +1,153 @@
+describe 'alert contact' do
+  it do
+    watch_list do
+      <<-RUBY
+        alert_contact do
+          type :email
+          value "#{WATCH_LIST_TEST_EMAIL}"
+        end
+
+        alert_contact do
+          type :email
+          value "#{WATCH_LIST_TEST_EMAIL2}"
+        end
+      RUBY
+    end
+
+    expect(watch_list_export {|h| h[:alert_contacts].length > 1 }).to eq(
+      {:monitors=>{},
+       :alert_contacts=>
+        [{:Type=>2, :Value=>WATCH_LIST_TEST_EMAIL},
+         {:Type=>2, :Value=>WATCH_LIST_TEST_EMAIL2}]}
+    )
+
+    watch_list do
+      <<-RUBY
+        monitor "http monitor" do
+          target "http://example.com"
+          interval 5
+          paused false
+          alert_contact :email, "#{WATCH_LIST_TEST_EMAIL}"
+          alert_contact :email, "#{WATCH_LIST_TEST_EMAIL2}"
+          type :http
+        end
+
+        alert_contact do
+          type :email
+          value "#{WATCH_LIST_TEST_EMAIL}"
+        end
+
+        alert_contact do
+          type :email
+          value "#{WATCH_LIST_TEST_EMAIL2}"
+        end
+      RUBY
+    end
+
+    expect(watch_list_export {|h| h[:monitors].length > 0 }).to eq(
+      {:monitors=>
+        {"http monitor"=>
+          {:FriendlyName=>"http monitor",
+           :URL=>"http://example.com",
+           :Type=>1,
+           :HTTPUsername=>nil,
+           :HTTPPassword=>nil,
+           :AlertContacts=>
+            [{:Type=>2, :Value=>WATCH_LIST_TEST_EMAIL},
+             {:Type=>2, :Value=>WATCH_LIST_TEST_EMAIL2}],
+           :Interval=>5}},
+       :alert_contacts=>
+        [{:Type=>2, :Value=>WATCH_LIST_TEST_EMAIL},
+         {:Type=>2, :Value=>WATCH_LIST_TEST_EMAIL2}]}
+    )
+
+    watch_list do
+      <<-RUBY
+        monitor "http monitor" do
+          target "http://example.com"
+          interval 5
+          paused false
+          alert_contact :email, "#{WATCH_LIST_TEST_EMAIL}"
+          type :http
+        end
+
+        alert_contact do
+          type :email
+          value "#{WATCH_LIST_TEST_EMAIL}"
+        end
+
+        alert_contact do
+          type :email
+          value "#{WATCH_LIST_TEST_EMAIL2}"
+        end
+      RUBY
+    end
+
+    expect(watch_list_export {|h| h[:monitors]['http monitor'][:AlertContacts].length < 2 }).to eq(
+      {:monitors=>
+        {"http monitor"=>
+          {:FriendlyName=>"http monitor",
+           :URL=>"http://example.com",
+           :Type=>1,
+           :HTTPUsername=>nil,
+           :HTTPPassword=>nil,
+           :AlertContacts=>
+            [{:Type=>2, :Value=>WATCH_LIST_TEST_EMAIL}],
+           :Interval=>5}},
+       :alert_contacts=>
+        [{:Type=>2, :Value=>WATCH_LIST_TEST_EMAIL},
+         {:Type=>2, :Value=>WATCH_LIST_TEST_EMAIL2}]}
+    )
+
+    watch_list do
+      <<-RUBY
+        monitor "http monitor" do
+          target "http://example.com"
+          interval 5
+          paused false
+          alert_contact :email, "#{WATCH_LIST_TEST_EMAIL2}"
+          type :http
+        end
+
+        alert_contact do
+          type :email
+          value "#{WATCH_LIST_TEST_EMAIL}"
+        end
+
+        alert_contact do
+          type :email
+          value "#{WATCH_LIST_TEST_EMAIL2}"
+        end
+      RUBY
+    end
+
+    expect(watch_list_export {|h| h[:monitors]['http monitor'][:AlertContacts][0][:Value] != WATCH_LIST_TEST_EMAIL }).to eq(
+      {:monitors=>
+        {"http monitor"=>
+          {:FriendlyName=>"http monitor",
+           :URL=>"http://example.com",
+           :Type=>1,
+           :HTTPUsername=>nil,
+           :HTTPPassword=>nil,
+           :AlertContacts=>
+            [{:Type=>2, :Value=>WATCH_LIST_TEST_EMAIL2}],
+           :Interval=>5}},
+       :alert_contacts=>
+        [{:Type=>2, :Value=>WATCH_LIST_TEST_EMAIL},
+         {:Type=>2, :Value=>WATCH_LIST_TEST_EMAIL2}]}
+    )
+
+    watch_list do
+      <<-RUBY
+        alert_contact do
+          type :email
+          value "#{WATCH_LIST_TEST_EMAIL}"
+        end
+      RUBY
+    end
+
+    expect(watch_list_export {|h| h[:monitors].length < 1 }).to eq(
+      {:monitors=>{}, :alert_contacts=>[{:Type=>2, :Value=>WATCH_LIST_TEST_EMAIL}]}
+    )
+  end
+end