redis_counters 1.3.0

data/lib/redis_counters/base_counter.rb

@@ -0,0 +1,84 @@
+# coding: utf-8
+require 'forwardable'
+require 'active_support/core_ext/class/attribute'
+
+module RedisCounters
+
+  # Базовый класс счетчика на основе Redis.
+
+  class BaseCounter
+    extend Forwardable
+
+    KEY_DELIMITER = ':'.freeze
+    VALUE_DELIMITER = ':'.freeze
+
+    attr_reader :redis
+    attr_reader :options
+    attr_reader :params
+
+    # Public: Фабричный метод создания счетчика заданного класса.
+    #
+    # redis - Redis - экземпляр redis - клиента.
+    # opts - Hash - хеш опций счетчика:
+    #        counter_name - Symbol/String - идентификатор счетчика.
+    #        key_delimiter - String - разделитель ключа (опционально).
+    #        value_delimiter - String - разделитель значений (опционально).
+    #
+    # Returns RedisCounters::BaseCounter.
+    #
+    def self.create(redis, opts)
+      counter_class = opts.fetch(:counter_class).to_s.constantize
+      counter_class.new(redis, opts)
+    end
+
+    # Public: Конструктор.
+    #
+    # см. self.create.
+    #
+    # Returns RedisCounters::BaseCounter.
+    #
+    def initialize(redis, opts)
+      @redis = redis
+      @options = opts
+      init
+    end
+
+    # Public: Метод производит обработку события.
+    #
+    # params - Hash - хеш параметров события.
+    #
+    # Returns process_value result.
+    #
+    def process(params = {}, &block)
+      @params = params.with_indifferent_access
+      process_value(&block)
+    end
+
+    def name
+      options[:counter_name]
+    end
+
+    alias_method :id, :name
+
+    protected
+
+    def init
+      counter_name.present?
+    end
+
+    def counter_name
+      @counter_name ||= options.fetch(:counter_name)
+    end
+
+    def key_delimiter
+      @key_delimiter ||= options.fetch(:key_delimiter, KEY_DELIMITER)
+    end
+
+    def value_delimiter
+      @value_delimiter ||= options.fetch(:value_delimiter, VALUE_DELIMITER)
+    end
+
+    def_delegator :redis, :multi, :transaction
+  end
+
+end

data/lib/redis_counters/bucket.rb

@@ -0,0 +1,59 @@
+# coding: utf-8
+module RedisCounters
+
+  class Bucket
+
+    def self.default_options
+      {:only_leaf => false}
+    end
+
+    def initialize(counter, bucket_params)
+      @counter = counter
+      @bucket_params = bucket_params.with_indifferent_access
+
+      if bucket_keys.present? && bucket_params.blank? && required?
+        raise ArgumentError, "You must specify a #{self.class.name}"
+      end
+    end
+
+    attr_reader :counter
+    attr_reader :bucket_params
+
+    # Protected: Возвращает букет в виде массива параметров, однозначно его идентифицирующих.
+    #
+    # cluster - Hash - хеш параметров, определяющий букет.
+    # options - Hash - хеш опций:
+    #           :only_leaf - Boolean - выбирать только листовые букеты (по умолачнию - true).
+    #                        Если флаг установлен в true и передана не листовой букет, то
+    #                        будет сгенерировано исключение KeyError.
+    #
+    # Метод генерирует исключение ArgumentError, если переданы параметры не верно идентифицирующие букет.
+    # Например: ключи группировки счетчика {:param1, :param2, :param3}, а переданы {:param1, :param3}.
+    # Метод генерирует исключение ArgumentError, 'You must specify a cluster',
+    # если букет передан в виде пустого хеша, но группировка используется в счетчике.
+    #
+    # Returns Array.
+    #
+    def params(options = {})
+      options.reverse_merge!(self.class.default_options)
+
+      bucket_keys.inject(Array.new) do |result, key|
+        param = (options[:only_leaf] ? bucket_params.fetch(key) : bucket_params[key])
+        next result unless bucket_params.has_key?(key)
+        next result << param if result.size >= bucket_keys.index(key)
+
+        raise ArgumentError, 'An incorrectly specified %s %s' % [self.class.name, bucket_params]
+      end
+    end
+
+    protected
+
+    def bucket_keys
+      raise NotImplementedError.new 'You must specify the grouping key'
+    end
+
+    def required?
+      false
+    end
+  end
+end

data/lib/redis_counters/cluster.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+
+require 'redis_counters/bucket'
+
+module RedisCounters
+
+  class Cluster < Bucket
+    def self.default_options
+      {:only_leaf => true}
+    end
+
+    protected
+
+    def bucket_keys
+      counter.send(:cluster_keys)
+    end
+
+    def required?
+      true
+    end
+  end
+end

