noah 0.0.5-jruby → 0.1-jruby

data/lib/noah/custom_watcher.rb

@@ -0,0 +1,79 @@
+require 'eventmachine'
+require 'uri'
+require 'logger'
+begin
+  require 'em-hiredis'
+rescue LoadError
+  puts "Please install: em-hiredis"
+end
+
+@log = Logger.new(STDOUT)
+@log.level = Logger::DEBUG
+
+require File.join(File.dirname(__FILE__), 'passthrough')
+
+module Noah
+
+  class CustomWatcher
+    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/ephemeral_routes.rb

@@ -0,0 +1,47 @@
+class Noah::App
+  get '/e/?' do
+    halt 404
+  end
+
+  get '/e/*' do
+    params["splat"].size == 0 ? (halt 404) : (e=Noah::Ephemeral.find(:path => "/#{params["splat"][0]}").first)
+    (halt 404) if e.nil?
+    content_type "application/octet-stream"
+    e.data.nil? ? "" : "#{e.data}"
+  end
+
+  put '/e/*/watch' do
+    required_params = ["endpoint"]
+    data = JSON.parse(request.body.read)
+    (data.keys.sort == required_params.sort) ? (e = Noah::Watcher.find(:path => params[:splat][0]).first) : (raise "Missing Parameters")
+    e.nil? ? (halt 404) : (w = e.watch!(:endpoint => data["endpoint"]))
+    w.to_json
+  end
+
+  put '/e/*' do
+    raise("Data too large") if request.body.size > 512
+    d = request.body.read  || nil
+    opts = {:path => "/#{params[:splat][0]}", :data => d}
+    e = Noah::Ephemeral.find_or_create(opts)
+    if e.valid?
+      action = e.is_new? ? "create" : "update"
+      r = {"action" => action, "result" => "success", "id" => e.id, "path" => e.path, "data" => e.data}
+      r.to_json
+    else
+      raise "#{format_errors(e)}"
+    end
+  end
+
+  delete '/e/*' do
+    p = params[:splat][0]
+    e = Noah::Ephemeral.find(:path => "/"+p).first
+    if e
+      e.delete
+      r = {"result" => "success", "id" => "#{e.id}", "action" => "delete", "path" => e.name}
+      r.to_json
+    else
+      halt 404
+    end
+  end
+
+end

data/lib/noah/helpers.rb

@@ -1,56 +1,79 @@
-require File.join(File.dirname(__FILE__), 'models')
 module Noah
   module SinatraHelpers
-  extend(Ohm)
+    
+    def format_errors(model)
+      error_messages = model.errors.present do |e|
+        # Missing attributes
+        e.on [:name, :not_present], "Name attribute missing"
+        e.on [:status, :not_present], "Status attribute missing"
+        e.on [:format, :not_present], "Format attribute missing"
+        e.on [:body, :not_present], "Body attribute missing"
+        e.on [:application_id, :not_present], "Application attribute missing"
+        e.on [:path, :not_present], "Path attribute missing"
+        e.on [:pattern, :not_present], "Pattern attribute missing"
+        e.on [:endpoint, :not_present], "Endpoint attribute missing"
+        # Invalid option
+        e.on [:status, :not_member], "Status must be up, down or pending"
+        # Duplicate keys
+        e.on [[:name, :application_id], :not_unique], "Record already exists"
+        e.on [[:name, :host_id], :not_unique], "Record already exists"
+        e.on [[:endpoint, :pattern], :not_unique], "Record already exists"
+        e.on [:path, :not_unique], "Record already exists"
+        # Custom exceptions
+        e.on [:pattern, :already_provided], "Pattern is already provided"
+        e.on [:pattern, :replaces_existing], "Pattern would overwrite existing"
+      end
+      error_messages.first
+    end
 
     def host(opts = {})
-     Host.find(opts).first
+      Noah::Host.find(opts).first
     end
 
     def hosts(opts = {})
-      Hosts.all(opts)
+      Noah::Hosts.all(opts)
     end
 
     def service(opts = {})
-      Service.find(options)
+      Noah::Service.find(options)
     end
 
     def services(opts = {})
-      Services.all(opts)
+      Noah::Services.all(opts)
     end 
 
     def host_service(hostname, servicename)
-      h = Host.find(:name => hostname).first
+      h = Noah::Host.find(:name => hostname).first
       if h.nil?
         nil
       else  
-        Service.find(:host_id => h.id, :name => servicename).first
+        Noah::Service.find(:host_id => h.id, :name => servicename).first
       end  
     end
 
     def host_services(hostname)
