pulse-meter 0.4.9 → 0.4.11

data/lib/pulse-meter/visualize/views/widgets/pie.haml

@@ -1,13 +0,0 @@
-%script.widget-template{type: 'text/template', 'data-widget-type' => 'pie'}
-  #plotarea
-  #chart-controls
-    .form-inline
-      %button#refresh.btn.btn-mini
-        %i.icon-refresh
-        Refresh
-      %span.space
-      %label
-        Refresh:
-        %input.btn-mini#need-refresh{type: :checkbox, checked: :true}
-  %hr
-

data/lib/pulse-meter/visualize/views/widgets/table.haml

@@ -1,45 +0,0 @@
-%script.widget-template{type: 'text/template', 'data-widget-type' => 'table'}
-  #plotarea
-  #chart-controls
-    .form-inline
-      %button#refresh.btn.btn-mini
-        %i.icon-refresh
-        Refresh
-      %a#configure-button.btn.btn-mini{href: "#configure", role: 'button', 'data-toggle' => 'modal'} 
-        %i.icon-wrench
-        Configure...
-      .modal.hide.fade#configure
-        .modal-header
-          %button.close{type: 'button', 'data-dismiss' => 'modal', 'aria-hidden' => 'true'} ×
-          %h3 Configure
-        .modal-body
-          %p
-            %label
-              Refresh:
-              %input.btn-mini#need-refresh{type: :checkbox, checked: :true}
-          %hr
-          %p
-            %label
-              Timespan:
-              %select#extend-timespan-val.btn-mini.span3
-                = partial "widgets/extend_options"
-              %button#extend-timespan.btn.btn-mini
-                %i.icon-arrow-left
-                Extend
-              %button#reset-timespan.btn.btn-mini
-                %i.icon-arrow-right
-                Reset
-          %hr
-          %p
-            %label
-              From:
-              %span#start-time
-                %input.datepicker
-            %label
-              Till:
-              %span#end-time
-                %input.datepicker
-            %button#set-interval.btn.btn-mini
-              %i.icon-time
-              Set interval
-

data/lib/pulse-meter/visualize/widget.rb

@@ -1,38 +0,0 @@
-module PulseMeter
-  module Visualize
-    class Error < StandardError; end
-
-    class Widget < Base
-      def initialize(opts)
-        super
-        @opts[:sensors] ||= []
-      end
-
-      def data
-        {
-          type: type,
-          title: title,
-          redraw_interval: redraw_interval,
-          width: width,
-          gchart_options: gchart_options,
-          values_title: values_label
-        }
-      end
-
-      def type
-        self.class.to_s.split('::').last.downcase
-      end
-
-      protected
-
-      def gauge_series_data
-        ensure_gauge_indicators!
-        sensors.map do |s|
-          [s.annotation, s.value]
-        end
-      end
-
-    end
-  end
-end
-

data/lib/pulse-meter/visualize/widgets/gauge.rb

@@ -1,47 +0,0 @@
-module PulseMeter
-  module Visualize
-    module Widgets
-      class Gauge < PulseMeter::Visualize::Widget
-        class NotAnIndicatorSensorInGaugeWidget < PulseMeter::Visualize::Error; end
-
-        def data(options = {})
-          super().merge({
-            series: values_data
-          })
-        end
-
-        protected
-
-        def ensure_gauge_indicators!
-          sensors.each do |s|
-            unless s.type <= PulseMeter::Sensor::Indicator || s.type <= PulseMeter::Sensor::HashedIndicator
-              raise NotAnIndicatorSensorInGaugeWidget, "Sensor #{s.name} is not an indicator(PulseMeter::Sensor::Indicator or PulseMeter::Sensor::HashedIndicator)"
-            end
-          end
-        end
-        
-        def values_data
-          ensure_gauge_indicators!
-          gauges = []
-          sensors.map do |s|
-            s_type = s.type
-            case 
-            when s_type == PulseMeter::Sensor::Indicator
-              gauges << [s.annotation, s.value]
-            when s_type == PulseMeter::Sensor::HashedIndicator
-              s.value.each_pair do |k, v|
-                gauge_title = "#{s.annotation}: #{k}"
-                gauges << [gauge_title, v]
-              end
-            end
-          end
-          gauges
-        end
-
-      end
-    end
-
-  end
-end
-
-

data/lib/pulse-meter/visualize/widgets/pie.rb

@@ -1,36 +0,0 @@
-module PulseMeter
-  module Visualize
-    module Widgets
-      class Pie < PulseMeter::Visualize::Widget
-
-        def data(options = {})
-          super().merge({
-            series: slice_data
-          })
-        end
-
-        protected
-        
-        def slice_data
-          values = []
-          slice_options = []
-          now = Time.now
-          sensors.each do |s|
-            s.last_point_data(now, show_last_point).each do |point_data|
-              values << [point_data[:name], point_data[:y]]
-              slice_options << {color: point_data[:color]}
-            end
-          end
-          {
-            data: values,
-            options: slice_options
-          }
-        end
-
-      end
-    end
-
-  end
-end
-
-

