watch_list 0.1.0

data/lib/watch_list/constants.rb

@@ -0,0 +1,16 @@
+module WatchList
+  module Monitor
+    Type        = WatchList::Utils.const_to_hash(UptimeRobot::Monitor::Type)
+    SubType     = WatchList::Utils.const_to_hash(UptimeRobot::Monitor::SubType)
+    KeywordType = WatchList::Utils.const_to_hash(UptimeRobot::Monitor::KeywordType)
+    Status      = WatchList::Utils.const_to_hash(UptimeRobot::Monitor::Status)
+  end
+
+  module Log
+    Type = WatchList::Utils.const_to_hash(UptimeRobot::Log::Type)
+  end
+
+  module AlertContact
+    Type = WatchList::Utils.const_to_hash(UptimeRobot::AlertContact::Type)
+  end
+end

data/lib/watch_list/driver.rb

@@ -0,0 +1,146 @@
+class WatchList::Driver
+  include WatchList::Logger::Helper
+
+  def initialize(uptimerobot, opts = {})
+    @uptimerobot = uptimerobot
+    @options = opts
+  end
+
+  def new_alert_contact(attrs)
+    updated = false
+    log(:info, "Create AlertContact: #{describe_alert_contacts(attrs)}", :color => :cyan)
+
+    unless @options[:dry_run]
+      response = @uptimerobot.newAlertContact(
+        :alertContactType  => attrs[:Type],
+        :alertContactValue => attrs[:Value],
+      )
+
+      attrs[:ID] = response['alertcontact']['id']
+      updated = true
+    end
+
+    updated
+  end
+
+  def delete_alert_contact(attrs)
+    updated = false
+    log(:info, "Delete AlertContact: #{describe_alert_contacts(attrs)}", :color => :red)
+
+    unless @options[:dry_run]
+      @uptimerobot.deleteAlertContact(
+        :alertContactID => attrs[:ID],
+      )
+
+      updated = true
+    end
+
+    updated
+  end
+
+  def new_monitor(attrs, exist_alert_contacts)
+    updated = false
+    log(:info, "Create Monitor: #{attrs[:FriendlyName]}", :color => :cyan)
+
+    unless @options[:dry_run]
+      normalize_edit_attrs!(attrs)
+      params = monitor_to_params(attrs, exist_alert_contacts)
+      response = @uptimerobot.newMonitor(params)
+      attrs[:ID] = response['monitor']['id']
+      updated = true
+    end
+
+    updated
+  end
+
+  def delete_monitor(attrs)
+    updated = false
+    log(:info, "Delete Monitor: #{attrs[:FriendlyName]}", :color => :red)
+
+    unless @options[:dry_run]
+      @uptimerobot.deleteMonitor(
+        :monitorID => attrs[:ID],
+      )
+
+      updated = true
+    end
+
+    updated
+  end
+
+  def edit_monitor(monitor_id, monitor_name, attrs, exist_alert_contacts)
+    updated = false
+    log(:info, "Update Monitor: #{monitor_name}", :color => :green)
+
+    attrs.each do |key, value|
+      log(:info, " set #{key}=#{value}", :color => :green)
+    end
+
+    unless @options[:dry_run]
+      params = monitor_to_params(attrs, exist_alert_contacts)
+      params[:monitorID] = monitor_id
+      @uptimerobot.editMonitor(params)
+      updated = true
+    end
+
+    updated
+  end
+
+  def pause_monitor(monitor_id, monitor_name, paused)
+    updated = false
+    log(:info, (paused ? 'Pause' : 'Unpause') + " Monitor: #{monitor_name}", :color => :green)
+
+    unless @options[:dry_run]
+      @uptimerobot.editMonitor(
+        :monitorID     => monitor_id,
+        :monitorStatus => (paused ? 0 : 1),
+      )
+
+      updated = true
+    end
+
+    updated
+  end
+
+  private
+
+  def describe_alert_contacts(attrs)
+    type = WatchList::AlertContact::Type.key(attrs[:Type])
+    "#{type}, #{attrs[:Value]}"
+  end
+
+  def monitor_to_params(attrs, exist_alert_contacts)
+    params = {}
+    attrs = attrs.dup
+    attrs.delete(:Paused)
+    alert_contacts = attrs.delete(:AlertContacts) || []
+
+    attrs.each do |key, value|
+      params["monitor#{key}"] = value unless value.nil?
+    end
+
+    unless alert_contacts.empty?
+      params[:monitorAlertContacts] = alert_contacts.map {|alert_contact|
+        exist_alert_contact = exist_alert_contacts.find {|i|
+          i.values_at(:Type, :Value) == alert_contact.values_at(:Type, :Value)
+        }
+
+        raise "AlertContact does not exist: #{alert_contact.inspect}" unless exist_alert_contact
+
+        exist_alert_contact[:ID]
+      }.join(',')
+    end
+
+    params
+  end
+
+  def normalize_edit_attrs!(attrs)
+    # XXX: Other parameter is required in order to update the "HTTPUsername" and "HTTPPassword"
+    attrs[:Interval] ||= expected[:Interval]
+
+    # Remove by an empty parameter
+    attrs.keys.each do |key|
+      attrs[key] ||= ''
+    end
+  end
+end

