redis_counters 1.3.0

data/lib/redis_counters/unique_hash_counter.rb

@@ -0,0 +1,51 @@
+# coding: utf-8
+require 'redis_counters/hash_counter'
+
+module RedisCounters
+
+  # HashCounter, с возможностью подсчета только уникальных значений.
+
+  class UniqueHashCounter < HashCounter
+    UNIQUE_LIST_POSTFIX = 'uq'.freeze
+
+    UNIQUE_LIST_POSTFIX_DELIMITER = '_'.freeze
+
+    attr_reader :unique_values_list
+
+    protected
+
+    def process_value
+      unique_values_list.add(params) { super }
+    end
+
+    def init
+      super
+      @unique_values_list = unique_values_list_class.new(
+        redis,
+        unique_values_list_options
+      )
+    end
+
+    def unique_values_list_options
+      options.fetch(:unique_list).merge!(:counter_name => unique_values_list_name)
+    end
+
+    def unique_values_list_name
+      [counter_name, UNIQUE_LIST_POSTFIX].join(unique_list_postfix_delimiter)
+    end
+
+    def unique_values_list_class
+      unique_values_list_options.fetch(:list_class).to_s.constantize
+    end
+
+    def unique_list_postfix_delimiter
+      @unique_list_postfix_delimiter ||= options.fetch(:unique_list_postfix_delimiter, UNIQUE_LIST_POSTFIX_DELIMITER)
+    end
+
+    def partitions_keys(params = {})
+      # удаляем из списка партиций, ключи в которых хранятся списки уникальных значений
+      super.delete_if { |partition| partition.start_with?(unique_values_list_name) }
+    end
+  end
+
+end

data/lib/redis_counters/unique_values_lists/base.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+require 'redis_counters/base_counter'
+require 'redis_counters/clusterize_and_partitionize'
+
+module RedisCounters
+  module UniqueValuesLists
+
+    # Базовый класс списка уникальных значений,
+    # с возможностью кластеризации и партиционирования.
+
+    class Base < RedisCounters::BaseCounter
+      include RedisCounters::ClusterizeAndPartitionize
+
+      alias_method :add, :process
+      alias_method :<<, :process
+
+      # Public: Проверяет существует ли заданное значение.
+      #
+      # params - Hash - параметры кластера и значения.
+      #
+      # Returns Boolean.
+      #
+      def has_value?(params)
+        raise NotImplementedError
+      end
+
+      protected
+
+      def value
+        value_params = value_keys.map { |key| params.fetch(key) }
+        value_params.join(value_delimiter)
+      end
+
+      def value_keys
+        @value_keys ||= Array.wrap(options.fetch(:value_keys))
+      end
+
+      # Protected: Возвращает данные партиции в виде массива хешей.
+      #
+      # Каждый элемент массива, представлен в виде хеша, содержащего все параметры уникального значения.
+      #
+      # cluster   - Array - листовой кластер - массив параметров однозначно идентифицирующий кластер.
+      # partition - Array - листовая партиция - массив параметров однозначно идентифицирующий партицию.
+      #
+      # Returns Array of WithIndifferentAccess.
+      #
+      def partition_data(cluster, partition)
+        keys = value_keys
+        redis.smembers(key(partition, cluster)).inject(Array.new) do |result, (key, value)|
+          values = key.split(value_delimiter, -1) << value.to_i
+          result << Hash[keys.zip(values)].with_indifferent_access
+        end
+      end
+    end
+
+  end
+end

data/lib/redis_counters/unique_values_lists/blocking.rb

