eye-patch 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ccc9b1afad17fb6c48380c118b5b98fef372f38
-  data.tar.gz: caf7686b488014a72041764a33d546cd862048e2
+  metadata.gz: 2b5844cb0bcc8406207a5838cf37b7c508096423
+  data.tar.gz: cdeffbc2afbfce475d4680ff91db40a9ec09ff6b
 SHA512:
-  metadata.gz: cc8f68ecfb3fe72e52227190422287b9b379c958421640b0bad27626816fb546b933400b21b7fe65dfb6eb938c68e21261a6e64d9877f6f4b82bcec145a699e5
-  data.tar.gz: 780c1b16f806ca7222fb2936ff0ed759230fcc9745d80bb46bff115264b8bebec1fb8a4e7def2e49e7a6fb8c04603014b7ed0a847f11f50d4f19daf40676b485
+  metadata.gz: 8c6eaabb46e382d2e04eb2f41286cab9f218d0b7a32c837ad057da6b55c838f0a9241abc726514fe63c5d32837abc3e39dd766499e3be80a5f20d0c003f84275
+  data.tar.gz: abc4cb6a750ceacb722d4be06d537858b2339d7d5c07c57b2abb2e306d83cccc65658e9f3443c61eb0e578974333b30676842bb37a002792b54e6fe8693f4cb2

data/eye-patch.gemspec

@@ -21,9 +21,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^test/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-
   spec.add_dependency "eye"
   spec.add_dependency "chronic_duration"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "mocha"
 end

data/lib/eye/patch.rb

@@ -15,11 +15,11 @@ module Eye::Patch
   require "eye/patch/version"
 
   def self.parse(filename)
-    settings = Eye::Patch::Settings.new(filename)
+    settings = Settings.new(filename)
 
-    config = Eye::Config.new(
-      Eye::Patch::Config.new(settings),
-      Eye::Patch::Application.new(settings))
+    config = ::Eye::Config.new(
+      Config.new(settings),
+      Application.new(settings))
     config.validate!
 
     config

data/lib/eye/patch/application.rb

@@ -1,73 +1,49 @@
-class Eye::Patch::Application < Hash
+require_relative "group_set"
+require_relative "option_set"
 
-  def initialize(settings)
-    super()
-    @settings = settings
-    self[settings[:name].to_s] = parse
-  end
+module Eye::Patch
 
-  private
+  class Application < Hash
 
-  def parse
-    @config = {}
+    def initialize(settings)
+      super()
+      @settings = settings
+      self[settings[:name]] = parse
+    end
 
-    parse_configuration
-    parse_processes
+    private
 
-    @config
-  end
+    def parse
+      parse_configuration
+      parse_processes
 
-  def root_settings
-    @root_settings ||= (@settings[:application] || {}).merge(
-      notify: parse_notifications,
-      triggers: parse_triggers,
-      checks: parse_checks )
-  end
-
-  def parse_notifications
-    Array(@settings[:notifications]).each_with_object({}) do |notify, monitors|
-      monitors[notify[:name].to_s] = notify[:level].to_sym
+      @config
     end
-  end
 
-  def parse_triggers
-    Array(@settings[:triggers]).each_with_object({}) do |trigger, triggers|
-      trigger_data = Eye::Trigger.name_and_class(trigger[:name].to_sym)
-      triggers[trigger_data[:name]] = trigger[:config].merge(type: trigger_data[:type])
+    def parse_configuration
+      @config = (@settings[:application] || {}).merge(
+        name: @settings[:name],
+        notify: notifications,
+        triggers: triggers,
+        checks: checks )
     end
-  end
 
-  def parse_checks
-    Array(@settings[:checks]).each_with_object({}) do |check, checks|
-      check_data = Eye::Checker.name_and_class(check[:name].to_sym)
-      checks[check_data[:name]] = check[:config].merge(type: check_data[:type])
+    def parse_processes
+      @config[:groups] = GroupSet.new(@config, @settings[:processes])
     end
-  end
-
-  def parse_configuration
-    @config.merge!(root_settings)
-  end
-
-  def parse_processes
-    @config[:groups] = {}
 
-    Array(@settings[:processes]).group_by{ |item| item[:group] }.each do |group_name, items|
-      name = group_name || "__default__"
-      parse_group(name, items)
+    def notifications
+      Array(@settings[:notifications]).each_with_object({}) do |notify, monitors|
+        monitors[notify[:name]] = notify[:level].to_sym
+      end
     end
-  end
 
-  def parse_group(name, processes)
-    @config[:groups][name] = root_settings.merge(
-      application: @settings[:name].to_s,
-      processes: parse_process_list(name, processes))
-  end
+    def triggers
+      OptionSet.new(Eye::Trigger, @settings[:triggers])
+    end
 