data/lib/redis_counters/clusterize_and_partitionize.rb

@@ -0,0 +1,194 @@
+# coding: utf-8
+
+require 'redis_counters/cluster'
+require 'redis_counters/partition'
+
+module RedisCounters
+  module ClusterizeAndPartitionize
+    # Public: Возвращает массив партиций (подпартиций) кластера в виде хешей.
+    #
+    # Если партиция не указана, возвращает все партиции кластера.
+    #
+    # params - Hash - хеш параметров, определяющий кластер и партицию.
+    #
+    # Партиция может быть не задана, тогда будут возвращены все партиции кластера.
+    # Может быть задана не листовая партиция, тогда будут все её листовые подпартции.
+    #
+    # Returns Array Of Hash.
+    #
+    def partitions(params = {})
+      partitions_keys(params).map do |part|
+        # parse and exclude counter_name and cluster
+        part = part.split(key_delimiter, -1).from(1).from(cluster_keys.size)
+        # construct hash
+        Hash[partition_keys.zip(part)].with_indifferent_access
+      end
+    end
+
+    # Public: Возвращает данные счетчика для указанной кластера из указанных партиций.
+    #
+    # params - Hash - хеш параметров, определяющий кластер и партицию.
+    #
+    # Партиция может быть не задана, тогда будут возвращены все партиции кластера.
+    # Может быть задана не листовая партиция, тогда будут все её листовые подпартции.
+    #
+    # Если передан блок, то вызывает блок для каждой партиции.
+    # Если блок, не передн, то аккумулирует данные,
+    # из всех запрошенных партиций, и затем возвращает их.
+    #
+    # Returns Array Of Hash.
+    #
+    def data(params = {})
+      total_rows = 0
+      cluster = ::RedisCounters::Cluster.new(self, params).params
+      parts = partitions(params).map { |partition| ::RedisCounters::Partition.new(self, partition).params }
+
+      result = parts.flat_map do |partition|
+        rows = partition_data(cluster, partition)
+        total_rows += rows.size
+        block_given? ? yield(rows) : rows
+      end
+
+      block_given? ? total_rows : result
+    end
+
+    # Public: Транзакционно удаляет данные указанной партиций или всех её подпартиций.
+    #
+    # params - Hash - хеш параметров, определяющий кластер и партицию.
+    #
+    # Партиция может быть не задана, тогда будут возвращены все партиции кластера.
+    # Может быть задана не листовая партиция, тогда будут все её листовые подпартции.
+    #
+    # Если передан блок, то вызывает блок, после удаления всех данных, в транзакции.
+    #
+    # Returns Nothing.
+    #
+    def delete_partitions!(params = {})
+      parts = partitions(params)
+
+      transaction do
+        parts.each { |partition| delete_partition_direct!(params.merge(partition)) }
+        yield if block_given?
+      end
+    end
+
+    # Public: Транзакционно удаляет все данные счетчика в кластере.
+    # Если кластеризация не используется, то удаляет все данные.
+    #
+    # cluster - Hash - хеш параметров, определяющих кластер.
+    #                  Опционально, если кластеризация не используется.
+    #
+    # Если передан блок, то вызывает блок, после удаления всех данных, в транзакции.
+    #
+    # Returns Nothing.
+    #
+    def delete_all!(cluster = {})
+      parts = partitions(cluster)
+
+      transaction do
+        delete_all_direct!(cluster, redis, parts)
+        yield if block_given?
+      end
+    end
+
+    # Public: Нетранзакционно удаляет данные конкретной конечной партиции.
+    #
+    # params        - Hash - хеш параметров, определяющий кластер и листовую партицию.
+    #
+    # write_session - Redis - соединение с Redis, в рамках которого
+    #                 будет производится удаление (опционально).
+    #                 По умолчанию - основное соединение счетчика.
+    #
+    # Должна быть задана конкретная листовая партиция.
+    #
+    # Returns Nothing.
+    #
+    def delete_partition_direct!(params = {}, write_session = redis)
+      cluster = ::RedisCounters::Cluster.new(self, params).params
+      partition = ::RedisCounters::Partition.new(self, params).params(:only_leaf => true)
+      key = key(partition, cluster)
+      write_session.del(key)
+    end
+
+    # Public: Нетранзакционно удаляет все данные счетчика в кластере.
+    # Если кластеризация не используется, то удаляет все данные.
+    #
+    # cluster       - Hash - хеш параметров, определяющих кластер.
+    # write_session - Redis - соединение с Redis, в рамках которого
+    #                 будет производится удаление (опционально).
+    #                 По умолчанию - основное соединение счетчика.
+    #
+    # Returns Nothing.
+    #
+    def delete_all_direct!(cluster, write_session = redis, parts = partitions(cluster))
+      parts.each do |partition|
+        delete_partition_direct!(cluster.merge(partition), write_session)
+      end
+    end
+
+    protected
+
+    def key(partition = partition_params, cluster = cluster_params)
+      raise 'Array required' if partition && !partition.is_a?(Array)
+      raise 'Array required' if cluster && !cluster.is_a?(Array)
+
+      [counter_name, cluster, partition].flatten.join(key_delimiter)
+    end
+
+    def cluster_params
+      cluster_keys.map { |key| params.fetch(key) }
+    end
+
+    def partition_params
+      partition_keys.map do |key|
+        key.respond_to?(:call) ? key.call(params) : params.fetch(key)
+      end
+    end
+
+    def cluster_keys
+      @cluster_keys ||= Array.wrap(options.fetch(:cluster_keys, []))
+    end
+
+    def partition_keys
+      @partition_keys ||= Array.wrap(options.fetch(:partition_keys, []))
+    end
+
+    def use_partitions?
+      partition_keys.present?
+    end
+
+    def set_params(params)
+      @params = params.with_indifferent_access
+      check_cluster_params
+    end
+
+    def form_cluster_params(cluster_params = params)
+      RedisCounters::Cluster.new(self, cluster_params).params
+    end
+
+    alias_method :check_cluster_params, :form_cluster_params
+
+    # Protected: Возвращает массив листовых партиций в виде ключей.
+    #
+    # params - Hash - хеш параметров, определяющий кластер и партицию.
+    #
+    # Если кластер не указан и нет кластеризации в счетчике, то возвращает все партиции.
+    # Партиция может быть не задана, тогда будут возвращены все партиции кластера (все партиции, если нет кластеризации).
+    # Может быть задана не листовая партиция, тогда будут все её листовые подпартции.
+    #
+    # Returns Array of Hash.
+    #
+    def partitions_keys(params = {})
+      cluster = ::RedisCounters::Cluster.new(self, params).params
+      partition = ::RedisCounters::Partition.new(self, params).params
+
+      strict_pattern = key(partition, cluster) if (cluster.present? && partition_keys.blank?) || partition.present?
+      fuzzy_pattern = key(partition << '*', cluster)
+
+      result = []
+      result |= redis.keys(strict_pattern) if strict_pattern.present?
+      result |= redis.keys(fuzzy_pattern) if fuzzy_pattern.present?
+      result
+    end
+  end
+end

