simple-feed 1.0.2

data/lib/simplefeed/providers/redis/provider.rb

@@ -0,0 +1,255 @@
+require 'redis'
+require 'base62-rb'
+require 'forwardable'
+require 'redis/pipeline' # defines Redis::Future
+
+require 'simplefeed/providers/base/provider'
+require 'simplefeed/providers/serialization/key'
+
+require_relative 'driver'
+require_relative 'stats'
+
+require 'pp'
+
+module SimpleFeed
+  module Providers
+    module Redis
+      # Internal data structure:
+      #
+      #   ```YAML
+      #     u.afkj234.data:
+      #       - [ 'John liked Robert', '2016-11-20 23:32:56 -0800' ]
+      #       - [ 'Debbie liked Robert', '2016-11-20 23:35:56 -0800' ]
+      #     u.afkj234.meta: { total: 2, unread: 2, last_read: 2016-11-20 22:00:34 -08:00 GMT }
+      #   ```
+      class Provider < ::SimpleFeed::Providers::Base::Provider
+
+        # SimpleFeed::Providers.define_provider_methods(self) do |provider, method, **opts, &block|
+        #   users = Users.new(provider: provider, user_ids: opts.delete(:user_ids))
+        #   opts.empty? ?
+        #     users.send(method, &block) :
+        #     users.send(method, **opts, &block)
+        # end
+        #
+
+        include Driver
+
+        def store(user_ids:, value:, at: Time.now)
+          with_response_pipelined(user_ids) do |redis, key|
+            tap redis.zadd(key.data, at.to_f, value) do
+              redis.zremrangebyrank(key.data, 0, -feed.max_size - 1)
+            end
+          end
+        end
+
+        def delete(user_ids:, value:, **)
+          with_response_pipelined(user_ids) do |redis, key|
+            redis.zrem(key.data, value)
+          end
+        end
+
+        def delete_if(user_ids:)
+          raise ArgumentError, '#delete_if must be called with a block that receives (user_id, event) as arguments.' unless block_given?
+          with_response_batched(user_ids) do |key|
+            fetch(user_ids: [key.user_id])[key.user_id].each do |event|
+              with_redis do |redis|
+                yield(key.user_id, event) ? redis.zrem(key.data, event.value) : false
+              end
+            end
+          end
+        end
+
+        def wipe(user_ids:)
+          with_response_pipelined(user_ids) do |redis, key|
+            should_wipe = block_given? ? yield(key.user_id) : true
+            key.keys.all? { |redis_key| redis.del(redis_key) if should_wipe }
+          end
+        end
+
+        def paginate(user_ids:, page:, per_page: feed.per_page, peek: false, with_total: false)
+          reset_last_read(user_ids: user_ids) unless peek
+          with_response_pipelined(user_ids) do |redis, key|
+            events = paginated_events(page, per_page, redis, key)
+            with_total ? { events:      events,
+                           total_count: redis.zcard(key.data) } : events
+          end
+        end
+
+
+        def fetch(user_ids:)
+          with_response_pipelined(user_ids) do |redis, key|
+            redis.zrevrange(key.data, 0, -1, withscores: true)
+          end
+        end
+
+        def reset_last_read(user_ids:, at: Time.now)
+          with_response_pipelined(user_ids) do |redis, key, *|
+            reset_users_last_read(redis, key, at.to_f)
+          end
+        end
+
+        def total_count(user_ids:)
+          with_response_pipelined(user_ids) do |redis, key|
+            redis.zcard(key.data)
+          end
+        end
+
+        def unread_count(user_ids:)
+          response = with_response_pipelined(user_ids) do |redis, key|
+            get_users_last_read(redis, key)
+          end
+          with_response_pipelined(response.user_ids, response) do |redis, key, _response|
+            last_read = _response.delete(key.user_id).to_f
+            redis.zcount(key.data, last_read, '+inf')
+          end
+        end
+
+        def last_read(user_ids:)
+          with_response_pipelined(user_ids) do |redis, key, *|
+            get_users_last_read(redis, key)
+          end
+        end
+
+        FEED_METHODS = %i(total_memory_bytes total_users last_disk_save_time)
+
+        def total_memory_bytes
+          with_stats(:used_memory_since_boot)
+        end
+
+        def total_users
+          with_redis { |redis| redis.dbsize / 2 }
+        end
+
+        def with_stats(operation)
+          with_redis do |redis|
+            SimpleFeed::Providers::Redis::Stats.new(redis).send(operation)
+          end
+        end
+
+        def transform_response(user_id = nil, result)
+          case result
+            when ::Redis::Future
+              transform_response(user_id, result.value)
+
+            when ::Hash
+
+              if result.values.any? { |v| transformable_type?(v) }
+                result.each { |k, v| result[k] = transform_response(user_id, v) }
+              else
+                result
+              end
+
+            when ::Array
+
+              if result.any? { |v| transformable_type?(v) }
+                result = result.map { |v| transform_response(user_id, v) }
+              end
+
+              if result.size == 2 && result[1].is_a?(Float)
+                SimpleFeed::Event.new(value: result[0], at: Time.at(result[1]))
+              else
+                result
+              end
+
+            when ::String
+              if result =~ /^\d+\.\d+$/
+                result.to_f
+              elsif result =~ /^\d+$/
+                result.to_i
+              else
+                result
+              end
+            else
+              result
+          end
+        end
+
+        def transformable_type?(value)
+          [
+            ::Redis::Future,
+            ::Hash,
+            ::Array,
+            ::String
+          ].include?(value.class)
+        end
+
+        private
+
+        #——————————————————————————————————————————————————————————————————————————————————————
+        # helpers
+        #——————————————————————————————————————————————————————————————————————————————————————
+
+        def reset_users_last_read(redis, key, time = nil)
+          time = time.nil? ? Time.now.to_f : time.to_f
+          redis.hset(key.meta, 'last_read', time)
+          Time.at(time)
+        end
+
+        # returns a string containing a float, which must then be
+        # converted into float in #transform
+        def get_users_last_read(redis, key)
+          redis.hget(key.meta, 'last_read')
+        end
+
+        def paginated_events(page, per_page, redis, key)
+          redis.zrevrange(key.data, (page - 1) * per_page, page * per_page - 1, withscores: true)
+        end
+
+        #——————————————————————————————————————————————————————————————————————————————————————
+        # Operations with response
+        #——————————————————————————————————————————————————————————————————————————————————————
+
+        def with_response_pipelined(user_ids, response = nil)
+          with_response(response) do |response|
+            batch_pipelined(user_ids) do |redis, key|
+              response.for(key.user_id) { yield(redis, key, response) }
+            end
+          end
+        end
+
+        def with_response_multi(user_ids, response = nil)
+          with_response(response) do |response|
+            batch_multi(user_ids) do |redis, key|
+              response.for(key.user_id) { yield(redis, key, response) }
+            end
+          end
+        end
+
+        #——————————————————————————————————————————————————————————————————————————————————————
+        # Batch operations
+        #——————————————————————————————————————————————————————————————————————————————————————
+        def batch_pipelined(user_ids)
+          to_array(user_ids).each_slice(batch_size) do |batch|
+            with_pipelined do |redis|
+              batch.each do |user_id|
+                yield(redis, key(user_id))
+              end
+            end
+          end
+        end
+
+        def batch_pipelined_multi(user_ids)
+          to_array(user_ids).each_slice(batch_size) do |batch|
+            with_pipelined do
+              batch.each do |user_id|
+                with_multi do |redis|
+                  yield(redis, key(user_id))
+                end
+              end
+            end
+          end
+        end
+
+        def batch_multi(user_ids)
+          to_array(user_ids).each_slice(batch_size) do |batch|
+            batch.each do |user_id|
+              with_multi do |redis|
+                yield(redis, key(user_id))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simplefeed/providers/redis/stats.rb

