vayacondios-server 0.2.11 → 0.3.0

data/examples/java/ItemSetTest.java

@@ -1,76 +0,0 @@
-import com.infochimps.vayacondios.Organization;
-import com.infochimps.vayacondios.VayacondiosClient;
-import com.infochimps.vayacondios.ItemSets;
-import static com.infochimps.vayacondios.ItemSets.Item;
-import static com.infochimps.vayacondios.ItemSets.ItemSet;
-
-import java.io.*;
-import java.util.*;
-
-public class ItemSetTest {
-  private static final int VCD_PORT = 8000;
-
-  public static void main(String argv[]) throws IOException {
-    // Instantiate a new Vayacondios client.
-    VayacondiosClient client = new VayacondiosClient("localhost", VCD_PORT);
-
-    // Organizations can allow for testing and multiple environments
-    // (staging, development).
-    Organization org = client.organization("test");
-
-    // At the moment, only the itemsets protocol is supported via a
-    // Java API.
-    ItemSets isets = org.itemsets();
-
-    List<Item> foobar = Arrays.asList(new Item("foo"), new Item("bar"));
-
-    // All of the following are equivalent ways to clobber the itemset
-    // at topic my_topic and id my_id, replacing it with the items
-    // "foo" and "bar." The first and second exist to avoid
-    // instantiating new objects repeatedly when a code path must
-    // access many different topics and ids.
-    isets                                   .create("my_topic", "my_id", foobar);
-    isets.topic("my_topic")                 .create(            "my_id", foobar);
-    isets.topic("my_topic").itemSet("my_id").create(                     foobar);
-
-    List<Item> fetched;
-
-    // Similarly, these are all equivalent ways to fetch items.
-    fetched = isets                                   .fetch("my_topic", "my_id");
-    fetched = isets.topic("my_topic")                 .fetch(            "my_id");
-    fetched = isets.topic("my_topic").itemSet("my_id").fetch(                   );
-
-    ItemSet iset = isets.topic("my_topic").itemSet("my_id");
-
-    // foo and bar will be printed, along with their types: STRING
-    System.out.println("fetched items: " + fetched);
-
-    List<Item> bazqux = Arrays.asList(new Item("baz"), new Item("qux"));
-
-    // Updating an itemset with a list of items ensures the presence
-    // in the itemset of all of the items in the specified list.
-    isets                                   .update("my_topic", "my_id", bazqux);
-    isets.topic("my_topic")                 .update(            "my_id", bazqux);
-    isets.topic("my_topic").itemSet("my_id").update(                     bazqux);
-
-    // foo, bar, baz, and qux will all be printed.
-    System.out.println("after update: " + iset.fetch());
-
-    List<Item> barbaz = Arrays.asList(new Item("bar"), new Item("baz"));
-
-    // Updating an itemset with a list of items ensures the presence
-    // in the itemset of all of the items in the specified list.
-    isets                                   .remove("my_topic", "my_id", barbaz);
-    isets.topic("my_topic")                 .remove(            "my_id", barbaz);
-    isets.topic("my_topic").itemSet("my_id").remove(                     barbaz);
-
-    // foo and qux will now be printed
-    System.out.println("after removing: " + iset.fetch());
-
-    // Create an empty itemset to effectively delete it.
-    iset.create(Collections.EMPTY_LIST);
-
-    // foo and qux will now be printed
-    System.out.println("after deletion: " + iset.fetch());
-  }
-}

data/lib/tasks/publish.rake

@@ -1,23 +0,0 @@
-$:.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 #{gem_name}-v#{Vayacondios::VERSION}"
-    sh "ls pkg/#{gem_name}*.gem | xargs -n 1 gem push"
-  end
-end

data/lib/tasks/spec.rake

@@ -1,11 +0,0 @@
-# -*- ruby -*-
-
-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

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

data/lib/vayacondios/client/config.rb

@@ -1,7 +0,0 @@
-def ENV.root_path(*args)
-  File.expand_path(File.join(File.dirname(__FILE__), '../../../', *args))
-end
-
-require 'configliere'
-
-Settings.read(ENV.root_path('config/vayacondios.yaml'))

data/lib/vayacondios/client/configliere.rb

@@ -1,38 +0,0 @@
-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/cube_client.rb

