simple-feed 1.0.2

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

@@ -0,0 +1,169 @@
+require 'base62-rb'
+require 'hashie'
+require 'set'
+require 'knjrbfw'
+
+require 'simplefeed/event'
+require_relative 'paginator'
+require_relative '../serialization/key'
+require_relative '../base/provider'
+
+module SimpleFeed
+  module Providers
+    module Hash
+      class Provider < ::SimpleFeed::Providers::Base::Provider
+        attr_accessor :h
+
+        include SimpleFeed::Providers::Hash::Paginator
+
+        def self.from_yaml(file)
+          self.new(YAML.load(File.read(file)))
+        end
+
+        def initialize(**opts)
+          self.h = {}
+          h.merge!(opts)
+        end
+
+        def store(user_ids:, value:, at: Time.now)
+          event = create_event(value, at)
+          with_response_batched(user_ids) do |key|
+            add_event(event, key)
+          end
+        end
+
+        def delete(user_ids:, value:, at: nil)
+          event = create_event(value, at)
+          with_response_batched(user_ids) do |key|
+            changed_activity_size?(key) do
+              __delete(key, event)
+            end
+          end
+        end
+
+        def delete_if(user_ids:, &block)
+          with_response_batched(user_ids) do |key|
+            activity(key).each do |event|
+              __delete(key, event) if yield(key.user_id, event)
+            end
+          end
+        end
+
+        def wipe(user_ids:)
+          with_response_batched(user_ids) do |key|
+            deleted = activity(key).size > 0
+            wipe_user_record(key)
+            deleted
+          end
+        end
+
+        def fetch(user_ids:)
+          with_response_batched(user_ids) do |key|
+            activity(key)
+          end
+        end
+
+        def paginate(user_ids:, page:, per_page: feed.per_page, **options)
+          reset_last_read(user_ids: user_ids) unless options[:peek]
+          with_response_batched(user_ids) do |key|
+            activity = activity(key)
+            (page && page > 0) ? activity[((page - 1) * per_page)...(page * per_page)] : activity
+          end
+        end
+
+        def reset_last_read(user_ids:, at: Time.now)
+          with_response_batched(user_ids) do |key|
+            user_record(key)[:last_read] = at
+            at
+          end
+        end
+
+        def total_count(user_ids:)
+          with_response_batched(user_ids) do |key|
+            activity(key).size
+          end
+        end
+
+        def unread_count(user_ids:)
+          with_response_batched(user_ids) do |key|
+            activity(key).count { |event| event.at > user_record(key).last_read.to_f }
+          end
+        end
+
+        def last_read(user_ids:)
+          with_response_batched(user_ids) do |key|
+            user_record(key).last_read
+          end
+        end
+
+        def total_memory_bytes
+          analyzer = Knj::Memory_analyzer::Object_size_counter.new(self.h)
+          analyzer.calculate_size
+        end
+
+        def total_users
+          self.h.size
+        end
+
+        private
+
+        #===================================================================
+        # Methods below operate on a single user only
+        #
+
+
+        def changed_activity_size?(key)
+          ua          = activity(key)
+          size_before = ua.size
+          yield(key, ua)
+          size_after = activity(key).size
+          (size_before > size_after)
+        end
+
+        def create_user_record
+          Hashie::Mash.new(
+            { last_read: 0, activity: SortedSet.new }
+          )
+        end
+
+        def user_record(key)
+          h[key.data] ||= create_user_record
+        end
+
+        def wipe_user_record(key)
+          h[key.data] = create_user_record
+        end
+
+        def activity(key, event = nil)
+          user_record(key)[:activity] << event if event
+          user_record(key)[:activity].to_a
+        end
+
+        def add_event(event, key)
+          uas = user_record(key)[:activity]
+          if uas.include?(event)
+            false
+          else
+            uas << event.dup
+            if uas.size > feed.max_size
+              uas.delete(uas.to_a.last)
+            end
+            true
+          end
+        end
+
+        def __last_read(key, value = nil)
+          user_record(key)[:last_read]
+        end
+
+        def __delete(key, event)
+          user_record(key)[:activity].delete(event)
+        end
+
+        def create_event(*args, **opts)
+          ::SimpleFeed::Event.new(*args, **opts)
+        end
+      end
+    end
+  end
+end

data/lib/simplefeed/providers/proxy.rb

