noah 0.0.5 → 0.0.9

data/lib/noah/models/watchers.rb

@@ -0,0 +1,54 @@
+require 'digest/sha1'
+module Noah
+  class Watcher < Model #NYI
+    # Don't trust anything in here yet
+    # I'm still trying a few things
+    include WatcherValidations
+
+    attribute :pattern
+    attribute :endpoint
+
+    index :pattern
+    index :endpoint
+
+    def validate
+      super
+      assert_present :endpoint
+      assert_present :pattern
+      assert_unique [:endpoint, :pattern]
+      assert_not_superset
+      assert_not_subset
+    end
+
+    def name
+      @name = Base64.encode64("#{pattern}|#{endpoint}").gsub("\n","")
+    end
+
+    def to_hash
+      h = {:pattern => pattern, :name => name, :endpoint => endpoint, :created_at => created_at, :updated_at => updated_at}
+      super.merge(h)
+    end
+
+    def self.watch_list
+      arr = []
+      watches = self.all.sort_by(:pattern)
+      watches.each {|w| arr << w.name}
+      arr
+    end
+
+    private
+    # Not sure about these next two.
+    # Could get around patterns changing due to namespace changes
+    def path_to_pattern
+    end
+
+    def pattern_to_path
+    end
+  end
+
+  class Watchers
+    def self.all(options = {})
+      options.empty? ? Watcher.all.sort : Watcher.find(options).sort
+    end
+  end
+end

data/lib/noah/passthrough.rb

@@ -0,0 +1,11 @@
+module Noah
+  module Passthrough
+    def passthrough(*methods)
+      methods.each do |method|
+        raise ArgumentError if ! method.is_a?(Symbol)
+        meth = method.to_s
+        self.class_eval("def #{meth}(*args); self.class.#{meth}(*args); end")
+      end
+    end
+  end
+end

data/lib/noah/service_routes.rb

@@ -0,0 +1,71 @@
+class Noah::App
+  # Service URIs
+
+  # get named {Service} for named {Host}
+  get '/s/:servicename/:hostname/?' do |servicename, hostname|
+    hs = host_service(hostname, servicename)
+    if hs.nil?
+      halt 404
+    else  
+      hs.to_json
+    end  
+  end
+
+  get '/s/:servicename/?' do |servicename|
+    s = services(:name => servicename)
+    s.map {|x| x.to_hash}
+    if s.empty?
+      halt 404
+    else  
+      s.to_json
+    end  
+  end
+
+  get '/s/?' do
+    if services.empty?
+      halt 404
+    else
+      services.map {|s| s.to_hash}
+      services.to_json
+    end  
+  end
+
+  put '/s/:servicename/watch' do |servicename|
+    required_params = ["endpoint"]
+    data = JSON.parse(request.body.read)
+    (data.keys.sort == required_params.sort) ? (s = Noah::Service.find(:name => servicename).first) : (raise "Missing Parameters")
+    s.nil? ? (halt 404) : (w = s.watch!(:endpoint => data['endpoint']))
+    w.to_json
+  end
+
+  put '/s/:servicename/?' do |servicename|
+    required_params = ["status", "host", "name"]
+    data = JSON.parse(request.body.read)
+    if data.keys.sort == required_params.sort
+      h = Noah::Host.find(:name => data['host']).first || (raise "Invalid Host")
+      service = Noah::Service.find_or_create(:name => servicename, :status => data['status'], :host => h)
+      if service.valid?
+        action = service.is_new? ? "create" : "update"
+        service.save
+        r = {"action" => action, "result" => "success", "id" => service.id, "host" => h.name, "name" => service.name}
+        r.to_json
+      else
+        raise "#{service.errors}"
+      end
+    else
+      raise "Missing Parameters"
+    end  
+  end
+
+  delete '/s/:servicename/:hostname/?' do |servicename, hostname|
+    host = Noah::Host.find(:name => hostname).first || (halt 404)
+    service = Noah::Service.find(:name => servicename, :host_id => host.id).first || (halt 404)
+    if host && service
+      service.delete
+      r = {"action" => "delete", "result" => "success", "id" => service.id, "host" => host.name, "service" => servicename}
+      r.to_json
+    else
+      halt 404
+    end  
+  end  
+end