@@ -1,39 +0,0 @@
-class Vayacondios
-  class CubeClient
-    include Gorillib::Model
-
-    field :host,         String,  :default => 'localhost'
-    field :port,         Integer, :default => 6000
-    
-    class Error < StandardError; end
-
-    def uri
-      return @uri if @uri
-
-      uri_str  = "http://#{host}:#{port}/1.0"
-      @uri ||= URI(uri_str)
-    end
-    
-    def event(topic, document = {})
-      request(:post, File.join(uri.path, 'event'), MultiJson.dump(document))
-    end
-    
-  private
-    
-    def request(method, path, document=nil)
-      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/http_client.rb

@@ -1,49 +0,0 @@
-class Vayacondios
-  class HttpClient
-    include Gorillib::Model
-
-    field :host,         String, :default => 'localhost'
-    field :port,         String, :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/itemset.rb

@@ -1,130 +0,0 @@
-require 'gorillib/logger/log'
-require 'net/http'
-require 'multi_json'
-require_relative 'config'
-require_relative 'legacy_switch'
-
-class Vayacondios
-  class Client
-    class ItemSet
-      def initialize host, port, organization=nil, topic=nil, id=nil
-        @host         = host
-        @port         = port
-        @organization = organization
-        @topic        = topic
-        @id           = id
-      end
-
-      def fetch organization=nil, topic=nil, id=nil
-        resp = execute_request(_req(:fetch, nil, organization, topic, id)) and
-          Vayacondios.legacy_switch.extract_response(resp)
-      end
-
-      def update ary, organization=nil, topic=nil, id=nil
-        execute_request(_req(:update, ary, organization, topic, id))
-      end
-
-      def create ary, organization=nil, topic=nil, id=nil
-        execute_request(_req(:create, ary, organization, topic, id))
-      end
-
-      def remove ary, organization=nil, topic=nil, id=nil
-        execute_request(_req(:remove, ary, organization, topic, id))
-      end
-
-      private
-
-      def execute_request req
-        begin
-          resp = Net::HTTP.start(@host, @port) do |http|
-            http.request(req)
-          end.body
-          result = MultiJson.decode(resp) unless resp.nil? or resp.empty?
-          (result.respond_to?(:has_key?) and result.has_key? "error") ? nil : result
-        rescue StandardError => ex
-          Log.warn("problem contacting vayacondios: #{ex.message}")
-          Log.debug(ex.backtrace.join("\n"))
-          nil
-        end
-      end
-
-      def path organization, topic, id
-        if ((the_organization = (organization || @organization)).nil? ||
-            (the_topic        = (topic        || @topic       )).nil? ||
-            (the_id           = (id           || @id          )).nil?)
-          raise ArgumentError.new("must provide organization, topic, and id!")
-        end
-
-        ['/v1', the_organization, 'itemset', the_topic, the_id].join("/")
-      end
-
-      # This is the only private method that is tested.
-      def _req type, ary=nil, organization=nil, topic=nil, id=nil
-
-        the_path = path(organization, topic, id)
-        headers = {"content-type" => "application/json"}
-        headers.merge!("x-method" => "PATCH") if type == :update
- 
-        case type
-        when :fetch  then Net::HTTP::Get
-        when :create then Net::HTTP::Put
-        when :update then Net::HTTP::Put
-        when :remove then Net::HTTP::Delete
-        else         raise ArgumentError.new("invalid type: #{type}")
-        end.new(the_path, headers).tap do |req|
-          unless type == :fetch
-            req.body =
-              MultiJson.encode(Vayacondios.legacy_switch.wrap_contents(ary))
-          end
-        end
-      end
-    end
-
-    # Subclasses should implement the remove_items(arr) and
-    # add_items(arr) methods, both of which will be called with arrays
-    # when the items in an itemset change. The run method polls the
-    # provided itemset at a specified interval and calls these methods
-    # appropriately.
-    class ItemSetListener
-      POLL_WAIT_SEC=2
-
-      def initialize itemset, poll_wait_sec = POLL_WAIT_SEC
-        @itemset = itemset
-        @items = []
-        @poll_wait_sec = poll_wait_sec
-      end
-
-      def run
-        setup
-        loop do
-          new_items = @itemset.fetch || []
-
-          Log.debug "currently configured: #{@items.inspect}"
-          Log.debug "new items: #{new_items.inspect}"
-
-          add_items(new_items - @items)
-          remove_items(@items - new_items)
-
-          @items = new_items
-
-          sleep @poll_wait_sec
-        end
-        teardown
-      end
-
-      protected
-
-      def add_items
-        raise NoMethodError.new("class #{self.class.name} must override add_items")
-      end
-
-      def remove_items
-        raise NoMethodError.new("class #{self.class.name} must override remove_items")
-      end
-
-      def setup() end
-      def teardown() end
-
-    end
-  end
-end