@@ -0,0 +1,38 @@
+module SimpleFeed
+  module Providers
+    class Proxy
+      attr_accessor :provider
+
+      def self.from(definition)
+        if definition.is_a?(::Hash)
+          ::SimpleFeed.symbolize!(definition)
+          self.new(definition[:klass], *definition[:args], **definition[:opts])
+        else
+          self.new(definition)
+        end
+
+      end
+
+      def initialize(provider_or_klass, *args, **options)
+        if provider_or_klass.is_a?(::String)
+          self.provider = ::Object.const_get(provider_or_klass).new(*args, **options)
+        else
+          self.provider = provider_or_klass
+        end
+
+        SimpleFeed::Providers::REQUIRED_METHODS.each do |m|
+          raise ArgumentError, "Invalid provider #{provider.class}\nMethod '#{m}' is required." unless provider.respond_to?(m)
+        end
+      end
+
+      # Forward all other method calls to Provider
+      def method_missing(name, *args, &block)
+        if self.provider && provider.respond_to?(name)
+          self.provider.send(name, *args, &block)
+        else
+          super(name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/simplefeed/providers/redis.rb

@@ -0,0 +1,9 @@
+module SimpleFeed
+  module Providers
+    module Redis
+    end
+  end
+end
+
+require_relative 'redis/driver'
+require_relative 'redis/provider'

data/lib/simplefeed/providers/redis/boot_info.yml

@@ -0,0 +1,99 @@
+---
+redis_version: 3.2.5
+redis_git_sha1: '00000000'
+redis_git_dirty: '0'
+redis_build_id: 9fe990583d8f1fbf
+redis_mode: standalone
+os: Darwin 16.1.0 x86_64
+arch_bits: '64'
+multiplexing_api: kqueue
+gcc_version: 4.2.1
+process_id: '12404'
+run_id: de08831d36013df78346b72b3ffc3f1f45147780
+tcp_port: '6379'
+uptime_in_seconds: '26'
+uptime_in_days: '0'
+hz: '10'
+lru_clock: '4352014'
+executable: "/usr/local/opt/redis/bin/redis-server"
+config_file: "/usr/local/etc/redis.conf"
+connected_clients: '1'
+client_longest_output_list: '0'
+client_biggest_input_buf: '0'
+blocked_clients: '0'
+used_memory: '1008384'
+used_memory_human: 984.75K
+used_memory_rss: '2027520'
+used_memory_rss_human: 1.93M
+used_memory_peak: '1008384'
+used_memory_peak_human: 984.75K
+total_system_memory: '17179869184'
+total_system_memory_human: 16.00G
+used_memory_lua: '37888'
+used_memory_lua_human: 37.00K
+maxmemory: '0'
+maxmemory_human: 0B
+maxmemory_policy: noeviction
+mem_fragmentation_ratio: '2.01'
+mem_allocator: libc
+loading: '0'
+rdb_changes_since_last_save: '0'
+rdb_bgsave_in_progress: '0'
+rdb_last_save_time: '1480746996'
+rdb_last_bgsave_status: ok
+rdb_last_bgsave_time_sec: "-1"
+rdb_current_bgsave_time_sec: "-1"
+aof_enabled: '0'
+aof_rewrite_in_progress: '0'
+aof_rewrite_scheduled: '0'
+aof_last_rewrite_time_sec: "-1"
+aof_current_rewrite_time_sec: "-1"
+aof_last_bgrewrite_status: ok
+aof_last_write_status: ok
+total_connections_received: '1'
+total_commands_processed: '1'
+instantaneous_ops_per_sec: '0'
+total_net_input_bytes: '43'
+total_net_output_bytes: '2168'
+instantaneous_input_kbps: '0.00'
+instantaneous_output_kbps: '0.00'
+rejected_connections: '0'
+sync_full: '0'
+sync_partial_ok: '0'
+sync_partial_err: '0'
+expired_keys: '0'
+evicted_keys: '0'
+keyspace_hits: '0'
+keyspace_misses: '0'
+pubsub_channels: '0'
+pubsub_patterns: '0'
+latest_fork_usec: '0'
+migrate_cached_sockets: '0'
+role: master
+connected_slaves: '0'
+master_repl_offset: '0'
+repl_backlog_active: '0'
+repl_backlog_size: '1048576'
+repl_backlog_first_byte_offset: '0'
+repl_backlog_histlen: '0'
+used_cpu_sys: '0.02'
+used_cpu_user: '0.01'
+used_cpu_sys_children: '0.00'
+used_cpu_user_children: '0.00'
+cluster_enabled: '0'
+db0: keys=0,expires=0,avg_ttl=0
+db1: keys=0,expires=0,avg_ttl=0
+db2: keys=0,expires=0,avg_ttl=0
+db3: keys=0,expires=0,avg_ttl=0
+db4: keys=0,expires=0,avg_ttl=0
+db5: keys=0,expires=0,avg_ttl=0
+db6: keys=0,expires=0,avg_ttl=0
+db7: keys=0,expires=0,avg_ttl=0
+db8: keys=0,expires=0,avg_ttl=0
+db9: keys=0,expires=0,avg_ttl=0
+db10: keys=0,expires=0,avg_ttl=0
+db11: keys=0,expires=0,avg_ttl=0
+db12: keys=0,expires=0,avg_ttl=0
+db13: keys=0,expires=0,avg_ttl=0
+db14: keys=0,expires=0,avg_ttl=0
+db15: keys=0,expires=0,avg_ttl=0

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

@@ -0,0 +1,158 @@
+require 'redis'
+require 'redis/connection/hiredis'
+require 'connection_pool'
+require 'colored2'
+require 'hashie/mash'
+require 'yaml'
+require 'pp'
+
+module SimpleFeed
+  module Providers
+    module Redis
+      @debug = ENV['REDIS_DEBUG']
+
+      def self.debug?
+        self.debug
+      end
+
+      class << self
+        attr_accessor :debug
+      end
+
+      module Driver
+        class Error < StandardError;
+        end
+
+        class LoggingRedis < Struct.new(:redis)
+          def method_missing(m, *args, &block)
+            if redis.respond_to?(m)
+              result = redis.send(m, *args, &block)
+              STDERR.printf "%40s %s\n", "#{m.to_s.upcase.bold.red}", "#{args.inspect.gsub(/[\[\]]/, '').magenta}"
+              result
+            else
+              super
+            end
+          end
+        end
+
+        def debug?
+          SimpleFeed::Providers::Redis.debug?
+        end
+
+        attr_accessor :pool
+
+=begin
+
+Various ways of defining a new Redis driver:
+
+SimpleFeed::Redis::Driver.new(pool: ConnectionPool.new(size: 2) { Redis.new })
+SimpleFeed::Redis::Driver.new(redis: -> { Redis.new }, pool_size: 2)
+SimpleFeed::Redis::Driver.new(redis: Redis.new)
+SimpleFeed::Redis::Driver.new(redis: { host: 'localhost', port: 6379, db: 1, timeout: 0.2 }, pool_size: 1)
+
+=end
+        def initialize(**opts)
+          if opts[:pool] && opts[:pool].respond_to?(:with)
+            self.pool = opts[:pool]
+
+          elsif opts[:redis]
+            redis      = opts[:redis]
+            redis_proc = nil
+
+            if redis.is_a?(::Hash)
+              redis_proc = -> { ::Redis.new(**opts[:redis]) }
+            elsif redis.is_a?(::Proc)
+              redis_proc = redis
+            elsif redis.is_a?(::Redis)
+              redis_proc = -> { redis }
+            end
+
+            if redis_proc
+              self.pool = ::ConnectionPool.new(size: (opts[:pool_size] || 2)) do
+                redis_proc.call
+              end
+            end
+          end
+
+          raise ArgumentError, "Unable to construct Redis connection from arguments: #{opts.inspect}" unless self.pool && self.pool.respond_to?(:with)
+        end
+
+        %i(set get incr decr setex expire del setnx exists zadd zrange).each do |method|
+          define_method(method) do |*args|
+            self.exec method, *args
+          end
+        end
+
+        alias_method :delete, :del
+        alias_method :rm, :del
+        alias_method :exists?, :exists
+
+        def exec(redis_method, *args, **opts, &block)
+          send_proc = redis_method if redis_method.respond_to?(:call)
+          send_proc ||= ->(redis) { redis.send(redis_method, *args, &block) }
+
+          if opts[:pipelined]
+            opts.delete :pipelined
+            with_pipelined { |redis| send_proc.call(redis) }
+          else
+            with_redis { |redis| send_proc.call(redis) }
+          end
+        end
+
+        class MockRedis
+          def method_missing(name, *args, &block)
+            puts "calling redis.#{name}(#{args.to_s.gsub(/[\[\]]/, '')}) { #{block ? block.call : nil} }"
+          end
+        end
+
+        def with_redis
+          with_retries do
+            pool.with do |redis|
+              yield(self.debug? ? LoggingRedis.new(redis) : redis)
+            end
+          end
+        end
+
+        def with_pipelined
+          with_retries do
+            with_redis do |redis|
+              redis.pipelined do
+                yield(redis)
+              end
+            end
+          end
+        end
+
+        def with_multi
+          with_retries do
+            with_redis do |redis|
+              redis.multi do
+                yield(redis)
+              end
+            end
+          end
+        end
+
+        def with_retries(tries = 3)
+          yield(tries)
+        rescue Errno::EINVAL => e
+          on_error e
+        rescue ::Redis::BaseConnectionError => e
+          if (tries -= 1) > 0
+            sleep rand(0..0.01)
+            retry
+          else
+            on_error e
+          end
+        rescue ::Redis::CommandError => e
+          (e.message =~ /loading/i || e.message =~ /connection/i) ? on_error(e) : raise(e)
+        end
+
+        def on_error(e)
+          raise Error.new(e)
+        end
+
+      end
+    end
+  end
+end