data/lib/noah/validations.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'validations','watcher_validations')

data/lib/noah/validations/watcher_validations.rb

@@ -0,0 +1,48 @@
+module Noah
+  module WatcherValidations
+
+      def assert_not_subset(error = [:pattern, :already_provided])
+        self.instance_of?(Noah::Watcher) ? (assert endpoint_covered?, error) : (assert false, "Validation not applicable")
+      end
+
+      def assert_not_superset(error = [:pattern, :replaces_existing])
+        self.instance_of?(Noah::Watcher) ? (assert endpoint_overrides?, error) : (assert false, "Validation not applicable")
+      end
+
+      def assert_valid_watch(error = [:pattern, :invalid_format])
+        self.instance_of?(Noah::Watcher) ? (assert pattern_valid?, error) : (assert false, "Validation not applicable")
+      end
+
+      private
+      def endpoint_covered?
+        watches = Watcher.all.find(:endpoint => self.endpoint).sort
+        watches.each do |w|
+          if (w.pattern.size < self.pattern.size) && self.pattern.match(/^#{w.pattern}/)
+            return false
+          end
+        end
+      rescue ArgumentError
+        return false
+      end
+
+      def endpoint_overrides?
+        watches = Watcher.all.find(:endpoint => self.endpoint).sort
+        watches.each do |w|
+          if (w.pattern.size > self.pattern.size) && w.pattern.match(/^#{self.pattern}/)
+            return false
+          end
+        end
+      rescue ArgumentError
+        return false
+      end
+
+      def pattern_valid?
+        unless self.pattern.match(/^\/\/noah\/.*\/$/)
+          return false
+        end
+      rescue ArgumentError
+        return false
+      end
+
+  end
+end

data/lib/noah/version.rb

@@ -1,3 +1,3 @@
 module Noah
-  VERSION = "0.0.5"
+  VERSION = "0.0.9"
 end

data/lib/noah/watcher.rb

@@ -0,0 +1,75 @@
+require 'eventmachine'
+require 'uri'
+require 'logger'
+
+@log = Logger.new(STDOUT)
+@log.level = Logger::DEBUG
+
+require File.join(File.dirname(__FILE__), 'passthrough')
+require File.join(File.dirname(__FILE__), '..','vendor','em-hiredis','lib','em-hiredis')
+
+module Noah
+
+  class Watcher
+    extend Passthrough
+
+    passthrough :redis_host, :pattern, :destination, :run!, :run_watcher
+
+    attr_accessor :my_pattern, :my_destination, :my_redis
+
+    def self.watch(&blk)
+      watcher = Noah::Watcher.new
+      watcher.instance_eval(&blk) if block_given?
+      watcher
+    end
+
+    def initialize
+      @my_redis ||= ENV['REDIS_URL']
+      @my_pattern ||= '//noah'
+    end
+
+    def self.redis_host(host)
+      @my_redis = host
+    end
+
+    def self.pattern(pattern)
+      @my_pattern = pattern
+    end
+
+    def self.destination(destination)
+      @my_destination = destination
+    end
+
+    def self.run!
+      @my_destination.nil? ? (raise ArgumentError) : run_watcher(@my_destination)
+    end
+
+    private
+    def self.run_watcher(dest)
+      log = Logger.new(STDOUT)
+      log.level = Logger::INFO
+      log.debug "#{dest.inspect}"
+      redis_url = URI.parse(@my_redis)
+      db = redis_url.path.gsub(/\//,'')
+
+      EventMachine.run do
+        trap("TERM") { log.info "Killed"; EventMachine.stop }
+        trap("INT")  { log.info "Interrupted"; EventMachine.stop }
+        channel = EventMachine::Channel.new
+        r = EventMachine::Hiredis::Client.connect(redis_url.host, redis_url.port)
+        # Pulling out dbnum for now. Need to rethink it
+        #log.info "Binding to pattern #{db}:#{@my_pattern}"
+        log.info "Binding to pattern #{@my_pattern}"
+        r.psubscribe("#{@my_pattern}*")
+        r.on(:pmessage) do |pattern, event, message|
+          log.debug "Got message"
+          channel.push "#{message}"
+        end
+        r.errback { log.info "Something went tango-uniform" }
+
+        sub = channel.subscribe {|msg| log.info "Calling message handler"; dest.call(msg)}
+      end
+    end
+  end
+
+end

data/lib/noah/watcher_routes.rb

@@ -0,0 +1,12 @@
+class Noah::App
+
+  get '/w/?' do
+    w = Noah::Watcher.all.sort_by(:pattern)
+    if w.size == 0
+      halt 404
+    else  
+      w.to_json
+    end  
+  end
+
+end

data/lib/vendor/em-hiredis/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in em-hiredis.gemspec
+gemspec

data/lib/vendor/em-hiredis/README.md

@@ -0,0 +1,61 @@
+Getting started
+===============
+
+Connect to redis
+
+    redis_client = EM::Hiredis.connect
+
+The client is a deferrable which succeeds when the underlying connection is established so you can bind to this. This isn't necessary however - any commands sent before the connection is established (or while reconnecting) will be sent to redis on connect.
+
+    redis_client.callback { puts "Redis now connected" }
+
+All redis commands are available without any remapping of names
+
+    redis.set('foo', 'bar').callback {
+      redis.get('foo').callback { |value|
+        p [:returned, value]
+      }
+    }
+
+As a shortcut, if you're only interested in binding to the success case you can simply provide a block to any command
+
+    redis.get('foo') { |value|
+      p [:returned, value]
+    }
+
+Handling failure
+----------------
+
+All commands return a deferrable. In the case that redis replies with an error (for example you called a hash operation against a set), or in the case that the redis connection is broken before the command returns, the deferrable will fail. If you care about the failure case you should bind to the errback - for example:
+
+    redis.sadd('aset', 'member').callback {
+      response_deferrable = redis.hget('aset', 'member')
+      response_deferrable.errback { |e|
+        p e # => #<RuntimeError: ERR Operation against a key holding the wrong kind of value>
+      }
+    }
+
+Pubsub
+------
+
+This example should explain things. Once a redis connection is in a pubsub state, you must make sure you only send pubsub commands.
+
+    redis = EM::Hiredis::Client.connect
+    subscriber = EM::Hiredis::Client.connect
+
+    subscriber.subscribe('bar.0')
+    subscriber.psubscribe('bar.*')
+
+    subscriber.on(:message) { |channel, message|
+      p [:message, channel, message]
+    }
+
+    subscriber.on(:pmessage) { |key, channel, message|
+      p [:pmessage, key, channel, message]
+    }
+
+    EM.add_periodic_timer(1) {
+      redis.publish("bar.#{rand(2)}", "hello").errback { |e|
+        p [:publisherror, e]
+      }
+    }

data/lib/vendor/em-hiredis/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/vendor/em-hiredis/em-hiredis.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "em-hiredis/version"
+
+Gem::Specification.new do |s|
+  s.name        = "em-hiredis"
+  s.version     = EM::Hiredis::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Martyn Loughran"]
+  s.email       = ["me@mloughran.com"]
+  s.homepage    = "http://github.com/mloughran/em-hiredis"
+  s.summary     = %q{Eventmachine redis client}
+  s.description = %q{Eventmachine redis client using hiredis native parser}
+
+  s.add_dependency 'hiredis', '~> 0.2.0'
+
+  s.rubyforge_project = "em-hiredis"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/vendor/em-hiredis/lib/em-hiredis.rb

@@ -0,0 +1,22 @@
+require 'eventmachine'
+
+module EM
+  module Hiredis
+    class << self
+      attr_writer :logger
+
+      def logger
+        @logger ||= begin
+          require 'logger'
+          log = Logger.new(STDOUT)
+          log.level = Logger::WARN
+          log
+        end
+      end
+    end
+  end
+end
+
+require 'em-hiredis/event_emitter'
+require 'em-hiredis/connection'
+require 'em-hiredis/client'

data/lib/vendor/em-hiredis/lib/em-hiredis/client.rb

@@ -0,0 +1,131 @@
+module EM::Hiredis
+  class Client
+    PUBSUB_MESSAGES = %w{message pmessage}.freeze
+
+    include EM::Hiredis::EventEmitter
+    include EM::Deferrable
+
+    def self.connect(host = 'localhost', port = 6379)
+      new(host, port)
+    end
+
+    def initialize(host, port)
+      @host, @port = host, port
+      @subs, @psubs = [], []
+      @defs = []
+      @connection = EM.connect(host, port, Connection, host, port)
+
+      @connection.on(:closed) {
+        if @connected
+          @defs.each { |d| d.fail("Redis disconnected") }
+          @defs = []
+          @deferred_status = nil
+          @connected = false
+          @reconnecting = true
+          reconnect
+        else
+          EM.add_timer(1) { reconnect }
+        end
+      }
+
+      @connection.on(:connected) {
+        @connected = true
+        select(@db) if @db
+        @subs.each { |s| method_missing(:subscribe, s) }
+        @psubs.each { |s| method_missing(:psubscribe, s) }
+        succeed
+
+        if @reconnecting
+          @reconnecting = false
+          emit(:reconnected)
+        end
+      }
+
+      @connection.on(:message) { |reply|
+        if RuntimeError === reply
+          raise "Replies out of sync: #{reply.inspect}" if @defs.empty?
+          deferred = @defs.shift
+          deferred.fail(reply) if deferred
+        else
+          if reply && PUBSUB_MESSAGES.include?(reply[0]) # reply can be nil
+            kind, subscription, d1, d2 = *reply
+
+            case kind.to_sym
+            when :message
+              emit(:message, subscription, d1)
+            when :pmessage
+              emit(:pmessage, subscription, d1, d2)
+            end
+          else
+            raise "Replies out of sync: #{reply.inspect}" if @defs.empty?
+            deferred = @defs.shift
+            deferred.succeed(reply) if deferred
+          end
+        end
+      }
+
+      @connected = false
+      @reconnecting = false
+    end
+
+    # Indicates that commands have been sent to redis but a reply has not yet 
+    # been received.
+    # 
+    # This can be useful for example to avoid stopping the 
+    # eventmachine reactor while there are outstanding commands
+    # 
+    def pending_commands?
+      @connected && @defs.size > 0
+    end
+
+    def subscribe(channel)
+      @subs << channel
+      method_missing(:subscribe, channel)
+    end
+
+    def unsubscribe(channel)
+      @subs.delete(channel)
+      method_missing(:unsubscribe, channel)
+    end
+
+    def psubscribe(channel)
+      @psubs << channel
+      method_missing(:psubscribe, channel)
+    end
+
+    def punsubscribe(channel)
+      @psubs.delete(channel)
+      method_missing(:punsubscribe, channel)
+    end
+
+    def select(db)
+      @db = db
+      method_missing(:select, db)
+    end
+
+    def method_missing(sym, *args)
+      deferred = EM::DefaultDeferrable.new
+      # Shortcut for defining the callback case with just a block
+      deferred.callback { |result| yield(result) } if block_given?
+
+      if @connected
+        @connection.send_command(sym, *args)
+        @defs.push(deferred)
+      else
+        callback {
+          @connection.send_command(sym, *args)
+          @defs.push(deferred)
+        }
+      end
+
+      return deferred
+    end
+
+    private
+
+    def reconnect
+      EM::Hiredis.logger.debug("Trying to reconnect to Redis")
+      @connection.reconnect @host, @port
+    end
+  end
+end