pulse_meter_core 0.4.13

data/pulse_meter_core.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ilya Averyanov", "Sergey Averyanov"]
+  gem.email         = ["av@fun-box.ru", "averyanov@gmail.com"]
+  gem.description   = %q{Lightweight metrics processor}
+  gem.summary       = %q{
+    Lightweight Redis-based metrics aggregator and processor
+    with simple CLI interface
+  }
+  gem.homepage      = "https://github.com/savonarola/pulse_meter_core"
+
+  gem.required_ruby_version = '>= 1.9.2'
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "pulse_meter_core"
+  gem.require_paths = ["lib"]
+  gem.version       = "0.4.13"
+
+  gem.add_runtime_dependency('redis')
+  gem.add_runtime_dependency('json')
+
+  gem.add_development_dependency('aquarium')
+  gem.add_development_dependency('hashie')
+  gem.add_development_dependency('mock_redis')
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('redcarpet')
+  gem.add_development_dependency('rspec')
+  gem.add_development_dependency('simplecov')
+  gem.add_development_dependency('timecop')
+  gem.add_development_dependency('yard')
+
+end

data/spec/pulse_meter/command_aggregator/async_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe PulseMeter::CommandAggregator::Async do
+  let(:ca){PulseMeter.command_aggregator}
+  let(:redis){PulseMeter.redis}
+
+  describe "#multi" do
+    it "should accumulate redis command and execute in a bulk" do
+      ca.multi do
+        ca.set("xxxx", "zzzz")
+        ca.set("yyyy", "zzzz")
+        sleep 0.1
+        redis.get("xxxx").should be_nil
+        redis.get("yyyy").should be_nil
+      end
+      ca.wait_for_pending_events
+      redis.get("xxxx").should == "zzzz"
+      redis.get("yyyy").should == "zzzz"
+    end
+  end
+
+  describe "any other redis instance method" do
+    it "should be delegated to redis" do
+      ca.set("xxxx", "zzzz")
+      ca.wait_for_pending_events
+      redis.get("xxxx").should == "zzzz"
+    end
+
+    it "should be aggregated if queue is not overflooded" do
+      redis.set("x", 0)
+      ca.max_queue_length.times{ ca.incr("x") }
+      ca.wait_for_pending_events
+      redis.get("x").to_i.should == ca.max_queue_length
+    end
+
+    it "should not be aggregated if queue is overflooded" do
+      redis.set("x", 0)
+      (ca.max_queue_length * 2).times{ ca.incr("x") }
+      ca.wait_for_pending_events
+      redis.get("x").to_i.should < 2 * ca.max_queue_length
+    end
+  end
+
+  describe "#wait_for_pending_events" do
+    it "should pause execution until aggregator thread sends all commands ro redis" do
+      ca.set("xxxx", "zzzz")
+      redis.get("xxxx").should be_nil
+      ca.wait_for_pending_events
+      redis.get("xxxx").should == "zzzz"
+    end
+  end
+
+end

data/spec/pulse_meter/command_aggregator/sync_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe PulseMeter::CommandAggregator::Sync do
+  let(:ca){described_class.instance}
+  let(:redis){PulseMeter.redis}
+
+  describe "#multi" do
+    it "should accumulate redis command and execute in a bulk" do
+      ca.multi do
+        ca.set("xxxx", "zzzz").should == "QUEUED"
+        ca.set("yyyy", "zzzz").should == "QUEUED"
+      end
+      redis.get("xxxx").should == "zzzz"
+      redis.get("yyyy").should == "zzzz"
+    end
+  end
+
+  describe "any other redis instance method" do
+    it "should be delegated to redis" do
+      ca.set("xxxx", "zzzz")
+      redis.get("xxxx").should == "zzzz"
+    end
+  end
+end
+

data/spec/pulse_meter/command_aggregator/udp_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe PulseMeter::CommandAggregator::UDP do
+  let(:host){'127.0.0.1'}
+  let(:port){33333}
+  let(:udp_sock){mock(:socket)}
+  before do 
+    UDPSocket.stub!(:new).and_return(udp_sock)
+    udp_sock.stub!(:fcntl).and_return(nil)
+    @ca = described_class.new([[host, port]])
+  end
+
+  describe "#multi" do
+    it "should accumulate redis commands and send them in a bulk" do
+      data = [
+        ["set", "xxxx", "zzzz"],
+        ["set", "yyyy", "zzzz"]
+      ].to_json
+      udp_sock.should_receive(:send).with(data, 0, host, port).and_return(0)
+      @ca.multi do
+        @ca.set("xxxx", "zzzz")
+        @ca.set("yyyy", "zzzz")
+      end
+    end
+
+    it "should ignore standard exceptions" do
+      udp_sock.should_receive(:send).and_raise(StandardError)
+      @ca.multi do
+        @ca.set("xxxx", "zzzz")
+      end
+    end
+  end
+
+  describe "any other redis instance method" do
+    it "should send data imediately" do
+      data = [
+        ["set", "xxxx", "zzzz"]
+      ].to_json
+      udp_sock.should_receive(:send).with(data, 0, host, port).and_return(0)
+      @ca.set("xxxx", "zzzz")
+    end
+  end
+
+end
+