@@ -0,0 +1,85 @@
+require 'redis'
+require 'hashie/mash'
+require 'yaml'
+
+module SimpleFeed
+  module Providers
+    module Redis
+      class Stats
+
+        attr_accessor :redis
+
+        def initialize(redis)
+          self.redis = redis
+        end
+
+        def info
+          self.class.destringify(redis.info)
+        end
+
+        def boot_info
+          self.class.boot_info
+        end
+
+        @boot_info = nil
+
+        class << self
+          attr_accessor :boot_info
+
+          # Converts strings values of a hash into floats or integers,
+          # if the string matches a corresponding pattern.
+          def destringify(hash)
+            db_hash = {}
+            hash.each_pair do |key, value|
+              if key =~ /^db\d+$/
+                h = {}
+                value.split(/,/).each do |word|
+                  *words      = word.split(/=/)
+                  h[words[0]] = words[1]
+                end
+                destringify(h)
+                db_hash[key.gsub(/^db/, '').to_i] = h
+                hash.delete(key)
+              else
+                hash[key] =
+                  if value =~ /^-?\d+$/
+                    value.to_i
+                  elsif value =~ /^-?\d*\.\d+$/
+                    value.to_f
+                  else
+                    value
+                  end
+              end
+            end
+            hash[:dbstats] = db_hash unless db_hash.empty?
+            Hashie::Mash.new(hash)
+          end
+
+          def load_boot_stats!
+            @boot_info ||= destringify(YAML.load(File.open(File.expand_path('../boot_info.yml', __FILE__))))
+          end
+
+        end
+
+        load_boot_stats!
+
+        boot_info.keys.each do |key|
+          unless key.to_s =~ /^db[0-9]+/
+
+            define_method(key.to_sym) do
+              info[key]
+            end
+
+            define_method("#{key}_at_boot".to_sym) do
+              boot_info[key]
+            end
+
+            define_method("#{key}_since_boot".to_sym) do
+              info[key] - boot_info[key]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simplefeed/providers/serialization/key.rb