-  def parse_process_list(group_name, processes)
-    processes.each_with_object({}) do |process, process_map|
-      process_map[process[:name].to_s] = root_settings.merge(process[:config]).merge(
-        name: process[:name].to_s,
-        group: group_name )
+    def checks
+      OptionSet.new(Eye::Checker, @settings[:checks])
     end
   end
 end

data/lib/eye/patch/capistrano.rb

@@ -0,0 +1,31 @@
+Capistrano::Configuration.instance.load do
+
+  _cset(:eye_default_hooks) { true }
+  _cset(:eye_config) { "config/eye.yml" }
+  _cset(:eye_bin) { "bundle exec eye-patch" }
+  _cset(:eye_roles) { :app }
+
+  if fetch(:eye_default_hooks)
+    after  "deploy:stop",    "eye:stop"
+    after  "deploy:start",   "eye:start"
+    before "deploy:restart", "eye:restart"
+  end
+
+  namespace :eye do
+
+    desc "Start eye with the desired configuration file"
+    task :start, roles: -> { fetch(:eye_roles) } do
+      run "cd #{current_path} && #{fetch(:eye_bin)} l #{fetch(:eye_config)}"
+    end
+
+    desc "Stop eye and all of its monitored tasks"
+    task :stop, roles: -> { fetch(:eye_roles) } do
+      run "cd #{current_path} && #{fetch(:eye_bin)} stop all && #{fetch(:eye_bin)} q"
+    end
+
+    desc "Restart all tasks monitored by eye"
+    task :restart, roles: -> { fetch(:eye_roles) } do
+      run "cd #{current_path} && #{fetch(:eye_bin)} r all"
+    end
+  end
+end

data/lib/eye/patch/group_set.rb

@@ -0,0 +1,26 @@
+require_relative "process_set"
+
+module Eye::Patch
+
+  class GroupSet < Hash
+
+    def initialize(application, processes)
+      @application = application
+
+      Array(processes).group_by{ |item| item[:group] }.each do |group_name, items|
+        name = group_name || "__default__"
+        parse_group(name, items)
+      end
+    end
+
+    private
+
+    def parse_group(name, processes)
+      self[name] = @application.merge(
+        name: name,
+        application: @application[:name])
+
+      self[name][:processes] = ProcessSet.new(self[name], processes)
+    end
+  end
+end

data/lib/eye/patch/option_set.rb

@@ -0,0 +1,11 @@
+module Eye::Patch
+  class OptionSet < Hash
+
+    def initialize(option_class, options)
+      Array(options).each do |option|
+        option_data = option_class.name_and_class(option[:name].to_sym)
+        self[option_data[:name]] = option[:config].merge(type: option_data[:type])
+      end
+    end
+  end
+end

data/lib/eye/patch/process_set.rb

@@ -0,0 +1,42 @@
+module Eye::Patch
+
+  class ProcessSet < Hash
+
+    def initialize(group, processes)
+      @group = group
+
+      Array(processes).each do |process|
+        parse_process(process)
+      end
+    end
+
+    private
+
+    def parse_process(process)
+      if process[:count]
+        parse_process_cluster(process)
+      else
+        parse_single_process(process[:name], process[:config])
+      end
+    end
+
+    def parse_process_cluster(process)
+      process[:count].times do |index|
+        name = "#{process[:name]}-#{index}"
+        parse_single_process(name, indexed_config(process[:config], index))
+      end
+    end
+
+    def parse_single_process(name, config)
+      self[name] = @group.merge(config).merge(
+        name: name,
+        group: @group[:name] )
+    end
+
+    def indexed_config(config, index)
+      config.each_with_object({}) do |(key, value), result|
+        result[key] = value.is_a?(String) ? value.gsub("{ID}", index.to_s) : value
+      end
+    end
+  end
+end

data/lib/eye/patch/settings.rb

@@ -1,34 +1,36 @@
-require "chronic_duration"
+require_relative "value_parser"
 
-class Eye::Patch::Settings
+module Eye::Patch
 
-  def initialize(filename)
-    @settings = YAML.load(File.open(filename))
-  end
+  class Settings
 
-  def [](value)
-    parsed[value]
-  end
+    def initialize(filename)
+      @settings = YAML.load(File.open(filename))
+    end
 
-  private
+    def [](value)
+      parsed[value]
+    end
 
-  def parsed
-    @parsed ||= parse(@settings)
-  end
+    private
+
+    def parsed
+      @parsed ||= parse(@settings)
+    end
 
-  def parse(item)
-    case item
-    when Hash
-      item.each_with_object({}) do |(key, val), result|
-        result[key.to_sym] = parse(val)
+    def parse(item)
+      case item
+      when Hash
+        item.each_with_object({}) do |(key, val), result|
+          result[key.to_sym] = parse(val)
+        end
+      when Array
+        item.map { |val| parse(val) }
+      when String
+        ValueParser.parse(item)
+      else
+        item
       end