data/lib/redis_counters/hash_counter.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+require 'redis_counters/base_counter'
+require 'redis_counters/clusterize_and_partitionize'
+
+module RedisCounters
+
+  # Счетчик на основе redis-hash, с возможностью партиционирования и кластеризации значений.
+
+  class HashCounter < BaseCounter
+    include ClusterizeAndPartitionize
+
+    alias_method :increment, :process
+
+    protected
+
+    def process_value
+      redis.hincrbyfloat(key, field, params.fetch(:value, 1.0))
+    end
+
+    def field
+      if group_keys.present?
+        group_params = group_keys.map { |key| params.fetch(key) }
+      else
+        group_params = [field_name]
+      end
+
+      group_params.join(value_delimiter)
+    end
+
+    def field_name
+      @field_name ||= options.fetch(:field_name)
+    end
+
+    def group_keys
+      @group_keys ||= Array.wrap(options.fetch(:group_keys, []))
+    end
+
+    # Protected: Возвращает данные партиции в виде массива хешей.
+    #
+    # Каждый элемент массива, представлен в виде хеша, содержащего все параметры кластеризации и
+    # значение счетчика в ключе :value.
+    #
+    # cluster - Array - листовой кластер - массив параметров однозначно идентифицирующий кластер.
+    # partition - Array - листовая партиция - массив параметров однозначно идентифицирующий партицию.
+    #
+    # Returns Array of WithIndifferentAccess.
+    #
+    def partition_data(cluster, partition)
+      keys = group_keys.dup << :value
+      redis.hgetall(key(partition, cluster)).inject(Array.new) do |result, (key, value)|
+        values = key.split(value_delimiter, -1) << format_value(value)
+        values = values.from(1) unless group_keys.present?
+        result << Hash[keys.zip(values)].with_indifferent_access
+      end
+    end
+
+    def format_value(value)
+      if float_mode?
+        value.to_f
+      else
+        value.to_i
+      end
+    end
+
+    def float_mode?
+      @float_mode ||= options.fetch(:float_mode, false)
+    end
+  end
+
+end

data/lib/redis_counters/partition.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+
+require 'redis_counters/bucket'
+
+module RedisCounters
+
+  class Partition < Bucket
+    def self.default_options
+      {:only_leaf => false}
+    end
+
+    def bucket_keys
+      counter.send(:partition_keys)
+    end
+  end
+end