redisrank 0.1.0

data/lib/redisrank/buffer.rb

@@ -0,0 +1,110 @@
+require 'redisrank/core_ext/hash'
+
+module Redisrank
+  class Buffer
+    include Synchronize
+
+    def self.instance
+      @instance ||= self.new
+    end
+
+    def size
+      synchronize do
+        @size ||= 0
+      end
+    end
+
+    def size=(value)
+      synchronize do
+        @size = value
+      end
+    end
+
+    def count
+      @count ||= 0
+    end
+
+    def store(key, stats, depth_limit, opts)
+      return false unless should_buffer?
+
+      to_flush = {}
+      buffkey = buffer_key(key, opts)
+
+      synchronize do
+        if !queue.has_key?(buffkey)
+          queue[buffkey] = { :key         => key,
+                             :stats       => {},
+                             :depth_limit => depth_limit,
+                             :opts        => opts }
+        end
+
+        queue[buffkey][:stats].merge_to_max!(stats)
+        incr_count
+
+        # return items to be flushed if buffer size limit has been reached
+        to_flush = reset_queue
+      end
+
+      # flush any data that's been cleared from the queue
+      flush_data(to_flush)
+      true
+    end
+
+    def flush(force = false)
+      to_flush = {}
+      synchronize do
+        to_flush = reset_queue(force)
+      end
+      flush_data(to_flush)
+    end
+
+    private
+
+    # should always be called from within a synchronize block
+    def incr_count
+      @count ||= 0
+      @count += 1
+    end
+
+    def queue
+      @queue ||= {}
+    end
+
+    def should_buffer?
+      size > 1 # buffer size of 1 would be equal to not using buffer
+    end
+
+    # should always be called from within a synchronize block
+    def should_flush?
+      (!queue.blank? && count >= size)
+    end
+
+    # returns items to be flushed if buffer size limit has been reached
+    # should always be called from within a synchronize block
+    def reset_queue(force = false)
+      return {} if !force && !should_flush?
+      data = queue
+      @queue = {}
+      @count = 0
+      data
+    end
+
+    def flush_data(buffer_data)
+      buffer_data.each do |k, item|
+        Summary.update(item[:key], item[:stats], item[:depth_limit], item[:opts])
+      end
+    end
+
+    # depth_limit is not needed as it's evident in key.to_s
+    def buffer_key(key, opts)
+      # covert keys to strings, as sorting a Hash with Symbol keys fails on
+      # Ruby 1.8.x.
+      opts = opts.inject({}) do |result, (k, v)|
+        result[k.to_s] = v
+        result
+      end
+      "#{key.to_s}:#{opts.sort.flatten.join(':')}"
+    end
+
+  end
+end

data/lib/redisrank/collection.rb

@@ -0,0 +1,20 @@
+module Redisrank
+  class Collection < ::Array
+
+    attr_accessor :from
+    attr_accessor :till
+    attr_accessor :depth
+    attr_accessor :rank
+
+    def initialize(options = {})
+      @from = options[:from] ||= nil
+      @till = options[:till] ||= nil
+      @depth = options[:depth] ||= nil
+    end
+
+    def rank
+      @rank ||= {}
+    end
+
+  end
+end

data/lib/redisrank/connection.rb

