watch_list 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 39b08a35fba945bc674c19dfa99ae9d5b95a04aa
+  data.tar.gz: 82e8aee260fb85a80e6571e24f9ad48113e69d17
+SHA512:
+  metadata.gz: 044e5aad31ee6923634bb761da3b0ddcc41161beb267c034c70afe78240802ae020536a9e8e7bfa5ba81762a35810634ae746fc660f57d8a391a23eb0365c567
+  data.tar.gz: f7924b7d7588da20d96ae02519538c577c6fec9f2d872109c4f27906d216db55467b716ae64537aa07b0cf6423f5e219fd036a599c15f4dddcbd6892db47ce81

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+test.rb
+Robotfile
+*.robot

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+- 2.0.0
+script:
+- bundle install
+- bundle exec rake
+env:
+  global:
+  - secure: "Zb/sZn5bAwqnUhSma4BqQFVaVO9wAdjlTUpl4aHLlVp9V+pRu4NVunEsvtTIZ0Y759Jw2s8BZzM7S8O2vcOSDf4D70RSrfKjyiQzBwK2NlwonAvN2lcD3AptBDxpXbvfLL2K7jSSM4/c8IUQjtJdYQooJ2nJWt/R4OTokHpp+sA="
+  - secure: "RxyKOUCe0+BgXThMPrHUYkddMd3mafV97qiXZfCzrP9X/kKEOTg+wNiR3Qkowjh6Ou9ultoXwEfBlwlQ44f9y/VV3qeaHjtoSgH7NVXRzEp5jLnEWyTIBwj4o4BEYHJNKRzGDsWC5TTkRgQQCOfwKeUlKPXTtx1tcN3dZtAEPqY="
+  - secure: "NYWq1B0s381EcvtHX2r3G8Oe3ZVfgRRwneQDI+G9HR2QIIM0sN+49agp5kSXGplSrNX2Swt7cFERPQ4YZ3o2vSnX90o7lnqZcfCh8bmOaLeV38AHlsOb5Rf9tyUyQPp+NyYUHNngUxdzrM+j8csTKwi5O+KpZKC2YedyM86BIso="
+  - secure: "Q2jYtrBEThr72h2HAImZXQuKbPltat5MbHt8DEl/oksv8bzqZbD5HxWVVQIBkkmKp9aefPdbDJ1hV5Y2zyo3KjYFCrXSQox11Lq3n4I0G3jaK8Ge2K+y1p/q55CBWTPOJrzHdgfEivXVwzYRvl6RuSqFVwiTdTB6kltxSxAOh4g="

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in watch_list.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Genki Sugawara
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,99 @@
+# watch_list
+
+watch_list is a tool to manage [Uptime Robot](https://uptimerobot.com/).
+
+It defines Uptime Robot monitors using Ruby DSL, and updates monitors according to DSL.
+
+[![Gem Version](https://badge.fury.io/rb/watch_list.svg)](http://badge.fury.io/rb/watch_list)
+[![Build Status](https://travis-ci.org/winebarrel/watch_list.svg?branch=master)](https://travis-ci.org/winebarrel/watch_list)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'watch_list'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install watch_list
+
+## Usage
+
+```sh
+watch_list -e -o Robotfile
+vi Robotfile
+watch_list -a --dry-run
+watch_list -a
+```
+
+## Help
+
+```
+Usage: watch_list [options]
+        --api-key API_KEY
+    -a, --apply
+    -f, --file FILE
+        --dry-run
+    -e, --export
+        --split
+    -o, --output FILE
+    -s, --status
+        --no-color
+        --debug
+    -h, --help
+```
+
+## Robotfile example
+
+```ruby
+monitor "http monitor" do
+  target "http://example.com"
+  interval 5
+  paused false
+  alert_contact :email, "alice@example.com"
+  type :http
+end
+
+monitor "keyword monitor" do
+  target "http://example.com"
+  interval 5
+  paused false
+  alert_contact :email, "alice@example.com"
+
+  type :keyword do
+    keywordtype :exists
+    keywordvalue "Example Domain"
+  end
+end
+
+monitor "ping monitor" do
+  target "127.0.0.1"
+  interval 5
+  paused false
+  alert_contact :email, "alice@example.com"
+  type :ping
+end
+
+monitor "port monitor" do
+  target "example.com"
+  interval 5
+  paused false
+  alert_contact :email, "alice@example.com"
+
+  type :port do
+    subtype :http
+    port 80
+  end
+end
+
+alert_contact do
+  type :email
+  value "alice@example.com"
+end
+```

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+task :default => :spec

data/bin/watch_list

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+$: << File.expand_path("#{File.dirname __FILE__}/../lib")
+
+require 'rubygems'
+require 'watch_list'
+require 'optparse'
+require 'json'
+
+Version = WatchList::VERSION
+DEFAULT_FILENAME = 'Robotfile'
+
+mode = nil
+file = DEFAULT_FILENAME
+output_file = '-'
+split = false
+
+options = {
+  :apiKey  => ENV['WATCH_LIST_API_KEY'],
+  :dry_run => false,
+  :color   => true,
+  :debug   => false,
+}
+
+ARGV.options do |opt|
+  begin
+    opt.on('',   '--api-key API_KEY') {|v| options[:apiKey]  = v       }
+    opt.on('-a', '--apply')           {    mode              = :apply  }
+    opt.on('-f', '--file FILE')       {|v| file              = v       }
+    opt.on(''  , '--dry-run')         {    options[:dry_run] = true    }
+    opt.on('-e', '--export')          {    mode              = :export }
+    opt.on(''  , '--split')           {    split             = true    }
+    opt.on('-o', '--output FILE')     {|v| output_file       = v       }
+    opt.on('-s', '--status')          {    mode              = :status  }
+    opt.on(''  , '--no-color')        {    options[:color]   = false   }
+    opt.on(''  , '--debug')           {    options[:debug]   = true    }
+
+    opt.on('-h', '--help') do
+      puts opt.help
+      exit 1
+    end
+
+    opt.parse!
+
+    unless mode
+      puts opt.help
+      exit 1
+    end
+
+    raise 'apiKey is required' unless options[:apiKey]
+  rescue => e
+    $stderr.puts("[ERROR] #{e.message}")
+    exit 1
+  end
+end
+
+String.colorize = options[:color]
+
+begin
+  logger = WatchList::Logger.instance
+  logger.set_debug(options[:debug])
+  client = WatchList::Client.new(options)
+
+  case mode
+  when :export
+    if split
+      logger.info('Export Uptime Robot')
+      output_file = DEFAULT_FILENAME if output_file == '-'
+      requires = []
+
+      client.export do |name, dsl|
+        robotfile = File.join(File.dirname(output_file), "#{name}.robot")
+        requires << robotfile
+        logger.info("  write `#{robotfile}`")
+
+        open(robotfile, 'wb') do |f|
+          f.puts dsl
+        end
+      end
+
+      logger.info("  write `#{output_file}`")
+
+      open(output_file, 'wb') do |f|
+        requires.each do |robotfile|
+          f.puts "require '#{File.basename robotfile}'"
+        end
+      end
+    else
+      if output_file == '-'
+        logger.info('# Export Uptime Robot')
+        puts client.export
+      else
+        logger.info("Export Uptime Robot to `#{output_file}`")
+        open(output_file, 'wb') {|f| f.puts client.export }
+      end
+    end
+  when :apply
+    unless File.exist?(file)
+      raise "No Robotfile found (looking for: #{file})"
+    end
+
+    msg = "Apply `#{file}` to Uptime Robot"
+    msg << ' (dry-run)' if options[:dry_run]
+    logger.info(msg)
+
+    updated = client.apply(file)
+
+    if updated
+      logger.warn('[WARN] Applying changes takes about 30 seconds'.yellow)
+    else
+      logger.info('No change'.intense_blue)
+    end
+  when :status
+    puts JSON.pretty_generate(client.status)
+  end
+rescue => e
+  if options[:debug]
+    raise e
+  else
+    $stderr.puts("[ERROR] #{e.message}".red)
+    exit 1
+  end
+end

data/lib/watch_list.rb

@@ -0,0 +1,27 @@
+require 'logger'
+require 'singleton'
+require 'tempfile'
+require 'term/ansicolor'
+require 'uptimerobot'
+
+module WatchList; end
+
+require 'watch_list/utils'
+require 'watch_list/constants'
+require 'watch_list/logger'
+
+require 'watch_list/client'
+require 'watch_list/driver'
+require 'watch_list/dsl'
+require 'watch_list/dsl/context'
+require 'watch_list/dsl/context/alert_contact'
+require 'watch_list/dsl/context/monitor'
+require 'watch_list/dsl/context/monitor/type'
+require 'watch_list/dsl/context/monitor/http'
+require 'watch_list/dsl/context/monitor/keyword'
+require 'watch_list/dsl/context/monitor/port'
+require 'watch_list/dsl/context/monitor/ping'
+require 'watch_list/dsl/converter'
+require 'watch_list/exporter'
+require 'watch_list/ext/string_ext'
+require 'watch_list/version'

data/lib/watch_list/client.rb

@@ -0,0 +1,156 @@
+class WatchList::Client
+  MONITOR_ATTRS = [
+    :URL,
+    :Type,
+    :SubType,
+    :Port,
+    :KeywordType,
+    :KeywordValue,
+    :HTTPUsername,
+    :HTTPPassword,
+    :AlertContacts,
+    :Interval,
+  ]
+
+  def initialize(options = {})
+    @options = options
+    @uptimerobot = UptimeRobot::Client.new(:apiKey => options[:apiKey])
+    @driver = WatchList::Driver.new(@uptimerobot, options)
+  end
+
+  def export
+    exported = WatchList::Exporter.export(@uptimerobot, @options)
+
+    if block_given?
+      exported.each do |name, attrs|
+        dsl = WatchList::DSL.convert({name => attrs}, @options).strip
+        yield(name, dsl) unless dsl.empty?
+      end
+    else
+      WatchList::DSL.convert(exported, @options)
+    end
+  end
+
+  def status
+    WatchList::Exporter.export_status(@uptimerobot, @options)
+  end
+
+  def apply(file)
+    walk(file)
+  end
+
+  private
+
+  def walk(file)
+    expected = load_file(file)
+    actual   = WatchList::Exporter.export(@uptimerobot, @options)
+
+    updated = walk_alert_contacts(expected[:alert_contacts], actual[:alert_contacts])
+    walk_monitors(expected[:monitors], actual[:monitors], expected[:alert_contacts]) || updated
+  end
+
+  def walk_alert_contacts(expected, actual)
+    updated = false
+
+    expected.each do |expected_alert_contact|
+      selector = proc do |i|
+        i.values_at(:Type, :Value) == expected_alert_contact.values_at(:Type, :Value)
+      end
+
+      actual_alert_contact = actual.find(&selector)
+
+      if actual_alert_contact
+        expected_alert_contact[:ID] = actual_alert_contact[:ID]
+        actual.delete_if(&selector)
+      else
+        updated = @driver.new_alert_contact(expected_alert_contact) || updated
+      end
+    end
+
+    actual.each do |alert_contact|
+      updated = @driver.delete_alert_contact(alert_contact) || updated
+    end
+
+    updated
+  end
+
+  def walk_monitors(expected, actual, alert_contacts)
+    updated = false
+
+    expected.each do |friendlyname, expected_monitor|
+      actual_monitor = actual.delete(friendlyname)
+
+      if actual_monitor
+        expected_monitor[:ID] = actual_monitor[:ID]
+        updated = walk_monitor(expected_monitor, actual_monitor, alert_contacts) || updated
+      else
+        updated = @driver.new_monitor(expected_monitor, alert_contacts) || updated
+      end
+    end
+
+    actual.each do |friendlyname, monitor|
+      updated = @driver.delete_monitor(monitor) || updated
+    end
+
+    updated
+  end
+
+  def walk_monitor(expected, actual, alert_contacts)
+    updated = false
+    delta = diff_monitor(expected, actual)
+
+    unless delta.empty?
+      updated = @driver.edit_monitor(expected[:ID], expected[:FriendlyName], delta, alert_contacts)
+    end
+
+    walk_monitor_paused(expected, actual) || updated
+  end
+
+  def walk_monitor_paused(expected, actual)
+    updated = false
+    expected_paused = !!expected[:Paused]
+    actual_pauced   = (actual[:Status] == UptimeRobot::Monitor::Status::Paused)
+
+    if expected_paused != actual_pauced
+      updated = @driver.pause_monitor(expected[:ID], expected[:FriendlyName], expected_paused)
+    end
+
+    updated
+  end
+
+  def diff_monitor(expected, actual)
+    delta = {}
+
+    MONITOR_ATTRS.each do |key|
+      expected_value = expected[key]
+      actual_value   = actual[key]
+      next if expected_value.nil? && actual_value.nil?
+
+      if expected_value.kind_of?(Array)
+        expected_value = expected_value.sort_by {|i| i.to_s }
+      end
+
+      if actual_value.kind_of?(Array)
+        actual_value = actual_value.sort_by {|i| i.to_s }
+      end
+
+      if expected_value != actual_value
+        delta[key] = expected_value
+      end
+    end
+
+    delta
+  end
+
+  def load_file(file)
+    if file.kind_of?(String)
+      open(file) do |f|
+        WatchList::DSL.parse(f.read, file)
+      end
+    elsif [File, Tempfile].any? {|i| file.kind_of?(i) }
+      WatchList::DSL.parse(file.read, file.path)
+    else
+      raise TypeError, "can't convert #{file} into File"
+    end
+  end
+end