vayacondios-server 0.0.4

data/bin/vcd.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+
+cmd="${1-help}"
+
+vcd_server_url='http://localhost:9000'
+
+case "$cmd" in
+help|--help)
+    echo "commands: "
+    echo "  vcd hola foo/bar '{...json hash...}' -- dispatches the hash to the foo/bar bucket on the  vayacondios server"
+    echo "  vcd help                             -- this text"
+    echo ""
+    echo "example: "
+    echo "  $0 hola just/fiddlin '{\"hi\":\"there\"}'"
+    echo ""
+    ;;
+
+hola)
+    bucket="$2"
+    facts="$3"
+    if [ -z "$bucket" ] || [ -z "$facts" ] ; then echo "vcd hola foo/bar '{...json hash...}'" ; echo "  got '$bucket' '$fact'" ; exit -1 ; fi
+
+    echo -- curl -H 'Content-Type:application/json' -d "'$facts'" "'$vcd_server_url/$bucket'"
+    curl -H 'Content-Type:application/json' -d "$facts" "$vcd_server_url/$bucket"
+    ;;
+
+esac

data/config/http_shim.rb

@@ -0,0 +1,43 @@
+def ENV.root_path(*args)
+  File.expand_path(File.join(File.dirname(__FILE__), '..', *args))
+end
+
+require 'configliere'
+Settings.define :app_name,    :default => 'vayacondios', :description => 'Name to key on for tracer stats, statsd metrics, etc.'
+Settings.define 'mongo.host', :default => 'localhost',   :description => 'Mongo hostname'
+Settings.define 'mongo.port', :default => '27017',       :description => 'Mongo port'
+
+Settings.read(ENV.root_path('config/vayacondios.yaml'))
+Settings.resolve!
+
+config[:server] = {
+  :nodename => ENV['NODENAME'],
+  :hostname => `hostname`.chomp,
+  :program  => File.expand_path($0),
+  :version  => `git log | head -n1`.chomp.split[1],
+  :pid      => Process.pid,
+}
+
+environment(:production) do
+  Settings[:environment] = config[:environment] = 'production'
+  config['mongo'] = EventMachine::Synchrony::ConnectionPool.new(:size => 20) do
+    conn = EM::Mongo::Connection.new(Settings[:mongo][:host], Settings[:mongo][:port], 1, {:reconnect_in => 1})
+    conn.db(Settings[:mongo][:database])
+  end
+end
+
+environment(:development) do
+  Settings[:environment] = config[:environment] = 'development'
+  conn = EM::Mongo::Connection.new(Settings[:mongo][:host],Settings[:mongo][:port], 1, {:reconnect_in => 1})
+  config['mongo'] = conn.db(Settings[:mongo][:database])
+end
+
+environment(:test) do
+  Settings[:environment] = config[:environment] = 'test'
+  conn = EM::Mongo::Connection.new(Settings[:mongo][:host],Settings[:mongo][:port], 1, {:reconnect_in => 1})
+  config['mongo'] = conn.db(Settings[:mongo][:database])
+end
+
+# def config.inspect
+#   self.reject{|k, v| /#{DB_NAME}/ =~ k.to_s}.inspect
+# end

data/config/vayacondios.example.yaml

@@ -0,0 +1,4 @@
+mongo:
+  host:         localhost
+  port:         27017
+  database:     vayacondios_dev

data/config/vayacondios.yaml

@@ -0,0 +1,4 @@
+mongo:
+  host:         localhost
+  port:         27017
+  database:     vayacondios_dev

data/lib/tasks/publish.rake

@@ -0,0 +1,23 @@
+$:.push File.expand_path('..', __FILE__)
+require 'vayacondios/version'
+
+Dir['*.gemspec'].each do |gemspec|
+  gem_name = gemspec.gsub(/\.gemspec/, '')
+
+  desc "Build #{gem_name} gem into the pkg directory"
+  task "build_#{gem_name}" do
+    FileUtils.rm_rf('pkg')
+    system "gem build #{gemspec}"
+    FileUtils.mkdir_p('pkg')
+    FileUtils.mv(Dir['*.gem'], 'pkg')
+  end
+
+  desc "Tags version, pushes to remote, and pushes #{gem_name} gem"
+  task "release_#{gem_name}" =>  "build_#{gem_name}" do
+    sh 'git', 'tag', '-m', "releasing #{gem_name}", "#{gem_name}-v#{Vayacondios::VERSION}"
+    branch = `git branch | awk -F '/* ' '{print $2}'`.strip
+    sh "git push origin #{branch}"
+    sh "git push origin v#{Vayacondios::VERSION}"
+    sh "ls pkg/#{gem_name}*.gem | xargs -n 1 gem push"
+  end
+end

data/lib/tasks/spec.rake

@@ -0,0 +1,9 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+namespace :spec do
+  # RSpec::Core::RakeTask.new :coverage do
+  #   ENV['COVERAGE'] = "true"
+  # end
+end

data/lib/tasks/yard.rake