data/lib/watch_list/dsl.rb

@@ -0,0 +1,11 @@
+class WatchList::DSL
+  class << self
+    def convert(exported, opts = {})
+      WatchList::DSL::Converter.convert(exported, opts)
+    end
+
+    def parse(dsl, path, opts = {})
+      WatchList::DSL::Context.eval(dsl, path, opts).result
+    end
+  end # of class methods
+end

data/lib/watch_list/dsl/context.rb

@@ -0,0 +1,40 @@
+class WatchList::DSL::Context
+  class << self
+    def eval(dsl, path, opts = {})
+      self.new(path, opts) {
+        Kernel.eval(dsl, binding, path)
+      }
+    end
+  end # of class methods
+
+  attr_reader :result
+
+  def initialize(path, options = {}, &block)
+    @path = path
+    @options = options
+    @result = {:monitors => {}, :alert_contacts => []}
+    instance_eval(&block)
+  end
+
+  def require(file)
+   robotfile = File.expand_path(File.join(File.dirname(@path), file))
+
+    if File.exist?(robotfile)
+      instance_eval(File.read(robotfile), robotfile)
+    elsif File.exist?(robotfile + '.rb')
+      instance_eval(File.read(robotfile + '.rb'), robotfile + '.rb')
+    else
+      Kernel.require(file)
+    end
+  end
+
+  def monitor(name, &block)
+    raise 'Monitor: "friendlyname" is required' unless name
+    raise "Monitor `#{name}` is already defined" if @result[:monitors][name]
+    @result[:monitors][name] = WatchList::DSL::Context::Monitor.new(name, &block).result
+  end
+
+  def alert_contact(&block)
+    @result[:alert_contacts] << WatchList::DSL::Context::AlertContact.new(&block).result
+  end
+end

data/lib/watch_list/dsl/context/alert_contact.rb

@@ -0,0 +1,33 @@
+class WatchList::DSL::Context::AlertContact
+  def initialize(&block)
+    @result = {}
+    instance_eval(&block)
+  end
+
+  def result
+    [:Type, :Value].each do |key|
+      raise %!AlertContact: "#{key.to_s.downcase}" is required! unless @result[key]
+    end
+
+    @result
+  end
+
+  def type(value, &block)
+    if value.kind_of?(Integer)
+      alert_contact_type = value
+    else
+      alert_contact_type = WatchList::AlertContact::Type[value.to_s]
+    end
+
+    unless WatchList::AlertContact::Type.values.include?(alert_contact_type)
+      raise %!AlertContact: "type" is invalid: #{value.inspect}!
+    end
+
+    @result[:Type] = alert_contact_type
+  end
+
+  def value(value)
+    raise %!AlertContact: "value" is invalid: #{value.inspect}! if value.nil?
+    @result[:Value] = value.to_s
+  end
+end

data/lib/watch_list/dsl/context/monitor.rb

