vayacondios-client 0.2.11 → 0.3.0

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
-

data/spec/client/itemset_legacy_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-require_relative '../../lib/vayacondios/server/legacy_switch'
-
-require 'multi_json'
-
-require_relative '../../lib/vayacondios/client/itemset'
-
-describe Vayacondios::Client::ItemSet do
-  context "after instantiation in legacy mode" do
-    itemset = Vayacondios::Client::ItemSet.new("foohost", 9999, "fooorg", "footopic", "fooid")
-    ary = ["foo", "bar", "baz"]
-
-    # testing internals here to avoid shimming up HTTP libraries.
-
-    it "generates a put request without a patch header when asked to create" do
-      Vayacondios.force_legacy_mode true
-
-      req = itemset.instance_eval{_req(:create, ary)}
-
-      req.method.should eql('PUT')
-      req.body.should eql(MultiJson.encode(ary))
-      req.path.should eql('/v1/fooorg/itemset/footopic/fooid')
-      req.each_header.to_a.should_not include(["x_method", "PATCH"])
-    end
-
-    it "generates a put request with a patch header when asked to update" do
-      Vayacondios.force_legacy_mode true
-
-      req = itemset.instance_eval{_req(:update, ary)}
-
-      req.method.should eql('PUT')
-      req.body.should eql(MultiJson.encode(ary))
-      req.path.should eql('/v1/fooorg/itemset/footopic/fooid')
-      req.each_header.to_a.should include(["x-method", "PATCH"])
-    end
-
-    it "generates a get request when asked to fetch" do
-      req = itemset.instance_eval{_req(:fetch)}
-
-      req.method.should eql('GET')
-      req.body.should be_nil
-      req.path.should eql('/v1/fooorg/itemset/footopic/fooid')
-    end
-
-    it "generates a delete request when asked to remove" do
-      Vayacondios.force_legacy_mode true
-
-      req = itemset.instance_eval{_req(:remove, ary)}
-
-      req.method.should eql('DELETE')
-      req.body.should eql(MultiJson.encode(ary))
-      req.path.should eql('/v1/fooorg/itemset/footopic/fooid')
-    end
-  end
-end

data/spec/client/itemset_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-require 'multi_json'
-
-require_relative '../../lib/vayacondios/client/itemset'
-
-describe Vayacondios::Client::ItemSet do
-  context "when initialized" do
-    it "can be passed a host, port, organization, topic and id" do
-      Vayacondios::Client::ItemSet.new("foohost", 9999, "fooorg", "footopic", "fooid")
-    end
-  end
-
-  context "after instantiation" do
-    itemset = Vayacondios::Client::ItemSet.new("foohost", 9999, "fooorg", "footopic", "fooid")
-    ary = ["foo", "bar", "baz"]
-
-    # testing internals here to avoid shimming up HTTP libraries.
-
-    it "generates a put request without a patch header when asked to create" do
-      Vayacondios.force_legacy_mode false
-
-      req = itemset.instance_eval{_req(:create, ary)}
-
-      req.method.should eql('PUT')
-      req.body.should eql(MultiJson.encode(contents: ary))
-      req.path.should eql('/v1/fooorg/itemset/footopic/fooid')
-      req.each_header.to_a.should_not include(["x_method", "PATCH"])
-    end
-
-    it "generates a put request with a patch header when asked to update" do
-      Vayacondios.force_legacy_mode false
-
-      req = itemset.instance_eval{_req(:update, ary)}
-
-      req.method.should eql('PUT')
-      req.body.should eql(MultiJson.encode(contents: ary))
-      req.path.should eql('/v1/fooorg/itemset/footopic/fooid')
-      req.each_header.to_a.should include(["x-method", "PATCH"])
-    end
-
-    it "generates a get request when asked to fetch" do
-      req = itemset.instance_eval{_req(:fetch)}
-
-      req.method.should eql('GET')
-      req.body.should be_nil
-      req.path.should eql('/v1/fooorg/itemset/footopic/fooid')
-    end
-
-    it "generates a delete request when asked to remove" do
-      Vayacondios.force_legacy_mode false
-
-      req = itemset.instance_eval{_req(:remove, ary)}
-
-      req.method.should eql('DELETE')
-      req.body.should eql(MultiJson.encode(contents: ary))
-      req.path.should eql('/v1/fooorg/itemset/footopic/fooid')
-    end
-  end
-end