@@ -0,0 +1,2 @@
+require 'yard'
+YARD::Rake::YardocTask.new

data/lib/vayacondios/client/configliere.rb

@@ -0,0 +1,38 @@
+class Vayacondios
+  module Configliere
+
+    def load_from_vayacondios(organization, id, options = {})
+      options.symbolize_keys!.deep_merge!(organization: organization)
+
+      client = ::Vayacondios::HttpClient.receive(options.deep_compact!)
+      id     = [id, options[:env]].compact.join('.')
+      
+      begin
+        new_data = client.fetch(:config, id)
+      rescue ::Vayacondios::HttpClient::Error
+        warn "Unable to load vayacondios config '#{id}' for #{organization} at: #{client.host}:#{client.port}"
+        new_data = {}
+      end
+      deep_merge! new_data
+      self
+    end
+    
+    def save_to_vayacondios(organization, id, options = {})
+      options.symbolize_keys!.deep_merge!(organization: organization)
+
+      client = ::Vayacondios::HttpClient.receive(options.deep_compact!)
+      id = [id, options[:env]].compact.join('.')
+      
+      begin
+        client.insert(self.to_hash, :config, id)
+      rescue ::Vayacondios::HttpClient::Error
+        warn "Unable to save vayacondios config '#{id}' for #{organization} at: #{client.host}:#{client.port}"
+      end
+      self
+    end
+  end
+end
+
+::Configliere::Param.class_eval do
+  include ::Vayacondios::Configliere
+end

data/lib/vayacondios/client/http_client.rb

@@ -0,0 +1,49 @@
+class Vayacondios
+  class HttpClient
+    include Gorillib::Builder
+
+    field :host,         String,  :default => 'localhost'
+    field :port,         Integer, :default => 8000
+    field :organization, String,  :default => 'infochimps'
+    
+    class Error < StandardError; end
+
+    def uri
+      return @uri if @uri
+
+      uri_str  = "http://#{host}:#{port}/v1"
+      uri_str += "/#{organization}" if organization
+      @uri ||= URI(uri_str)
+    end
+    
+    def fetch(type, id)
+      request(:get, type, id)
+    end
+    
+    def insert(document = {}, type = nil, id = nil)
+      id   ||= document.delete(:_id)   || document.delete('_id')
+      type ||= document.delete(:_type) || document.delete('_type')
+      
+      request(:post, type, id, MultiJson.dump(document))
+    end
+    
+  private
+    
+    def request(method, type, id = nil, document = nil)
+      path    = File.join(uri.path, type.to_s, *id.to_s.split(/\W/))
+      http    = Net::HTTP.new(uri.host, uri.port)
+
+      params  = [method.to_sym, path]
+      params += [document, {'Content-Type' => 'application/json'}] unless document.nil?
+      
+      response = http.send *params
+
+      if Net::HTTPSuccess === response
+        MultiJson.load(response.body) rescue response.body
+      else
+        raise Error.new("Error (#{response.code}) while #{method.to_s == 'get' ? 'fetching' : 'inserting'} document: " + response.body)
+      end
+    end
+  end
+end
+  

data/lib/vayacondios/client/notifier.rb

@@ -0,0 +1,84 @@
+class Vayacondios
+
+  class_attribute :notifier
+
+  class Notifier < Vayacondios
+    attr_accessor :client
+
+    def prepare(obj)
+      case
+      when obj.respond_to?(:to_inspectable) then obj.to_inspectable
+      when obj.respond_to?(:to_wire)        then obj.to_wire
+      when obj.respond_to?(:to_hash)        then obj.to_hash
+      else
+        raise ArgumentError.new("Cannot notify '#{obj.inspect}' -- require a hash-like object.")
+      end
+    end
+
+    def notify(topic, cargo = {})
+      NoMethodError.unimplemented_method(self)
+    end
+  end
+
+  class LogNotifier < Notifier
+
+    def initialize(options = {})
+      @client = options[:log] || Log
+    end
+
+    def notify(topic, cargo = {})
+      prepped  = prepare(cargo)
+      level    = prepped.delete(:level) || :info
+      message  = "Notification: #{topic.inspect}."
+      message += " Reason: #{prepped.delete(:reason)}." if prepped[:reason]
+      message += " Cargo: #{prepped.inspect}"
+      client.send(level, message)
+    end
+  end
+
+  class HttpNotifier < Notifier
+
+    def initialize(options = {})
+      @client = Vayacondios::HttpClient.receive(options)
+    end
+
+    def notify(topic, cargo = {})
+      prepped = prepare(cargo)
+      client.insert(prepped, :event, topic)
+      nil
+    end
+  end
+
+  class NotifierFactory
+    def self.receive(attrs = {})
+      type = attrs.delete(:type)
+      case type
+      when 'http' then HttpNotifier.new(attrs)
+      when 'log'  then LogNotifier.new(attrs)
+      else
+        raise ArgumentError, "<#{type}> is not a valid build option"
+      end
+    end
+  end
+
+  def self.default_notifier() NotifierFactory.receive(type: 'http') ; end
+
+  module Notifications
+    extend Gorillib::Concern
+    include Gorillib::Configurable
+
+    def notify(topic, cargo = {})
+      notifier.notify(topic, cargo)
+    end
+
+    included do
+      class_eval do
+        config(:notifier, Vayacondios::NotifierFactory, default: Vayacondios.default_notifier)
+      end
+    end
+
+  end
+
+  extend Notifications
+  self.notifier = default_notifier
+end