@@ -0,0 +1,82 @@
+require 'base62-rb'
+require 'hashie/mash'
+module SimpleFeed
+  module Providers
+    module Serialization
+      class Key
+        attr_accessor :user_id, :short_id, :prefix, :config
+
+        # This hash defines the paramters for the strategy we use
+        # to create a compact key based on the user id, feed's namespace,
+        # and the functionality, such as 'm' meta — as a hash for storing
+        # arbitrary values (in particular, +last_read+). and 'd' data —
+        # as a sorted set in for storing the actual events.
+        #
+        # ### Examples
+        #
+        # Here is a meta key for a given user ID:
+        #
+        #            user   'm' for meta
+        #              ↓        ↓
+        #          "ff|u.f23098.m"
+        #           ↑         ↑
+        #         namespace user_id(base62)
+        #
+        KEY_CONFIG = Hashie::Mash.new({
+                                        separator:         '.',
+                                        prefix:            '',
+                                        namespace_divider: '|',
+                                        namespace:         nil,
+                                        primary:           ->(user_id) { ::Base62.encode(user_id) },
+                                        primary_marker:    'u',
+                                        secondary_markers: {
+                                          data: 'd',
+                                          meta: 'm'
+                                        }
+                                      })
+
+        def initialize(user_id, namespace = nil, optional_key_config = {})
+          optional_key_config.merge!(namespace: namespace) if namespace
+          self.config = KEY_CONFIG.dup.merge!(optional_key_config)
+
+          self.user_id  = user_id
+          self.short_id = config.primary[user_id]
+
+          self.prefix = configure_prefix
+
+          config.secondary_markers.each_pair do |type, character|
+            self.class.send(:define_method, type) do
+              instance_variable_get("@#{type}") || instance_variable_set("@#{type}", "#{prefix}#{config.separator}#{character}")
+            end
+          end
+        end
+
+        def keys
+          config.secondary_markers.map { |k, v| [k, self.send(k)] }
+        end
+
+        def for(type)
+          "#{prefix}#{config.separator}#{type.to_s}"
+        end
+
+        def to_s
+          super.gsub(/SimpleFeed::Providers::Serialization/, '...*') + { user_id: user_id, short_id: short_id, keys: keys }.to_json
+        end
+
+        def inspect
+
+        end
+
+        private
+
+        # eg. ff|u.123498
+        def configure_prefix
+          namespace = config.namespace ? "#{config.namespace}#{config.namespace_divider}" : ''
+          "#{namespace}#{config.primary_marker}#{config.separator}#{short_id}"
+        end
+
+      end
+    end
+  end
+end
+

data/lib/simplefeed/response.rb

@@ -0,0 +1,77 @@
+require 'hashie'
+require 'forwardable'
+require 'simplefeed'
+
+module SimpleFeed
+  class Response
+    extend Forwardable
+
+    def_delegators :@result, :delete, :key?, :value?, :values, :keys, :size, :merge!
+
+    include Enumerable
+
+    def each
+      if block_given?
+        @result.each_pair do |user_id, result|
+          yield(user_id, result)
+        end
+      else
+        @result.keys.to_enum
+      end
+    end
+
+    def initialize(data = {})
+      @result = data.dup
+    end
+
+    def for(key_or_user_id, result = nil)
+      user_id = key_or_user_id.is_a?(SimpleFeed::Providers::Serialization::Key) ?
+        key_or_user_id.user_id :
+        key_or_user_id
+
+      @result[user_id] = result ? result : yield(@result[user_id])
+    end
+
+    def user_ids
+      @result.keys
+    end
+
+    def has_user?(user_id)
+      @result.key?(user_id)
+    end
+
+    def user_count
+      @result.size
+    end
+
+    def to_h
+      @result.to_h
+    end
+
+    # Passes results assigned to each user to a transformation
+    # function that in turn must return a transformed value for
+    # an individual response, and be implemented in the subclasses
+    def transform
+      if block_given?
+        @result.each_pair do |user_id, value|
+          @result[user_id] = yield(user_id, value)
+        end
+      end
+      self
+    end
+
+    def result(user_id = nil)
+      if user_id then
+        @result[user_id]
+      else
+        if @result.values.size == 1
+          @result.values.first
+        else
+          @result.to_hash
+        end
+      end
+    end
+
+    alias_method :[], :result
+  end
+end