data/lib/vayacondios/client/legacy_switch.rb

@@ -1,43 +0,0 @@
-require 'gorillib/logger/log'
-
-class Vayacondios
-  # Are we operating on JSON Hashes (Vayacondios) or on JSON arrays
-  # (Vayacondios Legacy)? These classes determine which to use.
-
-  class StandardContentsHandler
-    def wrap_contents(contents) {contents: contents} end
-    def extract_contents(document) document['contents'] end
-    def extract_response(document) document['contents'] end
-    def proper_request(document) true end
-  end
-
-  class LegacyContentsHandler
-    def wrap_contents(contents) contents end
-    def extract_contents(document) document end
-    def extract_response(document) document end
-    def proper_request(document) true end
-  end
-
-  @@legacy_switch = nil
-
-  def self.legacy_switch
-    if @@legacy_switch.nil?
-      legacy_mode_on = Settings[:vayacondios][:legacy]
-      @@legacy_switch = get_legacy_switch(legacy_mode_on)
-      Log.info("using #{legacy_mode_on ? 'legacy' : 'standard'} mode")
-    end
-    @@legacy_switch
-  end
-
-  def self.force_legacy_mode on
-    Log.info("forcing #{on ? 'legacy' : 'standard'} mode")
-    @@legacy_switch = get_legacy_switch on
-  end
-
-  private
-
-  def self.get_legacy_switch on
-    (on ? LegacyContentsHandler : StandardContentsHandler).new
-  end
-end
-

data/lib/vayacondios/client/notifier.rb

@@ -1,123 +0,0 @@
-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 NullNotifier < Notifier
-    def initialize(*args) ; end
-    
-    def notify topic, cargo={}
-    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 CubeNotifier < Notifier
-    def initialize(options={})
-      @client = Vayacondios::CubeClient.receive(options)
-    end
-    def notify topic, cargo={}
-      prepped = prepare(cargo)
-      client.event(topic, prepped)
-      nil
-    end
-  end
-
-  class ZabbixNotifier < Notifier
-    def initialize options={}
-      @client = Vayacondios::ZabbixClient.receive(options)
-    end
-    def notify(topic, cargo={})
-      prepped = prepare(cargo)
-      client.insert(topic, prepped)
-    end
-  end
-  
-  class NotifierFactory
-    def self.receive(attrs = {})
-      type = attrs[:type]
-      case type
-      when 'http'        then HttpNotifier.new(attrs)
-      when 'cube'        then CubeNotifier.new(attrs)
-      when 'zabbix'      then ZabbixNotifier.new(attrs)
-      when 'log'         then LogNotifier.new(attrs)
-      when 'none','null' then NullNotifier.new(attrs)
-      else
-        raise ArgumentError, "<#{type}> is not a valid build option"
-      end
-    end
-  end
-
-  def self.default_notifier(log = nil) NotifierFactory.receive(type: 'log', log: log) ; end
-
-  module Notifications
-
-    def notify(topic, cargo = {})
-      notifier.notify(topic, cargo)
-    end
-
-    def self.included klass
-      if klass.ancestors.include? Gorillib::Model
-        klass.class_eval do
-          field :notifier, Vayacondios::NotifierFactory, default: Vayacondios.default_notifier, :doc => "Notifier used to notify out of band data"
-          
-          def receive_notifier params
-            params.merge!(log: try(:log)) if params[:type] == 'log'
-            @notifier = Vayacondios::NotifierFactory.receive(params)
-          end
-        end
-      else
-        klass.class_attribute :notifier
-        klass.notifier = Vayacondios.default_notifier try(:log)
-      end
-    end
-
-  end
-
-  extend Notifications
-  self.notifier = default_notifier
-end

data/lib/vayacondios/client/zabbix_client.rb