@@ -0,0 +1,167 @@
+# coding: utf-8
+require 'redis_counters/unique_values_lists/base'
+
+module RedisCounters
+  module UniqueValuesLists
+
+    # Список уникальных значений, на основе механизма оптимистических блокировок.
+    #
+    # смотри Optimistic locking using check-and-set:
+    # http://redis.io/topics/transactions
+    #
+    # Особенности:
+    #   * Значения сохраняет в партициях;
+    #   * Ведет список партиций;
+    #   * Полностью транзакционен.
+
+    class Blocking < Base
+      PARTITIONS_LIST_POSTFIX = :partitions
+
+      # Public: Проверяет существует ли заданное значение.
+      #
+      # params - Hash - параметры кластера и значения.
+      #
+      # Returns Boolean.
+      #
+      def has_value?(params)
+        set_params(params)
+        reset_partitions_cache
+        value_already_exists?
+      end
+
+      # Public: Нетранзакционно удаляет данные конкретной конечной партиции.
+      #
+      # params        - Hash - хеш параметров, определяющий кластер и партицию.
+      # write_session - Redis - соединение с Redis, в рамках которого
+      #                 будет производится удаление (опционально).
+      #                 По умолчанию - основное соединение счетчика.
+      #
+      # Если передан блок, то вызывает блок, после удаления всех данных, в транзакции.
+      #
+      # Returns Nothing.
+      #
+      def delete_partition_direct!(params = {}, write_session = redis)
+        super(params, write_session)
+
+        # удаляем партицию из списка
+        return unless use_partitions?
+
+        cluster = ::RedisCounters::Cluster.new(self, params).params
+        partition = ::RedisCounters::Partition.new(self, params).params(:only_leaf => true)
+
+        partition = partition.flatten.join(key_delimiter)
+        write_session.lrem(partitions_list_key(cluster), 0, partition)
+      end
+
+      protected
+
+      def key(partition = partition_params, cluster = cluster_params)
+        return super if use_partitions?
+
+        raise 'Array required' if partition && !partition.is_a?(Array)
+        raise 'Array required' if cluster && !cluster.is_a?(Array)
+
+        [counter_name, cluster, partition].flatten.compact.join(key_delimiter)
+      end
+
+      def process_value
+        loop do
+          reset_partitions_cache
+
+          watch_partitions_list
+          watch_all_partitions
+
+          if value_already_exists?
+            redis.unwatch
+            return false
+          end
+
+          result = transaction do
+            add_value
+            add_partition
+            yield redis if block_given?
+          end
+
+          return true if result.present?
+        end
+      end
+
+      def reset_partitions_cache
+        @partitions = nil
+      end
+
+      def watch_partitions_list
+        return unless use_partitions?
+        redis.watch(partitions_list_key)
+      end
+
+      def watch_all_partitions
+        all_partitions.each do |partition|
+          redis.watch(key(partition))
+        end
+      end
+
+      def value_already_exists?
+        all_partitions.reverse.any? do |partition|
+          redis.sismember(key(partition), value)
+        end
+      end
+
+      def add_value
+        redis.sadd(key, value)
+      end
+
+      def all_partitions(cluster = cluster_params)
+        return @partitions unless @partitions.nil?
+        return (@partitions = [nil]) unless use_partitions?
+
+        @partitions = redis.lrange(partitions_list_key(cluster), 0, -1)
+        @partitions = @partitions.map do |partition|
+          partition.split(key_delimiter, -1)
+        end.delete_if(&:empty?)
+      end
+
+      def add_partition
+        return unless use_partitions?
+        return unless new_partition?
+        redis.rpush(partitions_list_key, current_partition)
+      end
+
+      def partitions_list_key(cluster = cluster_params)
+        raise 'Array required' if cluster && !cluster.is_a?(Array)
+
+        [counter_name, cluster, PARTITIONS_LIST_POSTFIX].flatten.join(key_delimiter)
+      end
+
+      def current_partition
+        partition_params.flatten.join(key_delimiter)
+      end
+
+      def new_partition?
+        !all_partitions.include?(current_partition.split(key_delimiter))
+      end
+
+
+      # Protected: Возвращает массив листовых партиций в виде ключей.
+      #
+      # Если кластер не указан и нет кластеризации в счетчике, то возвращает все партиции.
+      # Если партиция не указана, возвращает все партиции кластера (все партиции, если нет кластеризации).
+      #
+      # params  - Hash - хеш параметров, определяющий кластер и партицию.
+      #
+      # Returns Array of Hash.
+      #
+      def partitions_keys(params = {})
+        reset_partitions_cache
+
+        cluster = ::RedisCounters::Cluster.new(self, params).params
+        partition = ::RedisCounters::Partition.new(self, params).params
+
+        partitions_keys = all_partitions(cluster).map { |part| key(part, cluster) }
+
+        fuzzy_pattern = key(partition, cluster)
+        partitions_keys.select { |part| part.start_with?(fuzzy_pattern) }
+      end
+    end
+  end
+end