@@ -0,0 +1,82 @@
+class WatchList::DSL::Context::Monitor
+  def initialize(name, &block)
+    @name = name
+
+    @result = {
+      :FriendlyName  => name,
+      :Paused        => false,
+      :AlertContacts => [],
+    }
+
+    instance_eval(&block)
+  end
+
+  def result
+    raise %!Monitor `#{@name}`: "target" is required! unless @result[:URL]
+
+    [:Interval, :Type].each do |key|
+      raise %!Monitor `#{@name}`: "#{key.to_s.downcase}" is required! unless @result[key]
+    end
+
+    @result
+  end
+
+  def target(value)
+    raise %!Monitor `#{@name}`: "target" is invalid: #{value.inspect}! if value.nil?
+    @result[:URL] = value.to_s
+  end
+
+  def interval(value)
+    raise %!Monitor `#{@name}`: "interval" is invalid: #{value.inspect}! unless value.kind_of?(Integer)
+    @result[:Interval] = value
+  end
+
+  def paused(value)
+    unless [TrueClass, FalseClass].any? {|i| value.kind_of?(i) }
+      raise %!Monitor `#{@name}`: "paused" is invalid: #{value.inspect}!
+    end
+
+    @result[:Paused] = value
+  end
+
+  def alert_contact(type, value)
+    if type.kind_of?(Integer)
+      alert_contact_type = type
+    else
+      alert_contact_type = WatchList::AlertContact::Type[type.to_s]
+    end
+
+    unless WatchList::AlertContact::Type.values.include?(alert_contact_type)
+      raise %!Monitor `#{@name}`: "alert_contact" type is invalid: #{type.inspect}!
+    end
+
+    raise %!Monitor `#{@name}`: "alert_contact" value is invalid: #{value.inspect}! if value.nil?
+
+    hash = {:Type => alert_contact_type, :Value => value.to_s}
+
+    if @result[:AlertContacts].include?(hash)
+      raise %!Monitor `#{@name}`: "alert_contact"(#{type}, #{value}) is already defined!
+    end
+
+    @result[:AlertContacts] << hash
+  end
+
+  def type(value, &block)
+    if value.kind_of?(Integer)
+      monitor_type = value
+    else
+      monitor_type = WatchList::Monitor::Type[value.to_s]
+    end
+
+    unless WatchList::Monitor::Type.values.include?(monitor_type)
+      raise %!Monitor `#{@name}`: "type" is invalid: #{value.inspect}!
+    end
+
+    @result[:Type] = monitor_type
+
+    type_class = WatchList::DSL::Context::Monitor::Type[value.to_s]
+    raise "Monitor `#{@name}`: #{value.inspect} is unimplemented type" unless type_class
+
+    @result.update(type_class.new(@name, &block).result)
+  end
+end

data/lib/watch_list/dsl/context/monitor/http.rb

@@ -0,0 +1,13 @@
+class WatchList::DSL::Context::Monitor
+  class HTTP < Type
+    def httpusername(value)
+      raise %!Monitor `#{@monitor_name}`: "httpusername" is invalid: #{value.inspect}! if value.nil?
+      @result[:HTTPUsername] = value.to_s
+    end
+
+    def httppassword(value)
+      raise %!Monitor `#{@monitor_name}`: "httppassword" is invalid: #{value.inspect}! if value.nil?
+      @result[:HTTPPassword] = value.to_s
+    end
+  end
+end

data/lib/watch_list/dsl/context/monitor/keyword.rb

@@ -0,0 +1,30 @@
+class WatchList::DSL::Context::Monitor
+  class Keyword < HTTP
+    def result
+      [:KeywordType, :KeywordValue].each do |key|
+        raise %!Monitor `#{@monitor_name}`: "#{key.to_s.downcase}" is required! unless @result[key]
+      end
+
+      super
+    end
+
+    def keywordtype(value)
+      if value.kind_of?(Integer)
+        type = value
+      else
+        type = WatchList::Monitor::KeywordType[value.to_s]
+      end
+
+      unless WatchList::Monitor::KeywordType.values.include?(type)
+        raise %!Monitor `#{@monitor_name}`: "keywordtype" is invalid: #{value.inspect}!
+      end
+
+      @result[:KeywordType] = type
+    end
+
+    def keywordvalue(value)
+      raise %!Monitor `#{@monitor_name}`: "keywordvalue" is invalid: #{value.inspect}! if value.nil?
+      @result[:KeywordValue] = value.to_s
+    end
+  end
+end

data/lib/watch_list/dsl/context/monitor/ping.rb

@@ -0,0 +1,4 @@
+class WatchList::DSL::Context::Monitor
+  class Ping < Type
+  end
+end

data/lib/watch_list/dsl/context/monitor/port.rb

@@ -0,0 +1,30 @@
+class WatchList::DSL::Context::Monitor
+  class Port < Type
+    def result
+      [:SubType, :Port].each do |key|
+        raise %!Monitor `#{@monitor_name}`: "#{key.to_s.downcase}" is required! unless @result[key]
+      end
+
+      super
+    end
+
+    def subtype(value)
+      if value.kind_of?(Integer)
+        type = value
+      else
+        type = WatchList::Monitor::SubType[value.to_s]
+      end
+
+      unless WatchList::Monitor::SubType.values.include?(type)
+        raise %!Monitor `#{@monitor_name}`: "subtype" is invalid: #{value.inspect}!
+      end
+
+      @result[:SubType] = type
+    end
+
+    def port(value)
+      raise %!Monitor `#{@monitor_name}`: "port" is invalid: #{value.inspect}! unless value.kind_of?(Integer)
+      @result[:Port] = value
+    end
+  end
+end

data/lib/watch_list/dsl/context/monitor/type.rb

@@ -0,0 +1,24 @@
+class WatchList::DSL::Context::Monitor::Type
+  CHILDREN = {}
+
+  class << self
+    def inherited(child)
+      name = child.to_s.split('::').last.downcase
+      CHILDREN[name] = child
+    end
+
+    def [](name)
+      CHILDREN[name]
+    end
+  end # of class methods
+
+  def initialize(monitor_name, &block)
+    @monitor_name = monitor_name
+    @result = {}
+    instance_eval(&block) if block
+  end
+
+  def result
+    @result
+  end
+end