data/lib/vayacondios/server/handlers/config_handler.rb

@@ -0,0 +1,35 @@
+# Vayacondios::ConfigHandler
+#
+# This handler will accept requests to update config for an organization. All
+# updates will merge with an existing document.
+
+class Vayacondios
+
+  class ConfigHandler
+
+    def initialize(mongodb)
+      @mongo = mongodb
+    end
+
+    def update(document, options={})
+      existing_document = ConfigDocument.find(@mongo, options)
+      if existing_document
+        existing_document.update(document)
+      else
+        existing_document = ConfigDocument.create(@mongo, document, options)
+      end
+
+      {
+        topic: existing_document.topic,
+        cargo: existing_document.body,
+        status: :success
+      }
+    end
+
+    def self.find(mongodb, options)
+      existing_document = ConfigDocument.find(mongodb, options)
+      return nil unless existing_document
+      existing_document.body
+    end
+  end
+end

data/lib/vayacondios/server/handlers/event_handler.rb

@@ -0,0 +1,30 @@
+# Vayacondios::EventHandler
+#
+# This handler will accept requests to update Event for an organization. All
+# updates will overwrite an existing document.
+
+class Vayacondios
+
+  class EventHandler
+
+    def initialize(mongodb)
+      @mongo = mongodb
+    end
+
+    def update(document, options={})
+      existing_document = EventDocument.find(@mongo, options)
+      if existing_document
+        existing_document.update(document)
+      else
+        existing_document = EventDocument.create(@mongo, document, options)
+      end
+      existing_document.body
+    end
+
+    def self.find(mongodb, options)
+      existing_document = EventDocument.find(mongodb, options)
+      return nil unless existing_document
+      existing_document.body
+    end
+  end
+end

data/lib/vayacondios/server/model/config_document.rb

@@ -0,0 +1,94 @@
+require 'vayacondios/server/model/document'
+
+# The configuration model
+#
+# Configuration documents are key-value pairs, represented in JSON. A document
+# consists of a primary key called the topic (_id in mongodb). It belongs to a
+# collection named "#{organization_name}.config"
+#
+# Note: mongodb is passed in beacuse Goliath makes Thread lookups will not
+# work while Goliath is in a streaming context.
+
+class Vayacondios::ConfigDocument < Vayacondios::Document
+  attr_reader :organization, :topic, :body
+
+  def initialize(mongodb, options = {})
+    super options
+    @mongo = mongodb
+    options = sanitize_options(options)
+
+    @body         = nil
+    @field        = options[:field] ||= options[:id]
+    @mongo        = mongodb
+
+    collection_name = [organization.to_s, 'config'].join('.')
+    @collection = @mongo.collection(collection_name)
+  end
+
+  def self.create(mongodb, document, options={})
+    self.new(mongodb, options).update(document)
+  end
+
+  def self.find(mongodb, options={})
+    self.new(mongodb, options).find
+  end
+
+  def find
+    fields = {}
+    fields[@field] = 1 if @field
+
+    result = @collection.find_one({_id: @topic}, {fields: @fields})
+    if result.present?
+      result.delete("_id")
+      @body = result
+      # @body = @field.split('.').inject(result){|acc, attr| acc = acc[attr]} if @field.present?
+      self
+    else
+      nil
+    end
+  end
+
+  def update(document)
+    # MongoDB always wants a Hash. If we POST to /org/topic/users/jim/username
+    # with "jimmy", we transform the document to {username: "jimmy"}
+    if !document.is_a?(Hash)
+      document = {@field.split(/\W/).last.to_sym => document}
+    end
+
+    # Merge ourselves
+    document = deep_merge(document)
+
+    fields = document
+    # fields = {@field => document} if @field.present?
+
+    @body = document
+    @collection.update({:_id => @topic}, {'$set' => fields}, {upsert: true})
+
+    self
+  end
+
+  def destroy(document)
+    super
+  end
+
+  protected
+
+  def sanitize_options(options)
+    options = options.symbolize_keys
+
+    topic = options[:topic]
+
+    if (topic.is_a?(Hash) && topic["$oid"].present?)
+      topic = BSON::ObjectId(topic["$oid"])
+    elsif topic.is_a?(String)
+      topic = topic.gsub(/\W/,'')
+      if topic.to_s.match(/^[a-f0-9]{24}$/)
+        topic = BSON::ObjectId(topic)
+      end
+    end
+
+    field = options[:field].gsub(/\W/, '') if options[:field].present?
+
+    options.merge(topic: topic, field: field)
+  end
+end