-    when Array
-      item.map { |val| parse(val) }
-    when String
-      # Assume that we should parse any time-like values
-      item =~ /\b(hour|second|minute)s?\b/ ? ChronicDuration.parse(item) : item
-    else
-      item
     end
   end
 end

data/lib/eye/patch/value_parser.rb

@@ -0,0 +1,32 @@
+require "chronic_duration"
+
+module Eye::Patch
+
+  class ValueParser
+
+    TIME_MATCHER = / (?<duration>(week|day|hour|minute|second)s?)( |\Z)/.freeze
+    SIZE_MATCHER = / (?<size>(tera|giga|mega|kilo)?bytes?)( |\Z)/.freeze
+    MATCHERS     = {
+      time: TIME_MATCHER,
+      size: SIZE_MATCHER }.freeze
+
+    def self.parse(value)
+      result = MATCHERS.detect do |match_type, matcher|
+        break send(:"parse_#{match_type}", value) if value.match(matcher)
+      end
+
+      result || value
+    end
+
+    private
+
+    def self.parse_time(value)
+      ChronicDuration.parse(value)
+    end
+
+    def self.parse_size(value)
+      unit = value.match(SIZE_MATCHER)[:size]
+      value.gsub(/[^\d.]/, "").to_f.send(unit)
+    end
+  end
+end

data/lib/eye/patch/version.rb

@@ -1,5 +1,5 @@
 module Eye
   module Patch
-    VERSION = "0.0.4"
+    VERSION = "0.0.5"
   end
 end

data/test/fixtures/test.yml

@@ -0,0 +1,51 @@
+name: Test Application
+
+config:
+  logger: /path/to/log/eye.log
+
+application:
+  working_dir: /path/to/application
+
+notifications:
+  - name: monitoring
+    type: jabber
+    level: info
+    contact: test+admin@example.com
+    config:
+      from: test+notifier@example.com
+
+triggers:
+  - name: flapping
+    config:
+      times: 10
+      within: 1 minute
+
+checks:
+  - name: memory
+    config:
+      times: 3
+      every: 20 seconds
+      below: 1.5 gigabytes
+
+processes:
+  - name: my-process
+    config:
+      start_timeout: 25 seconds
+      start_command: bundle exec my-process
+      pid_file: tmp/pids/my-process.pid
+  - name: first-grouped-process
+    group: my-group
+    config:
+      start_command: bundle exec grouped-process
+      pid_file: tmp/pids/first-grouped-process.pid
+  - name: second-grouped-process
+    group: my-group
+    config:
+      start_command: bundle exec grouped-process
+      pid_file: tmp/pids/second-grouped-process.pid
+  - name: clustered-process
+    group: cluster
+    count: 2
+    config:
+      start_command: bundle exec clustered-process
+      pid_file: "tmp/pids/clustered-process-{ID}.pid"

data/test/lib/eye/patch/value_parser_test.rb

@@ -0,0 +1,22 @@
+require_relative "../../../test_helper"
+
+describe Eye::Patch::ValueParser do
+
+  it "parses time values" do
+    assert_equal 2.weeks, Eye::Patch::ValueParser.parse("2 weeks")
+    assert_equal 1.5.hours, Eye::Patch::ValueParser.parse("1.5 hours")
+    assert_equal 50.minutes, Eye::Patch::ValueParser.parse("50 minutes")
+    assert_equal 3.seconds, Eye::Patch::ValueParser.parse("3 seconds")
+  end
+
+  it "parses size values" do
+    assert_equal 3.2.gigabytes, Eye::Patch::ValueParser.parse("3.2 gigabytes")
+    assert_equal 2.4.megabytes, Eye::Patch::ValueParser.parse("2.4 megabytes")
+    assert_equal 1.kilobyte, Eye::Patch::ValueParser.parse("1 kilobyte")
+  end
+
+  it "uses strict word boundary characters" do
+    assert_equal "second-thing", Eye::Patch::ValueParser.parse("second-thing")
+    assert_equal "minutes", Eye::Patch::ValueParser.parse("minutes")
+  end
+end

data/test/lib/eye/patch/version_test.rb

@@ -0,0 +1,8 @@
+require_relative "../../../test_helper"
+
+describe Eye::Patch do
+
+  it "defines a version" do
+    assert Eye::Patch::VERSION
+  end
+end

data/test/lib/eye/patch_test.rb