data/spec/pulse_meter/mixins/dumper_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+describe PulseMeter::Mixins::Dumper do
+  class Base
+    include PulseMeter::Mixins::Dumper
+  end
+
+  class Bad < Base; end
+
+  class Good < Base
+    attr_accessor :some_value
+    attr_accessor :name
+
+    def redis; PulseMeter.redis; end
+
+    def initialize(name)
+      @name = name.to_s
+      @some_value = name
+    end
+  end
+
+  class GoodButAnother < Good; end
+
+  let(:bad_obj){ Bad.new }
+  let(:good_obj){ Good.new(:foo) }
+  let(:another_good_obj){ Good.new(:bar) }
+  let(:good_obj_of_another_type){ GoodButAnother.new(:quux) }
+  let(:redis){ PulseMeter.redis }
+
+  describe '#dump' do
+    context "when class violates dump contract" do
+      context "when it has no name attribute" do
+        it "should raise exception" do
+          def bad_obj.redis; PulseMeter.redis; end
+          expect{ bad_obj.dump! }.to raise_exception(PulseMeter::DumpError)
+        end
+      end
+
+      context "when it has no redis attribute" do
+        it "should raise exception" do
+          def bad_obj.name; :foo; end
+          expect{ bad_obj.dump! }.to raise_exception(PulseMeter::DumpError)
+        end
+      end
+
+      context "when redis is not avalable" do
+        it "should raise exception" do
+          def bad_obj.name; :foo; end
+          def bad_obj.redis; nil; end
+          expect{ bad_obj.dump! }.to raise_exception(PulseMeter::DumpError)
+        end
+      end
+    end
+
+    context "when class follows dump contract" do
+      it "should not raise dump exception" do
+        expect {good_obj.dump!}.not_to raise_exception(PulseMeter::DumpError)
+      end
+
+      it "should save dump to redis" do
+        expect {good_obj.dump!}.to change {redis.hlen(Good::DUMP_REDIS_KEY)}.by(1)
+      end
+    end
+
+    context "when dump is safe" do
+      it "should not overwrite stored objects of the same type" do
+        good_obj.some_value = 123
+        good_obj.dump!
+        good_obj.some_value = 321
+        good_obj.dump!
+        Base.restore(good_obj.name).some_value.should == 123
+      end
+
+      it "should raise DumpConflictError exception if sensor with the same name but different type already exists" do
+        good_obj.name = "duplicate_name"
+        good_obj_of_another_type.name = "duplicate_name"
+        good_obj.dump!
+        expect{good_obj_of_another_type.dump!}.to raise_exception(PulseMeter::DumpConflictError)
+      end
+    end
+  end
+
+  describe ".restore" do
+    context "when object has never been dumped" do
+      it "should raise exception" do
+        expect{ Base.restore(:nonexistant) }.to raise_exception(PulseMeter::RestoreError)
+      end
+    end
+
+    context "when object was dumped" do
+      before do
+        good_obj.dump!
+      end
+
+      it "should keep object class" do
+        Base.restore(good_obj.name).should be_instance_of(good_obj.class)
+      end
+
+      it "should restore object data" do
+        restored = Base.restore(good_obj.name)
+        restored.some_value.should == good_obj.some_value
+      end
+
+      it "should restore last dumped object" do
+        good_obj.some_value = :bar
+        good_obj.dump!(false)
+        restored = Base.restore(good_obj.name)
+        restored.some_value.should == :bar
+      end
+    end
+  end
+
+  describe ".list_names" do
+    context "when redis is not available" do
+      before do
+        PulseMeter.stub(:redis).and_return(nil)
+      end
+
+      it "should raise exception" do
+        expect {Base.list_names}.to raise_exception(PulseMeter::RestoreError)
+      end
+    end
+
+    context "when redis if fine" do
+      it "should return empty list if nothing is registered" do
+        Base.list_names.should == []
+      end
+
+      it "should return list of registered objects" do
+        good_obj.dump!(false)
+        another_good_obj.dump!(false)
+        Base.list_names.should =~ [good_obj.name, another_good_obj.name]
+      end
+    end
+  end
+
+  describe ".list_objects" do
+    before do
+      good_obj.dump!
+      another_good_obj.dump!
+    end
+
+    it "should return restored objects" do
+      objects = Base.list_objects
+      objects.map(&:name).should =~ [good_obj.name, another_good_obj.name]
+    end
+
+    it "should skip unrestorable objects" do
+      Base.stub(:list_names).and_return([good_obj.name, "scoundrel", another_good_obj.name])
+      objects = Base.list_objects
+      objects.map(&:name).should =~ [good_obj.name, another_good_obj.name]
+    end
+  end
+
+  describe "#cleanup_dump" do
+    it "should remove data from redis" do
+      good_obj.dump!
+      another_good_obj.dump!
+      expect {good_obj.cleanup_dump}.to change{good_obj.class.list_names.count}.by(-1)
+    end
+  end
+end