data/lib/pulse-meter/visualize/widgets/timeline.rb

@@ -1,114 +0,0 @@
-module PulseMeter
-  module Visualize
-    module Widgets
-      class Error < StandardError; end
-      class Timeline < PulseMeter::Visualize::Widget
-
-        class NotATimelinedSensorInWidget < PulseMeter::Visualize::Error; end
-        class DifferentSensorIntervalsInWidget < PulseMeter::Visualize::Error; end
-
-        DEFAULT_TIMESPAN = 3600
-
-        def initialize(opts)
-          super
-          opts[:timespan] ||= DEFAULT_TIMESPAN
-        end
-
-        def data(options = {})
-          from, till = get_interval_borders(options)
-          super().merge({
-            values_title: values_label,
-            series: series_data(from, till),
-            timespan: timespan,
-            interval: interval
-          })
-        end
-
-        protected
-
-        def get_interval_borders(options)
-          from = if options[:start_time] && (options[:start_time] > 0)
-            Time.at options[:start_time]
-          else
-            tspan = options[:timespan] || timespan
-            Time.now - tspan
-          end
-
-          till = if options[:end_time] && (options[:end_time] > 0)
-            Time.at options[:end_time]
-          else
-            Time.now
-          end
-          [from, till]
-        end
-
-        def series_data(from, till)
-          ensure_equal_intervals!
-          sensor_datas = sensors.map{ |s|
-            s.timeline_data(from, till, show_last_point)
-          }
-          rows = []
-          titles = []
-          series_options = []
-          datas = []
-          sensor_datas.each do |sensor_data|
-            sensor_data.each do |tl|
-              titles << tl[:name]
-              series_options << {color: tl[:color]}
-              datas << tl[:data]
-            end
-          end
-          unless datas.empty?
-            first = datas.shift
-            first.each_with_index do |tl_data, row_num|
-              rows << datas.each_with_object([tl_data[:x], tl_data[:y]]) do |data_col, row|
-                row << data_col[row_num][:y]
-              end
-            end
-          end
-          {
-            titles: titles,
-            rows: rows,
-            options: series_options
-          }
-        end
-
-        def ensure_equal_intervals!
-          intervals = []
-          sensors.each do |s|
-            unless s.type < PulseMeter::Sensor::Timeline
-              raise NotATimelinedSensorInWidget, "sensor `#{s.name}' is not timelined"
-            end
-            intervals << s.interval
-          end
-
-          unless intervals.all?{|i| i == intervals.first}
-            interval_notice = sensors.map{|s| "#{s.name}: #{s.interval}"}.join(', ')
-            raise DifferentSensorIntervalsInWidget, "Sensors with different intervals in a single widget: #{interval_notice}"
-          end
-        end
-
-        def interval
-          if sensors.empty?
-            nil
-          else
-            sensors.first.interval
-          end
-        end
-
-      end
-
-      class Area < Timeline; end
-      class Line < Timeline; end
-      
-      class Table < Timeline 
-        def data(options = {})
-          res = super(options)      
-          res[:series].delete(options)
-          res
-        end
-      end
-    end
-  end
-end
-

data/spec/pulse_meter/command_aggregator/async_spec.rb

@@ -1,53 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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/extensions/enumerable_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-require 'pulse-meter/extensions/enumerable'
-
-describe Enumerable do
-  let!(:time) {Time.new}
-  describe "#convert_time" do
-    it "converts Time objects to unixtime" do
-      [time].convert_time.should == [time.to_i]
-    end
-
-    it "does not change other members" do
-      [1, 2, 3].convert_time.should == [1, 2 ,3]
-    end
-  end
-
-  describe "#to_table" do
-    context "when format is csv" do
-      it "returns csv as string" do
-        [].to_table(:csv).should be_instance_of(String)
-      end
-
-      it "returns csv containing each subarray as a row" do
-        [[:a, :b], [:c, :d]].to_table(:csv).should == "a;b\nc;d\n"
-      end
-
-      it "converts Time objects to unixtime" do
-        [[time]].to_table(:csv).should == "#{time.to_i}\n"
-      end
-
-      it "takes format argument both as string and as symbol" do
-        [[:foo]].to_table("csv").should == "foo\n"
-        [[:foo]].to_table(:csv).should == "foo\n"
-      end
-    end
-
-    context "when format is table" do
-      it "return Terminal::Table instance" do
-        [].to_table.should be_instance_of(Terminal::Table)
-      end
-
-      it "returns table containing each subarray as a row" do
-        data = [[:a, :b], [:c, :d]]
-        table = [[:a, :b], [:c, :d]].to_table
-        table.rows.map do |row|
-          row.cells.map(&:to_s).map(&:strip).map(&:to_sym)
-        end.should == data
-      end
-    end
-
-    it "uses table format as default" do
-      [].to_table.should be_instance_of(Terminal::Table)
-    end
-
-    it "uses table format unless it is :csv or 'csv'" do
-      [].to_table(:unknown_format).should be_instance_of(Terminal::Table)
-    end
-  end
-end