@@ -0,0 +1,89 @@
+require 'monitor'
+
+module Redisrank
+  module Connection
+
+    REQUIRED_SERVER_VERSION = "1.3.10"
+    MIN_EXPIRE_SERVER_VERSION = "2.1.3"
+
+    # TODO: Create a ConnectionPool instance object using Sychronize mixin to replace Connection class
+
+    class << self
+
+      # TODO: clean/remove all ref-less connections
+
+      def get(ref = nil)
+        ref ||= :default
+        synchronize do
+          connections[references[ref]] || create
+        end
+      end
+
+      def add(conn, ref = nil)
+        ref ||= :default
+        synchronize do
+          check_redis_version(conn)
+          references[ref] = conn.client.id
+          connections[conn.client.id] = conn
+        end
+      end
+
+      def create(options = {})
+        synchronize do
+          options = options.clone
+          ref = options.delete(:ref) || :default
+          options.reverse_merge!(default_options)
+          conn = (connections[connection_id(options)] ||= connection(options))
+          references[ref] = conn.client.id
+          conn
+        end
+      end
+
+      def connections
+        @connections ||= {}
+      end
+
+      def references
+        @references ||= {}
+      end
+
+      private
+
+      def monitor
+        @monitor ||= Monitor.new
+      end
+
+      def synchronize(&block)
+        monitor.synchronize(&block)
+      end
+
+      def connection(options)
+        check_redis_version(Redis.new(options))
+      end
+
+      def connection_id(options = {})
+        options = options.reverse_merge(default_options)
+        "redis://#{options[:host]}:#{options[:port]}/#{options[:db]}"
+      end
+
+      def check_redis_version(conn)
+        raise RedisServerIsTooOld if conn.info["redis_version"] < REQUIRED_SERVER_VERSION
+        if conn.info["redis_version"] < MIN_EXPIRE_SERVER_VERSION
+          STDOUT.puts "WARNING: You MUST upgrade Redis to v2.1.3 or later " +
+            "if you are using key expiry."
+        end
+        conn
+      end
+
+      def default_options
+        {
+          :host => '127.0.0.1',
+          :port => 6379,
+          :db => 0,
+          :timeout => 5
+        }
+      end
+
+    end
+  end
+end

data/lib/redisrank/core_ext.rb

@@ -0,0 +1,5 @@
+require 'redisrank/core_ext/bignum'
+require 'redisrank/core_ext/date'
+require 'redisrank/core_ext/fixnum'
+require 'redisrank/core_ext/hash'
+require 'redisrank/core_ext/time'

data/lib/redisrank/core_ext/bignum.rb

@@ -0,0 +1,8 @@
+class Bignum
+  include Redisrank::DateHelper
+
+  def to_time
+    Time.at(self)
+  end
+
+end

data/lib/redisrank/core_ext/date.rb

@@ -0,0 +1,8 @@
+class Date
+  include Redisrank::DateHelper
+
+  def to_time
+    Time.parse(self.to_s)
+  end
+
+end

data/lib/redisrank/core_ext/fixnum.rb

@@ -0,0 +1,8 @@
+class Fixnum
+  include Redisrank::DateHelper
+
+  def to_time
+    Time.at(self)
+  end
+
+end

data/lib/redisrank/core_ext/hash.rb

@@ -0,0 +1,20 @@
+class Hash
+
+  def merge_to_max(key, value)
+    return false unless value.is_a?(Numeric)
+    self[key] = 0 unless self.has_key?(key)
+    return false unless self[key].is_a?(Numeric)
+    return false unless self[key] < value
+    self[key] = value
+    true
+  end
+
+  def merge_to_max!(hash)
+    raise ArgumentError unless hash.is_a?(Hash)
+    hash.each do |key, value|
+      self[key] = value unless (self[key] || 0) > value
+    end
+    self
+  end
+
+end

data/lib/redisrank/core_ext/time.rb

@@ -0,0 +1,3 @@
+class Time
+  include Redisrank::DateHelper
+end

data/lib/redisrank/date.rb

