pulse-meter 0.4.9 → 0.4.11

data/lib/pulse-meter/command_aggregator/async.rb

@@ -1,83 +0,0 @@
-require 'singleton'
-require 'thread'
-
-module PulseMeter
-  module CommandAggregator
-    class Async
-      include Singleton
-
-      MAX_QUEUE_LENGTH = 10_000
-
-      attr_reader :max_queue_length
-
-      def initialize
-        @max_queue_length = MAX_QUEUE_LENGTH
-        @queue = Queue.new
-        @buffer = []
-        @in_multi = false
-        @consumer_thread = run_consumer
-        at_exit{ wait_for_pending_events }
-      end
-
-      def multi
-        @in_multi = true
-        yield
-      ensure
-        @in_multi = false
-        send_buffer_to_queue
-      end
-
-      def method_missing(*args)
-        @buffer << args
-        send_buffer_to_queue unless @in_multi
-      end
-
-      def wait_for_pending_events(max_seconds = 1)
-        left_to_wait = max_seconds.to_f
-        sleep_step = 0.01
-        while has_pending_events? && left_to_wait > 0
-          left_to_wait -= sleep_step
-          sleep(sleep_step)
-        end
-      end
-
-      private
-
-      def has_pending_events?
-        !@queue.empty?
-      end
-
-      def send_buffer_to_queue
-        if @queue.size < @max_queue_length
-          @queue << @buffer
-        end
-        @buffer = []
-      end
-
-      def redis
-        PulseMeter.redis
-      end
-
-      def consume_commands
-        # redis and @queue are threadsafe
-        while commands = @queue.pop
-          begin
-            redis.multi do 
-              commands.each do |command|
-                redis.send(*command)
-              end
-            end
-          rescue StandardError => e
-            PulseMeter.error "error in consumer thread: #{e}, #{e.backtrace.join("\n")}"
-          end
-        end
-      end
-
-      def run_consumer
-        Thread.new do
-          consume_commands
-        end
-      end
-    end
-  end
-end

data/lib/pulse-meter/command_aggregator/sync.rb

@@ -1,18 +0,0 @@
-require 'singleton'
-
-module PulseMeter
-  module CommandAggregator
-    class Sync
-      include Singleton
-
-      def redis
-        PulseMeter.redis
-      end
-
-      def method_missing(*args, &block)
-        redis.send(*args, &block)
-      end
-    end
-  end
-end
-

data/lib/pulse-meter/command_aggregator/udp.rb