-      h = Host.find(:name => hostname).first
+      h = Noah::Host.find(:name => hostname).first
       if h.nil?
         nil
       else  
-        Services.all(:host_id => id)
+        Noah::Services.all(:host_id => id)
       end  
     end 
 
     def application(opts = {})
-      Application.find(opts).first
+      Noah::Application.find(opts).first
     end
 
     def applications(opts = {})
-      Applications.all(opts)
+      Noah::Applications.all(opts)
     end
 
     def configuration(opts = {})
-      Configuration.find(opts).first
+      Noah::Configuration.find(opts).first
     end
 
     def configurations(opts = {})
-      Configurations.all(opts)
+      Noah::Configurations.all(opts)
     end
   end
 

data/lib/noah/host_routes.rb

@@ -0,0 +1,69 @@
+class Noah::App
+# Host URIs
+
+  # GET named {Service} for named {Host}
+  get '/h/:hostname/:servicename/?' do |hostname, servicename|
+    h = host_service(hostname, servicename)
+    if h.nil?
+      halt 404
+    else
+      h.to_json
+    end
+  end
+
+  # GET named {Host}
+  # @param :hostname name of {Host}
+  # @return [JSON] representation of {Host}
+  get '/h/:hostname/?' do |hostname|
+    h = host(:name => hostname)
+    if h.nil?
+      halt 404
+    else
+      h.to_json
+    end
+  end
+
+  # GET all {Hosts}
+  get '/h/?' do
+    hosts.map {|h| h.to_hash}
+    if hosts.size == 0
+      halt 404
+    else
+      hosts.to_json
+    end
+  end
+
+  put '/h/:hostname/watch' do |hostname|
+    required_params = ["endpoint"]
+    data = JSON.parse(request.body.read)
+    (data.keys.sort == required_params.sort) ? (h = Noah::Host.find(:name => hostname).first) : (raise "Missing Parameters")
+    h.nil? ? (halt 404) : (w = h.watch!(:endpoint => data['endpoint']))
+    w.to_json
+  end
+
+  put '/h/:hostname/?' do |hostname|
+    required_params = ["name", "status"]
+    data = JSON.parse(request.body.read)
+    (data.keys.sort == required_params.sort && data['name'] == hostname) ? (host = Noah::Host.find_or_create(:name => data['name'], :status => data['status'])) : (raise "Missing Parameters")
+    if host.valid?
+      r = {"result" => "success","id" => "#{host.id}","status" => "#{host.status}", "name" => "#{host.name}", "new_record" => host.is_new?}
+      r.to_json
+    else
+      raise "#{format_errors(host)}"
+    end
+  end
+
+  delete '/h/:hostname/?' do |hostname|
+    host = Noah::Host.find(:name => hostname).first
+    if host
+      services = []
+      Noah::Service.find(:host_id => host.id).sort.each {|x| services << x; x.delete} if host.services.size > 0
+      host.delete
+      r = {"result" => "success", "id" => "#{host.id}", "name" => "#{hostname}", "service_count" => "#{services.size}"}
+      r.to_json
+    else
+      halt 404
+    end
+  end
+
+end

data/lib/noah/models.rb