data/lib/redis_counters/unique_values_lists/expirable.rb

@@ -0,0 +1,155 @@
+# coding: utf-8
+
+require 'redis_counters/unique_values_lists/blocking'
+require 'active_support/core_ext/module/aliasing'
+
+module RedisCounters
+  module UniqueValuesLists
+
+    # Список уникальных значений, с возможностью expire отдельных элементов.
+    #
+    # На основе сортированного множества.
+    # http://redis4you.com/code.php?id=010
+    #
+    # На основе механизма оптимистических блокировок.
+    # смотри Optimistic locking using check-and-set:
+    # http://redis.io/topics/transactions
+    #
+    # Особенности:
+    #   * Expire - таймаут, можно установить как на уровне счетчика,
+    #     так и на уровне отдельного занчения;
+    #   * Очистка возможна как в автоматическогом режиме так в и ручном;
+    #   * Значения сохраняет в партициях;
+    #   * Ведет список партиций;
+    #   * Полностью транзакционен.
+    #
+    # Пример:
+    #
+    # counter = RedisCounters::UniqueValuesLists::Expirable.new(redis,
+    #   :counter_name => :sessions,
+    #   :value_keys   => [:session_id],
+    #   :expire       => 10.minutes
+    # )
+    #
+    # counter << session_id: 1
+    # counter << session_id: 2
+    # counter << session_id: 3, expire: :never
+    #
+    # counter.data
+    # > [{session_id: 1}, {session_id: 2}, {session_id: 3}]
+    #
+    # # after 10 minutes
+    #
+    # counter.data
+    # > [{session_id: 3}]
+    #
+    # counter.has_value?(session_id: 1)
+    # false
+
+    class Expirable < Blocking
+      DEFAULT_AUTO_CLEAN_EXPIRED = true
+      DEFAULT_VALUE_TIMEOUT = :never
+
+      NEVER_EXPIRE_TIMESTAMP = 0
+
+      # Public: Производит принудительную очистку expired - значений.
+      #
+      # cluster - Hash - параметры кластера, если используется кластеризация.
+      #
+      # Returns nothing.
+      #
+      def clean_expired(cluster = {})
+        set_params(cluster)
+        internal_clean_expired
+      end
+
+      protected
+
+      def add_value
+        redis.zadd(key, value_expire_timestamp, value)
+      end
+
+      def reset_partitions_cache
+        super
+        internal_clean_expired if auto_clean_expired?
+      end
+
+      alias_method :clean, :reset_partitions_cache
+
+      def current_timestamp
+        Time.now.to_i
+      end
+
+      def value_already_exists?
+        all_partitions.reverse.any? do |partition|
+          redis.zrank(key(partition), value).present?
+        end
+      end
+
+      def internal_clean_expired
+        all_partitions.each do |partition|
+          redis.zremrangebyscore(key(partition), "(#{NEVER_EXPIRE_TIMESTAMP}", current_timestamp)
+        end
+      end
+
+      def value_expire_timestamp
+        timeout = params[:expire] || default_value_expire
+
+        case timeout
+          when Symbol
+            NEVER_EXPIRE_TIMESTAMP
+          else
+            current_timestamp + timeout.to_i
+        end
+      end
+
+      def default_value_expire
+        @default_value_expire ||= options[:expire].try(:seconds) || DEFAULT_VALUE_TIMEOUT
+      end
+
+      def auto_clean_expired?
+        @auto_clean_expired ||= options.fetch(:clean_expired, DEFAULT_AUTO_CLEAN_EXPIRED)
+      end
+
+      def partitions_with_clean(params = {})
+        clean_empty_partitions(params)
+        partitions_without_clean(params)
+      end
+
+      alias_method_chain :partitions, :clean
+
+      # Protected: Производит очистку expired - значений и пустых партиций.
+      #
+      # params - Hash - параметры кластера, если используется кластеризация.
+      #
+      # Returns nothing.
+      #
+      def clean_empty_partitions(params)
+        set_params(params)
+        clean
+
+        partitions_without_clean(params).each do |partition|
+          next if redis.zcard(key(partition.values)).nonzero?
+          delete_partition_direct!(params.merge(partition))
+        end
+      end
+
+      # Protected: Возвращает данные партиции в виде массива хешей.
+      #
+      # Каждый элемент массива, представлен в виде хеша, содержащего все параметры уникального значения.
+      #
+      # cluster   - Array - листовой кластер - массив параметров однозначно идентифицирующий кластер.
+      # partition - Array - листовая партиция - массив параметров однозначно идентифицирующий партицию.
+      #
+      # Returns Array of WithIndifferentAccess.
+      #
+      def partition_data(cluster, partition)
+        keys = value_keys
+        redis.zrangebyscore(key(partition, cluster), '-inf', '+inf').inject(Array.new) do |result, (key, value)|
+          values = key.split(value_delimiter, -1) << value.to_i
+          result << Hash[keys.zip(values)].with_indifferent_access
+        end
+      end
+    end
+  end
+end