@@ -1,48 +0,0 @@
-require 'socket'
-require 'fcntl'
-
-module PulseMeter
-  module CommandAggregator
-    class UDP
-
-      def initialize(host, port = nil)
-        @servers = if host.is_a?(Array)
-          host
-        else
-          [[host, port]]
-        end
-        raise ArgumentError, "No servers specified" if @servers.empty?
-        @buffer = []
-        @in_multi = false
-        @sock = UDPSocket.new
-        @sock.fcntl(Fcntl::F_SETFL, @sock.fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
-      end
-
-      def multi
-        @in_multi = true
-        yield
-      ensure
-        @in_multi = false
-        send_buffer
-      end
-
-      def method_missing(*args)
-        @buffer << args
-        send_buffer unless @in_multi
-      end
-
-      private
-
-      def send_buffer
-        data = @buffer.to_json
-        @sock.send(data, 0, *@servers.sample)
-      rescue StandardError => e
-        PulseMeter.error "error sending data: #{e}, #{e.backtrace.join("\n")}"
-      ensure
-        @buffer = []
-      end
-
-    end
-  end
-end
-

data/lib/pulse-meter/extensions/enumerable.rb

@@ -1,24 +0,0 @@
-module Enumerable
-  require 'csv'
-  require 'terminal-table'
-
-  def convert_time
-    map {|el| el.is_a?(Time) ? el.to_i : el}
-  end
-
-  def to_table(format = nil)
-    if "csv" == format.to_s
-      CSV.generate(:col_sep => ';') do |csv|
-        self.each {|row| csv << row.convert_time}
-      end
-    else
-      self.each_with_object(Terminal::Table.new) do |row, table|
-        table << if row.respond_to?(:map)
-          row.map(&:to_s)
-        else
-          row
-        end
-      end
-    end
-  end
-end

data/lib/pulse-meter/mixins/cmd.rb

@@ -1,46 +0,0 @@
-require 'pulse-meter/extensions/enumerable'
-
-module PulseMeter
-  module Mixins
-    # Mixin with command-line utilities
-    module Cmd
-      def with_redis
-        PulseMeter.redis = create_redis
-        yield
-      end
-
-      def with_safe_restore_of(name, &block)
-        with_redis do
-          sensor = PulseMeter::Sensor::Base.restore(name)
-          block.call(sensor)
-        end
-      rescue PulseMeter::RestoreError
-        fail! "Sensor #{name} is unknown or cannot be restored"
-      end
-
-      def all_sensors
-        PulseMeter::Sensor::Timeline.list_objects
-      end
-
-      def all_sensors_table(format = nil)
-        data = [
-          ["Name", "Class", "ttl", "raw data ttl", "interval", "reduce delay"],
-        ]
-        data << :separator unless 'csv' == format.to_s
-        all_sensors.each do |s|
-          if s.kind_of? PulseMeter::Sensor::Timeline
-            data << [s.name, s.class, s.ttl, s.raw_data_ttl, s.interval, s.reduce_delay]
-          else
-            data << [s.name, s.class] + [''] * 4
-          end
-        end
-        data.to_table(format)
-      end
-
-      def fail!(description = nil)
-        puts description if description
-        exit 1
-      end
-    end
-  end
-end

data/lib/pulse-meter/mixins/dumper.rb

@@ -1,87 +0,0 @@
-require 'yaml'
-
-module PulseMeter
-  module Mixins
-    # Mixin with dumping utilities
-    module Dumper
-      # Prefix for Redis keys with dumped sensors' metadata
-      DUMP_REDIS_KEY = "pulse_meter:dump"
-
-      module InstanceMethods
-        # Serializes object and saves it to Redis
-        # @param safe [Boolean] forbids dump if sensor has already been dumped
-        # @raise [DumpConflictError] if object class conflicts with stored object class
-        # @raise [DumpError] if dumping fails for any reason
-        def dump!(safe = true)
-          ensure_storability!
-          serialized_obj = to_yaml
-          if safe
-            unless redis.hsetnx(DUMP_REDIS_KEY, name, serialized_obj)
-              stored = self.class.restore(name)
-              unless stored.class == self.class
-                raise DumpConflictError, "Attempt to create sensor #{name} of class #{self.class} but it already has class #{stored.class}"
-              end
-            end
-          else
-            redis.hset(DUMP_REDIS_KEY, name, serialized_obj)
-          end
-        rescue DumpError, RestoreError => exc
-          raise exc
-        rescue StandardError => exc
-          raise DumpError, "object cannot be dumped: #{exc}"
-        end
-
-        # Ensures that object is dumpable
-        # @raise [DumpError] if object cannot be dumped
-        def ensure_storability!
-          raise DumpError, "#name attribute must be readable" unless self.respond_to?(:name)
-          raise DumpError, "#redis attribute must be available" unless self.respond_to?(:redis) && self.redis
-        end
-        
-        # Cleans up object dump in Redis 
-        def cleanup_dump
-          redis.hdel(DUMP_REDIS_KEY, self.name)
-        end
-      end
-
-      module ClassMethods
-        # Restores object from Redis
-        # @param name [String] object name
-        # @return [Object]
-        # @raise [RestoreError] if object cannot be restored for any reason
-        def restore(name)
-          serialized_obj = PulseMeter.redis.hget(DUMP_REDIS_KEY, name)
-          YAML::load(serialized_obj)
-        rescue
-          raise RestoreError, "cannot restore #{name}"
-        end
-
-        # Lists all dumped objects' names
-        # @return [Array<String>]
-        # @raise [RestoreError] if list cannot be retrieved for any reason
-        def list_names
-          PulseMeter.redis.hkeys(DUMP_REDIS_KEY)
-        rescue
-          raise RestoreError, "cannot get data from redis"
-        end
-
-        # Safely restores all dumped objects
-        # @return [Array<Object>]
-        def list_objects
-          list_names.each_with_object([]) do |name, objects|
-            begin
-              objects << restore(name)
-            rescue
-            end
-          end
-        end
-      end
-
-      def self.included(base)
-        base.send :include, InstanceMethods
-        base.send :extend, ClassMethods
-      end
-
-    end
-  end
-end

data/lib/pulse-meter/mixins/utils.rb

@@ -1,155 +0,0 @@
-require 'securerandom'
-
-module PulseMeter
-  module Mixins
-    # Mixin with various useful functions 
-    module Utils
-      # Tries to find a class with the name specified in the argument string
-      # @param const_name [String] class name
-      # @return [Class] if given class definde
-      # @return [NilClass] if given class is not defined
-      def constantize(const_name)
-        return unless const_name.respond_to?(:to_s)
-        const_name.to_s.split('::').reduce(Module, :const_get)
-      rescue NameError
-        nil
-      end
-
-      # Ensures that hash value specified by key is Array
-      # @param options [Hash] hash to be looked at
-      # @param key [Object] hash key
-      # @param default [Object] default value to be returned
-      # @raise [ArgumentError] unless value is Array
-      # @return [Array]
-      def assert_array!(options, key, default = nil)
-        value = options[key] || default
-        raise ArgumentError, "#{key} should be defined" unless value
-        raise ArgumentError, "#{key} should be array" unless value.is_a?(Array)
-        value
-      end
-
-      # Ensures that hash value specified by key can be converted to positive integer.
-      # In case it can makes in-place conversion and returns the value.
-      # @param options [Hash] hash to be looked at
-      # @param key [Object] hash key
-      # @param default [Object] default value to be returned
-      # @raise [ArgumentError] unless value is positive integer
-      # @return [Fixnum]
-      def assert_positive_integer!(options, key, default = nil)
-        value = options[key] || default
-        raise ArgumentError, "#{key} should be defined" unless value
-        raise ArgumentError, "#{key} should be integer" unless value.respond_to?(:to_i)
-        raise ArgumentError, "#{key} should be positive" unless value.to_i > 0
-        options[key] = value.to_i
-      end
-
-      # Ensures that hash value specified by key is can be converted to float
-      # and it is within given range.
-      # In case it can makes in-place conversion and returns the value.
-      # @param options [Hash] hash to be looked at
-      # @param key [Object] hash key
-      # @param from [Float] lower bound
-      # @param to [Float] upper bound
-      # @raise [ArgumentError] unless value is float within given range
-      # @return [Float]
-      def assert_ranged_float!(options, key, from, to)
-        f = options[key]
-        raise ArgumentError, "#{key} should be defined" unless f
-        raise ArgumentError, "#{key} should be float" unless f.respond_to?(:to_f)
-        f = f.to_f
-        raise ArgumentError, "#{key} should be between #{from} and #{to}" unless f >= from && f <= to
-        options[key] = f
-      end
-
-      # Generates uniq random string
-      # @return [String]
-      def uniqid
-        SecureRandom.hex(32)
-      end
-
-      # Capitalizes the first letter of each word in string
-      # @param str [String]
-      # @return [String]
-      # @raise [ArgumentError] unless passed value responds to to_s
-      def titleize(str)
-        raise ArgumentError unless str.respond_to?(:to_s)
-        str.to_s.split(/[\s_]+/).map(&:capitalize).join(' ')
-      end
-
-      # Converts string from snake_case to CamelCase
-      # @param str [String] string to be camelized
-      # @param first_letter_upper [TrueClass, FalseClass] says if the first letter must be uppercased
-      # @return [String]
-      # @raise [ArgumentError] unless passed value responds to to_s
-      def camelize(str, first_letter_upper = false)
-        raise ArgumentError unless str.respond_to?(:to_s)
-        terms = str.to_s.split(/_/)
-        first = terms.shift
-        (first_letter_upper ? first.capitalize : first.downcase) + terms.map(&:capitalize).join
-      end
-
-      # Converts string from CamelCase to snake_case
-      # @param str [String] string to be underscore
-      # @return [String]
-      # @raise [ArgumentError] unless passed value responds to to_s
-      def underscore(str)
-        raise ArgumentError unless str.respond_to?(:to_s)
-        str.to_s.gsub(/::/, '/').
-          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-          gsub(/([a-z\d])([A-Z])/,'\1_\2').
-          tr("-", "_").
-          downcase
-      end
-
-      # Converts string of the form YYYYmmddHHMMSS (considered as UTC) to Time
-      # @param str [String] string to be converted
-      # @return [Time]
-      # @raise [ArgumentError] unless passed value responds to to_s
-      def parse_time(str)
-        raise ArgumentError unless str.respond_to?(:to_s)
-        m = str.to_s.match(/\A(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\z/)
-        if m
-          Time.gm(*m.captures.map(&:to_i))
-        else
-          raise ArgumentError, "`#{str}' is not a YYYYmmddHHMMSS time"
-        end
-      end
-
-      # Symbolizes hash keys
-      def symbolize_keys(h)
-        h.each_with_object({}) do |(k, v), acc|
-          new_k = if k.respond_to?(:to_sym)
-            k.to_sym
-          else
-            k
-          end
-          acc[new_k] = v
-        end
-      end
-
-      # Deeply capitalizes Array values or Hash keys
-      def camelize_keys(item)
-        case item
-        when Array
-          item.map{|i| camelize_keys(i)}
-        when Hash
-          item.each_with_object({}) { |(k, v), h| h[camelize(k)] = camelize_keys(v)}
-        else
-          item
-        end
-      end
-      
-      # Yields block for each subset of given array
-      # @param array [Array] given array
-      def each_subset(array)
-        subsets_of(array).each {|subset| yield(subset)}
-      end
-
-      # Returs all array's subsets
-      # @param array [Array]
-      def subsets_of(array)
-        0.upto(array.length).flat_map { |n| array.combination(n).to_a }
-      end
-    end
-  end
-end