@@ -0,0 +1,83 @@
+require_relative "../../test_helper"
+
+describe Eye::Patch do
+  before do
+    @fixture = File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. fixtures test.yml]))
+    @original = YAML.load(File.open(@fixture))
+  end
+
+  describe ".parse" do
+    before do
+      Eye::Config.any_instance.stubs(:validate!)
+      @parsed = Eye::Patch.parse(@fixture)
+
+      @settings = @parsed.settings
+      @applications = @parsed.applications
+      @application = @applications.values.first
+    end
+
+    it "returns an Eye::Config" do
+      assert_kind_of Eye::Config, @parsed
+    end
+
+    it "gives the application an appropriate name" do
+      assert_equal @original["name"], @applications.keys.first
+      assert_equal @original["name"], @application[:name]
+    end
+
+    it "parses contacts for notification" do
+      notification = @original["notifications"].first
+
+      assert_equal notification["config"]["from"], @settings[notification["type"].to_sym][:from]
+      assert_equal notification["type"].to_sym, @settings[:contacts][notification["name"]][:type]
+      assert_equal notification["level"].to_sym, @application[:notify][notification["name"]]
+    end
+
+    it "parses triggers" do
+      trigger = @original["triggers"].first
+      parsed_trigger = @application[:triggers][trigger["name"].to_sym]
+
+      assert_equal trigger["config"]["times"], parsed_trigger[:times]
+      assert_equal Eye::Patch::ValueParser.parse(trigger["config"]["within"]), parsed_trigger[:within]
+    end
+
+    it "parses checks" do
+      check = @original["checks"].first
+      parsed_check = @application[:checks][check["name"].to_sym]
+
+      assert_equal check["config"]["times"], parsed_check[:times]
+      assert_equal Eye::Patch::ValueParser.parse(check["config"]["every"]), parsed_check[:every]
+      assert_equal Eye::Patch::ValueParser.parse(check["config"]["below"]), parsed_check[:below]
+    end
+
+    it "splits processes into groups" do
+      grouped_processes = @original["processes"].select { |process| process["group"] && !process["count"] }
+      grouped_processes.each do |process|
+        assert_equal process["group"], @application[:groups][process["group"]][:processes][process["name"]][:group]
+      end
+    end
+
+    it "puts ungrouped processes into the __default__ group" do
+      lone_processes = @original["processes"].reject { |process| process["group"] }
+      lone_processes.each do |process|
+        assert_equal "__default__", @application[:groups]["__default__"][:processes][process["name"]][:group]
+      end
+    end
+
+    it "creates process clusters" do
+      process = @original["processes"].detect { |process| process["count"] }
+      process["count"].times do |index|
+        name = "#{process["name"]}-#{index}"
+        parsed_process = @application[:groups][process["group"]][:processes][name]
+
+        assert_equal process["group"], parsed_process[:group]
+        assert_equal process["config"]["pid_file"].gsub("{ID}", index.to_s), parsed_process[:pid_file]
+      end
+    end
+
+    it "passes application configurations down to processes" do
+      process = @application[:groups]["__default__"][:processes].values.first
+      assert_equal @application[:triggers], process[:triggers]
+    end
+  end
+end

data/test/test_helper.rb

@@ -1 +1,5 @@
-require 'minitest/autorun'
+require "minitest/autorun"
+require "minitest/unit"
+require "mocha/mini_test"
+
+require File.expand_path("../../lib/eye/patch.rb", __FILE__)

metadata

@@ -1,37 +1,37 @@
 --- !ruby/object:Gem::Specification
 name: eye-patch
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Andrew Horner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-02 00:00:00.000000000 Z
+date: 2014-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: eye
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
+        version: '0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: chronic_duration
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -39,13 +39,27 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: eye
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -53,13 +67,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: chronic_duration
+  name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -86,10 +100,19 @@ files:
 - lib/eye/notify/ses.rb
 - lib/eye/patch.rb
 - lib/eye/patch/application.rb
+- lib/eye/patch/capistrano.rb
 - lib/eye/patch/config.rb
+- lib/eye/patch/group_set.rb
+- lib/eye/patch/option_set.rb
 - lib/eye/patch/overrides.rb
+- lib/eye/patch/process_set.rb
 - lib/eye/patch/settings.rb
+- lib/eye/patch/value_parser.rb
 - lib/eye/patch/version.rb
+- test/fixtures/test.yml
+- test/lib/eye/patch/value_parser_test.rb
+- test/lib/eye/patch/version_test.rb
+- test/lib/eye/patch_test.rb
 - test/test_helper.rb
 homepage: https://github.com/tablexi/eye-patch
 licenses:
@@ -117,4 +140,8 @@ specification_version: 4
 summary: Eye::Patch abstracts out the Eye DSL to allow you to load your configuration
   from a structured YAML file, rather than relying on Eye's built-in DSL.
 test_files:
+- test/fixtures/test.yml
+- test/lib/eye/patch/value_parser_test.rb
+- test/lib/eye/patch/version_test.rb
+- test/lib/eye/patch_test.rb
 - test/test_helper.rb