data/spec/client/notifier_spec.rb

@@ -1,120 +0,0 @@
-require 'vayacondios-client'
-
-require 'spec_helper'
-
-class FakeModel
-  include Vayacondios::Notifications
-end
-
-describe FakeModel do
-  context 'including', Vayacondios::Notifications do
-
-    it 'defines an instance method notify()' do
-      subject.should respond_to(:notify)
-    end
-
-    it 'adds a configurable attribute :notifier with default' do
-      subject.notifier.should be_instance_of(Vayacondios.default_notifier.class)
-    end
-
-  end
-end
-
-describe Vayacondios::Notifier do
-
-  shared_examples_for described_class do
-    it{ should respond_to(:notify) }
-  end
-
-  context '.prepare' do
-    context 'given a Hash-like object' do
-      let(:hashlike) { double :hashlike, :to_hash => {} }
-      it 'returns a Hash' do
-        subject.prepare(hashlike).should be_instance_of(Hash)
-      end
-    end
-
-    context 'given a bad argument' do
-      let(:bad_arg) { 'shazam' }
-      it 'raises an ArgumentError' do
-        expect{ subject.prepare(bad_arg) }.to raise_error(ArgumentError, /Cannot notify.*#{bad_arg}.*require a hash-like object/)
-      end
-    end
-  end
-
-end
-
-describe Vayacondios::HttpNotifier do
-  it_behaves_like Vayacondios::Notifier
-
-  its(:client){ should be_instance_of(Vayacondios::HttpClient) }
-
-  context '#notify' do
-    let(:test_client) { double :client }
-    let(:topic)       { 'weeeeeeeeeee' }
-    let(:cargo)       { Hash.new       }
-
-    before do
-      subject.stub(:client).and_return(test_client)
-      subject.stub(:prepare).and_return(cargo)
-    end
-
-    it 'notifies its client correctly' do
-      test_client.should_receive(:insert).with(cargo, :event, topic)
-      subject.notify(topic, cargo)
-    end
-  end
-end
-
-describe Vayacondios::LogNotifier do
-  it_behaves_like Vayacondios::Notifier
-
-  its(:client){ should be_instance_of(Logger) }
-
-  context '#notify' do
-    let(:test_client) { double :client }
-    let(:topic)       { 'weeeeeeeeeee' }
-    let(:cargo)       { Hash.new       }
-
-    before do
-      subject.stub(:client).and_return(test_client)
-      subject.stub(:prepare).and_return(cargo)
-    end
-
-    it 'notifies its client correctly' do
-      test_client.should_receive(:info).with(/Notification.*#{topic}/)
-      subject.notify(topic, cargo)
-    end
-  end
-
-end
-
-describe Vayacondios::NotifierFactory do
-  context '.receive' do
-    context 'given :http' do
-      it 'builds a HttpNotifier' do
-        described_class.receive(type: 'http').should be_instance_of(Vayacondios::HttpNotifier)
-      end
-    end
-
-    context 'given :log' do
-      it 'builds a LogNotifier' do
-        described_class.receive(type: 'log').should be_instance_of(Vayacondios::LogNotifier)
-      end
-    end
-
-    context 'given a bad argument' do
-      it 'raises an ArgumentError' do
-        expect{ described_class.receive(type: 'bad') }.to raise_error(ArgumentError, /not a valid build option/)
-      end
-    end
-  end
-end
-
-describe Vayacondios do
-
-  it 'has a class method notify()' do
-    described_class.should respond_to(:notify)
-  end
-
-end