@@ -1,148 +0,0 @@
-require 'socket'
-
-class Vayacondios
-
-  # Used for sending events to a Zabbix server.
-  #
-  # An 'event' from Vayacondios' perspective is an arbitrary Hash.
-  #
-  # An 'event' from Zabbix's perspective is a tuple of values:
-  #
-  # * time
-  # * host
-  # * key
-  # * value
-  #
-  # This client will accept a Vayacondios event and internally
-  # translate it into a set of Zabbix events.
-  #
-  # @example A CPU monitoring notification
-  #
-  #   notify "foo-server.example.com", cpu: {
-  #     util: {
-  #       user: 0.20,
-  #       idle: 0.70,
-  #       sys:  0.10
-  #     },
-  #     load: 1.3
-  #   }
-  #
-  # would get turned into the following events when written to Zabbix:
-  #
-  # @example The CPU monitoring notification translated to Zabbix events
-  #
-  # [
-  #   { host: "foo-server.example.com", key: "cpu.util.user", value: 0.20 }
-  #   { host: "foo-server.example.com", key: "cpu.util.idle", value: 0.70 },
-  #   { host: "foo-server.example.com", key: "cpu.util.sys",  value: 0.10 },
-  #   { host: "foo-server.example.com", key: "cpu.load",      value: 1.3  }
-  # ]
-  #
-  # Zabbix will interpret the time as the time it receives each event.
-  #
-  # The following links provide details on the protocol used by Zabbix
-  # to receive events:
-  #
-  # * https://www.zabbix.com/forum/showthread.php?t=20047&highlight=sender
-  # * https://gist.github.com/1170577
-  # * http://spin.atomicobject.com/2012/10/30/collecting-metrics-from-ruby-processes-using-zabbix-trappers/?utm_source=rubyflow&utm_medium=ao&utm_campaign=collecting-metrics-zabix
-  class ZabbixClient
-    include Gorillib::Builder
-
-    attr_accessor :socket
-
-    field :host, String,  :default => 'localhost', :doc => "Host for the Zabbix server"
-    field :port, Integer, :default => 10051,       :doc => "Port for the Zabbix server"
-
-    # Insert events to a Zabbix server.
-    #
-    # The `topic` will be used as the name of the Zabbix host to
-    # associate event data to.
-    #
-    # As per the documentation for the [Zabbix sender
-    # protocol](https://www.zabbix.com/wiki/doc/tech/proto/zabbixsenderprotocol),
-    # a new TCP connection will be created for each event.
-    #
-    # @param [String] topic
-    # @param [Hash] cargo
-    # Array<Hash>] text
-    def insert topic, cargo={}
-      self.socket = TCPSocket.new(host, port)
-      send_request(topic, cargo)
-      handle_response
-      self.socket.close
-    end
-
-    private
-
-    # :nodoc
-    def send_request topic, cargo
-      socket.write(payload(topic, cargo))
-    end
-
-    # :nodoc
-    def handle_response
-      header = socket.recv(5)
-      if header == "ZBXD\1"
-        data_header = socket.recv(8)
-        length      = data_header[0,4].unpack("i")[0]
-        response    = MultiJson.load(socket.recv(length))
-        puts response["info"]
-      else
-        puts "Invalid response: #{header}"
-      end
-    end
-
-    # :nodoc
-    def payload topic, cargo={}
-      body = body_for(topic, cargo)
-      header_for(body) + body
-    end
-
-    # :nodoc
-    def body_for topic, cargo={}
-      MultiJson.dump({request: "sender data", data: zabbix_events_from(topic, cargo) })
-    end
-
-    # :nodoc
-    def header_for body
-      length = body.bytesize
-      "ZBXD\1".encode("ascii") + [length].pack("i") + "\x00\x00\x00\x00"
-    end
-
-    # :nodoc
-    def zabbix_events_from topic, cargo, scope=''
-      events = []
-      case cargo
-      when Hash
-        cargo.each_pair do |key, value|
-          events += zabbix_events_from(topic, value, new_scope(scope, key))
-        end
-      when Array
-        cargo.each_with_index do |item, index|
-          events += zabbix_events_from(topic, item, new_scope(scope, index))
-        end
-      else
-        events << event_body(topic, scope, cargo)
-      end
-      events
-    end
-
-    # :nodoc
-    def new_scope(current_scope, new_scope)
-      [current_scope, new_scope].map(&:to_s).reject(&:empty?).join('.')
-    end
-
-    # :nodoc
-    def event_body topic, scope, cargo
-      value = case cargo
-      when Hash  then cargo[:value]
-      when Array then cargo.first
-      else cargo
-      end
-      { host: topic, key: scope, value: value }
-    end
-    
-  end
-end
-