data/spec/pulse_meter/mixins/utils_spec.rb

@@ -0,0 +1,212 @@
+require 'spec_helper'
+
+describe PulseMeter::Mixins::Utils do
+  class Dummy
+    include PulseMeter::Mixins::Utils
+  end
+
+  let(:dummy){ Dummy.new }
+
+  describe '#constantize' do
+    context "when argument is a string with a valid class name" do
+      it "should return class" do
+        dummy.constantize("PulseMeter::Mixins::Utils").should == PulseMeter::Mixins::Utils
+      end
+    end
+    context "when argument is a string with invalid class name" do
+      it "should return nil" do
+        dummy.constantize("Pumpkin::Eater").should be_nil
+      end
+    end
+    context "when argument is not a string" do
+      it "should return nil" do
+        dummy.constantize({}).should be_nil
+      end
+    end
+  end
+
+  describe "#assert_positive_integer!" do
+    it "should extract integer value from hash by passed key" do
+      dummy.assert_positive_integer!({:val => 4}, :val).should == 4
+    end
+
+    context "when no default value given" do
+      context "when the value by the passed key is not integer" do
+        it "should convert non-integers to integers" do
+          dummy.assert_positive_integer!({:val => 4.4}, :val).should == 4
+        end
+
+        it "should change the original value to the obtained integer" do
+          h = {:val => 4.4}
+          dummy.assert_positive_integer!(h, :val).should == 4
+          h[:val].should == 4
+        end
+
+        it "should raise exception if the original value cannot be converted to integer"do
+          expect{ dummy.assert_positive_integer!({:val => :bad_int}, :val) }.to raise_exception(ArgumentError)
+        end
+      end
+
+      it "should raise exception if the value is not positive" do
+        expect{ dummy.assert_positive_integer!({:val => -1}, :val) }.to raise_exception(ArgumentError)
+      end
+
+      it "should raise exception if the value is not defined" do
+        expect{ dummy.assert_positive_integer!({}, :val) }.to raise_exception(ArgumentError)
+      end
+    end
+
+    context "when default value given" do
+      it "should prefer value from options to default" do
+        dummy.assert_positive_integer!({:val => 4}, :val, 22).should == 4
+      end
+
+      it "should use default value when there is no one in options" do
+        dummy.assert_positive_integer!({}, :val, 22).should == 22
+      end
+
+      it "should check default value if it is to be used" do
+        expect{dummy.assert_positive_integer!({}, :val, :bad)}.to raise_exception(ArgumentError)
+        expect{dummy.assert_positive_integer!({}, :val, -1)}.to raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  describe "#assert_array!" do
+    it "should extract value from hash by passed key" do
+      dummy.assert_array!({:val => [:foo]}, :val).should == [:foo]
+    end
+
+    context "when no default value given" do
+      it "should raise exception if th value is not an Array" do
+        expect{ dummy.assert_array!({:val => :bad}, :val) }.to raise_exception(ArgumentError)
+      end
+
+      it "should raise exception if the value is not defined" do
+        expect{ dummy.assert_array!({}, :val) }.to raise_exception(ArgumentError)
+      end
+    end
+
+    context "when default value given" do
+      it "should prefer value from options to default" do
+        dummy.assert_array!({:val => [:foo]}, :val, []).should == [:foo]
+      end
+
+      it "should use default value when there is no one in options" do
+        dummy.assert_array!({}, :val, []).should == []
+      end
+
+      it "should check default value if it is to be used" do
+        expect{dummy.assert_array!({}, :val, :bad)}.to raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  describe "#assert_ranged_float!" do
+
+    it "should extract float value from hash by passed key" do
+      dummy.assert_ranged_float!({:val => 4}, :val, 0, 100).should be_generally_equal(4)
+    end
+
+    context "when the value by the passed key is not float" do
+      it "should convert non-floats to floats" do
+        dummy.assert_ranged_float!({:val => "4.0000"}, :val, 0, 100).should be_generally_equal(4)
+      end
+
+      it "should change the original value to the obtained float" do
+        h = {:val => "4.000"}
+        dummy.assert_ranged_float!(h, :val, 0, 100).should be_generally_equal(4)
+        h[:val].should be_generally_equal(4)
+      end
+
+      it "should raise exception if the original value cannot be converted to float" do
+        expect{ dummy.assert_ranged_float!({:val => :bad_float}, :val, 0, 100) }.to raise_exception(ArgumentError)
+      end
+    end
+
+    it "should raise exception if the value is not within range" do
+      expect{ dummy.assert_ranged_float!({:val => -0.1}, :val, 0, 100) }.to raise_exception(ArgumentError)
+      expect{ dummy.assert_ranged_float!({:val => 100.1}, :val, 0, 100) }.to raise_exception(ArgumentError)
+    end
+
+    it "should raise exception if the value is not defined" do
+      expect{ dummy.assert_ranged_float!({}, :val) }.to raise_exception(ArgumentError)
+    end
+  end
+
+  describe "#uniqid" do
+    it "should return uniq strings" do
+      uniq_values = (1..1000).map{|_| dummy.uniqid}
+      uniq_values.uniq.count.should == uniq_values.count
+    end
+  end
+
+  describe "#titleize" do
+    it "should convert identificator to title" do
+      dummy.titleize("aaa_bbb").should == 'Aaa Bbb'
+      dummy.titleize(:aaa_bbb).should == 'Aaa Bbb'
+      dummy.titleize("aaa bbb").should == 'Aaa Bbb'
+    end
+  end
+
+  describe "#camelize" do
+    it "should camelize string" do
+      dummy.camelize("aa_bb_cc").should == "aaBbCc"
+      dummy.camelize("aa_bb_cc", true).should == "AaBbCc"
+    end
+  end
+
+  describe "#underscore" do
+    it "should underscore string" do
+      dummy.underscore("aaBbCc").should == "aa_bb_cc"
+      dummy.underscore("AaBbCc").should == "aa_bb_cc"
+      dummy.underscore("aaBb::Cc").should == "aa_bb/cc"
+    end
+  end
+
+  describe "#camelize_keys" do
+    it "should deeply camelize keys in hashes" do
+      dummy.camelize_keys({ :aa_bb_cc => [ { :dd_ee => 123 }, 456 ] }).should =={ 'aaBbCc' => [ { 'ddEe' => 123 }, 456 ] }
+    end
+  end
+
+  describe "#symbolize_keys" do
+    it "should convert symbolizable keys to symbols" do
+      dummy.symbolize_keys({"a" => 5, 6 => 7}).should == {a: 5, 6 => 7}
+    end
+  end
+
+  describe "#subsets_of" do
+    it "returns all subsets of given array" do
+      dummy.subsets_of([1, 2]).sort.should == [[], [1], [2], [1, 2]].sort
+    end
+  end
+
+  describe "#each_subset" do
+    it "iterates over each subset" do
+      subsets = []
+      dummy.each_subset([1, 2]) {|s| subsets << s}
+      subsets.sort.should == [[], [1], [2], [1, 2]].sort
+    end
+  end
+
+  describe '#parse_time' do
+    context "when argument is a valid YYYYmmddHHMMSS string" do
+      it "should correct Time object" do
+        t = dummy.parse_time("19700101000000")
+        t.should be_kind_of(Time)
+        t.to_i.should == 0
+      end
+    end
+    context "when argument is an invalid YYYYmmddHHMMSS string" do
+      it "should raise ArgumentError" do
+        expect{ dummy.parse_time("19709901000000") }.to raise_exception(ArgumentError)
+      end
+    end
+    context "when argument is not a YYYYmmddHHMMSS string" do
+      it "should raise ArgumentError" do
+        expect{ dummy.parse_time("197099010000000") }.to raise_exception(ArgumentError)
+      end
+    end
+  end
+end