@@ -0,0 +1,88 @@
+module Redisrank
+  class Date
+
+    attr_accessor :year
+    attr_accessor :month
+    attr_accessor :day
+    attr_accessor :hour
+    attr_accessor :min
+    attr_accessor :sec
+    attr_accessor :usec
+    attr_accessor :depth
+
+    DEPTHS = [:year, :month, :day, :hour, :min, :sec, :usec]
+
+    def initialize(input, depth = nil)
+      @depth = depth
+      if input.is_a?(::Time)
+        from_time(input)
+      elsif input.is_a?(::Date)
+        from_date(input)
+      elsif input.is_a?(::String)
+        from_string(input)
+      elsif input.is_a?(::Fixnum)
+        from_integer(input)
+      elsif input.is_a?(::Bignum)
+        from_integer(input)
+      end
+    end
+
+    def to_t
+      ::Time.local(@year, @month, @day, @hour, @min, @sec, @usec)
+    end
+    alias :to_time :to_t
+
+    def to_d
+      ::Date.civil(@year, @month, @day)
+    end
+    alias :to_date :to_d
+
+    def to_i
+      to_time.to_i
+    end
+    alias :to_integer :to_i
+
+    def to_s(depth = nil)
+      depth ||= @depth ||= :sec
+      output = ""
+      DEPTHS.each_with_index do |current, i|
+        break if self.send(current).nil?
+        if current != :usec
+          output << self.send(current).to_s.rjust((i <= 0) ? 4 : 2, '0')
+        else
+          output << "." + self.send(current).to_s.rjust(6, '0')
+        end
+        break if current == depth
+      end
+      output
+    end
+    alias :to_string :to_s
+
+    private
+
+    def from_time(input)
+      DEPTHS.each do |k|
+        send("#{k}=", input.send(k))
+      end
+    end
+
+    def from_date(input)
+      [:year, :month, :day].each do |k|
+        send("#{k}=", input.send(k))
+      end
+      [:hour, :min, :sec, :usec].each do |k|
+        send("#{k}=", 0)
+      end
+    end
+
+    def from_integer(input)
+      from_time(::Time.at(input))
+    end
+
+    def from_string(input)
+      input += "19700101000000"[input.size..-1] if input =~ /^\d\d\d[\d]+$/i
+      from_time(::Time.parse(input))
+    end
+
+  end
+end

data/lib/redisrank/event.rb

@@ -0,0 +1,98 @@
+module Redisrank
+  class Event
+    include Database
+    include Options
+
+    attr_reader :id
+    attr_reader :key
+
+    attr_accessor :stats
+    attr_accessor :meta
+
+    def default_options
+      { :depth => :hour,
+        :store_event => false,
+        :connection_ref => nil,
+        :enable_grouping => true,
+        :label_indexing => true }
+    end
+
+    def initialize(scope, label = nil, date = nil, stats = {}, opts = {}, meta = {}, is_new = true)
+      parse_options(opts)
+      @key = Key.new(scope, label, date, @options)
+      @stats = stats ||= {}
+      @meta = meta ||= {}
+      @new = is_new
+    end
+
+    def new?
+      @new
+    end
+
+    def date
+      @key.date
+    end
+
+    def date=(input)
+      @key.date = input
+    end
+
+    def scope
+      @key.scope
+    end
+
+    def scope=(input)
+      @key.scope = input
+    end
+
+    def label
+      @key.label
+    end
+
+    def label_hash
+      @key.label_hash
+    end
+
+    def label=(input)
+      @key.label = input
+    end
+
+    def next_id
+      db.incr("#{self.scope}#{KEY_NEXT_ID}")
+    end
+
+    def save
+      return false if !self.new?
+      Summary.update_all(@key, @stats, depth_limit, @options)
+      if @options[:store_event]
+        @id = self.next_id
+        db.hmset("#{self.scope}#{KEY_EVENT}#{@id}",
+                 "scope", self.scope,
+                 "label", self.label,
+                 "date", self.date.to_time.to_s,
+                 "stats", self.stats.to_json,
+                 "meta", self.meta.to_json,
+                 "options", self.options.to_json)
+        db.sadd("#{self.scope}#{KEY_EVENT_IDS}", @id)
+      end
+      @new = false
+      self
+    end
+
+    def depth_limit
+      @options[:depth] ||= @key.depth
+    end
+
+    def self.create(*args)
+      self.new(*args).save
+    end
+
+    def self.find(scope, id)
+      event = db.hgetall "#{scope}#{KEY_EVENT}#{id}"
+      return nil if event.size == 0
+      self.new( event["scope"], event["label"], event["date"], JSON.parse(event["stats"]),
+                JSON.parse(event["options"]), JSON.parse(event["meta"]), false )
+    end
+
+  end
+end