data/lib/redis_counters/unique_values_lists/non_blocking.rb

@@ -0,0 +1,91 @@
+# coding: utf-8
+require 'redis_counters/unique_values_lists/base'
+
+module RedisCounters
+  module UniqueValuesLists
+
+    # Список уникальных значений, на основе не блокирующего алгоритма.
+    #
+    # Особенности:
+    #   * 2-х кратный расход памяти в случае использования партиций;
+    #   * Не ведет список партиций;
+    #   * Не транзакционен;
+    #   * Методы delete_partitions! и delete_partition_direct!, удаляют только дублирующие партиции,
+    #     но не удаляют данные из основной партиции.
+    #     Для удаления основной партиции необходимо вызвать delete_main_partition!
+    #     или воспользоваться методами delete_all! или delete_all_direct!,
+    #     для удаления всех партиций кластера включая основную.
+
+    class NonBlocking < Base
+
+      # Public: Проверяет существует ли заданное значение.
+      #
+      # params - Hash - параметры кластера и значения.
+      #
+      # Returns Boolean.
+      #
+      def has_value?(params)
+        set_params(params)
+        redis.sismember(main_partition_key, value)
+      end
+
+      # Public: Нетранзакционно удаляет все данные счетчика в кластере, включая основную партицию.
+      # Если кластеризация не используется, то удаляет все данные.
+      #
+      # cluster       - Hash - хеш параметров, определяющих кластер.
+      # write_session - Redis - соединение с Redis, в рамках которого
+      #                 будет производится удаление (опционально).
+      #                 По умолчанию - основное соединение счетчика.
+      #
+      # Returns Nothing.
+      #
+      def delete_all_direct!(cluster, write_session = redis, parts = partitions(cluster))
+        super(cluster, write_session, parts)
+        delete_main_partition!(cluster, write_session)
+      end
+
+      # Public: Удаляет основную партицию.
+      #
+      # cluster       - Hash - хеш параметров, определяющих кластер.
+      #                 Опционально, если кластеризация не используется.
+      # write_session - Redis - соединение с Redis, в рамках которого
+      #                 будет производится удаление (опционально).
+      #                 По умолчанию - основное соединение счетчика.
+      #
+      # Returns Nothing.
+      #
+      def delete_main_partition!(cluster = {}, write_session = redis)
+        cluster = ::RedisCounters::Cluster.new(self, cluster).params
+        key = key(main_partition, cluster)
+        write_session.del(key)
+      end
+
+      protected
+
+      def process_value
+        return unless add_value
+        yield redis if block_given?
+        true
+      end
+
+      def add_value
+        return unless redis.sadd(main_partition_key, value)
+        redis.sadd(current_partition_key, value) if use_partitions?
+        true
+      end
+
+      def main_partition_key
+        key(main_partition)
+      end
+
+      def current_partition_key
+        key
+      end
+
+      def main_partition
+        []
+      end
+    end
+
+  end
+end