@@ -1,5 +1,86 @@
-require File.join(File.dirname(__FILE__),'hosts')
-require File.join(File.dirname(__FILE__),'services')
-require File.join(File.dirname(__FILE__),'applications')
-require File.join(File.dirname(__FILE__),'configurations')
-require File.join(File.dirname(__FILE__),'watchers')
+require 'ohm'
+require 'ohm/contrib'
+module Noah
+  class Model < Ohm::Model
+    def self.inherited(model)
+
+      model.send :include, Ohm::Timestamping
+      model.send :include, Ohm::Typecast
+      model.send :include, Ohm::Callbacks
+      model.send :include, Ohm::ExtraValidations
+
+      # removing this as it's simply redundant
+      # model.after :save, :notify_via_redis_save
+      model.after :create, :notify_via_redis_create
+      model.after :update, :notify_via_redis_update
+      model.before :delete, :stash_name
+      model.after :delete, :notify_via_redis_delete
+      model.send :include, ModelClassMethods
+    end
+  end
+
+  module ModelClassMethods
+
+    def is_new?
+      self.created_at == self.updated_at
+    end
+
+
+    def watch!(opts={:endpoint => nil, :pattern => nil})
+      base_pattern = "#{self.patternize_me}"
+      opts[:endpoint].nil? ? (raise ArgumentError, "Need an endpoint") : endpoint=opts[:endpoint]
+      opts[:pattern].nil? ? pattern=base_pattern : pattern=opts[:pattern]
+
+      begin
+        w = Watcher.new :pattern => pattern, :endpoint => endpoint
+        w.valid? ? w.save : (raise "#{w.errors}")
+        w.name
+      rescue Exception => e
+        e.message
+      end
+    end
+      
+    protected
+    def patternize_me
+      "//noah/#{self.class_to_lower}/#{name}"
+    end
+
+    def stash_name
+      @deleted_name = self.name
+    end
+
+    def class_to_lower
+      self.class.to_s.gsub(/(.*)::(\w)/,'\2').downcase
+    end
+    def dbnum
+      o = Ohm.options.first
+      return "0" if o.nil?
+      return "0" if (o[:db].nil? && o[:url].nil?)
+      o[:db].nil? ? "#{o[:url].split('/').last}" : "#{o[:db]}"
+    end
+
+    ["create", "update", "delete"].each do |meth|
+      class_eval do
+        define_method("notify_via_redis_#{meth}".to_sym) do
+          db = self.dbnum
+          self.name.nil? ? name=@deleted_name : name=self.name
+          # Pulling out dbnum for now. Need to rethink it
+          #pub_category = "#{db}:noah.#{self.class.to_s}[#{name}].#{meth}"
+          pub_category = "#{self.patternize_me}"
+          Ohm.redis.publish(pub_category, self.to_hash.merge({"action" => meth, "pubcategory" => pub_category}).to_json)
+
+          # The following provides a post post-action hook. It allows a class to provide it's own handling after the fact
+          # good example is in [Noah::Ephemeral] where it's used to check for/clean up expired ephemeral nodes entries
+          self.send("#{meth}_hook".to_sym) unless self.protected_methods.member?("#{meth}_hook".to_sym) == false
+        end
+      end
+    end
+
+  end
+end
+require File.join(File.dirname(__FILE__), 'models','hosts')
+require File.join(File.dirname(__FILE__), 'models','services')
+require File.join(File.dirname(__FILE__), 'models','applications')
+require File.join(File.dirname(__FILE__), 'models','configurations')
+require File.join(File.dirname(__FILE__), 'models','watchers')
+require File.join(File.dirname(__FILE__), 'models','ephemerals')

data/lib/noah/models/applications.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), 'configurations')
+module Noah
+  class Application < Model
+    attribute :name
+    collection :configurations, Configuration
+
+    index :name
+
+    def validate
+      super
+      assert_present :name
+    end
+
+    def to_hash
+      arr = []
+      configurations.sort.each {|c| arr << c.to_hash}
+      super.merge(:name => name, :created_at => created_at, :updated_at => updated_at, :configurations => arr)
+    end
+
+    class << self
+    def find_or_create(opts = {})
+      begin
+        find(opts).first.nil? ? (app = create(opts)) : (app = find(opts).first)
+        if app.valid?
+          app.save
+        end
+        app
+      rescue Exception => e
+        e.message
+      end
+    end
+    end
+
+  end
+
+  class Applications
+    def self.all(options = {})
+      options.empty? ? Application.all.sort : Application.find(options).sort
+    end
+  end
+end

data/lib/noah/models/configurations.rb

@@ -0,0 +1,49 @@
+module Noah
+  class Configuration < Model
+
+    attribute :name
+    attribute :format
+    attribute :body
+    attribute :new_record
+    reference :application, Application
+
+    index :name
+    index :format
+    index :body
+
+    def validate
+      super
+      assert_present :name
+      assert_present :format
+      assert_present :body
+      assert_present :application_id
+      assert_unique [:name, :application_id]
+    end
+
+    def to_hash
+      Application[application_id].nil? ? app_name=nil : app_name=Application[application_id].name
+      super.merge(:name => name, :format => format, :body => body, :created_at => created_at, :updated_at => updated_at, :application => app_name)
+    end
+
+    class << self
+    def find_or_create(opts={})
+      begin
+        if find(opts).first.nil?
+          conf = create(opts)
+        else  
+          conf = find(opts).first
+        end  
+      rescue Exception => e
+        e.message
+      end
+    end
+    end
+
+  end
+
+  class Configurations
+    def self.all(options = {})
+      options.empty? ? Configuration.all.sort : Configuration.find(options).sort
+    end
+  end 
+end