zermelo 1.0.0

data/lib/zermelo/records/instance_methods.rb

@@ -0,0 +1,224 @@
+require 'zermelo/records/key'
+
+module Zermelo
+
+  module Records
+
+    # module renamed to avoid ActiveSupport::Concern deprecation warning
+    module InstMethods
+
+      def initialize(attributes = {})
+        @is_new = true
+        @attributes = {}
+        attributes.each_pair do |k, v|
+          self.send("#{k}=".to_sym, v)
+        end
+      end
+
+      def persisted?
+        !@is_new
+      end
+
+      def load(id)
+        self.id = id
+        refresh
+      end
+
+      def refresh
+        # AM::Dirty -- private method 'clear_changes_information' in 4.2.0+,
+        # private method 'reset_changes' in 4.1.0+, internal state before that
+        if self.respond_to?(:clear_changes_information, true)
+          clear_changes_information
+        elsif self.respond_to?(:reset_changes, true)
+          reset_changes
+        else
+          @previously_changed.clear unless @previously_changed.nil?
+          @changed_attributes.clear
+        end
+
+        attr_types = self.class.attribute_types
+
+        @attributes = {'id' => self.id}
+
+        attrs = nil
+
+        self.class.lock do
+          class_key = self.class.send(:class_key)
+
+          # TODO: check for record existence in backend-agnostic fashion
+          @is_new = false
+
+          attr_types = self.class.attribute_types.reject {|k, v| k == :id}
+
+          attrs_to_load = attr_types.collect do |name, type|
+            Zermelo::Records::Key.new(:klass => class_key,
+              :id => self.id, :name => name, :type => type, :object => :attribute)
+          end
+
+          attrs = backend.get_multiple(*attrs_to_load)[class_key][self.id]
+        end
+
+        return false unless attrs.present?
+        @attributes.update(attrs)
+        true
+      end
+
+      # TODO limit to only those attribute names defined in define_attributes
+      def update_attributes(attributes = {})
+        attributes.each_pair do |att, v|
+          unless value == @attributes[att.to_s]
+            @attributes[att.to_s] = v
+            send("#{att}_will_change!")
+          end
+        end
+        save
+      end
+
+      def save
+        return unless @is_new || self.changed?
+        self.id ||= self.class.generate_id
+        return false unless valid?
+
+        creating = !self.persisted?
+
+        run_callbacks( (creating ? :create : :update) ) do
+
+          idx_attrs = self.class.send(:with_index_data) do |d|
+            idx_attrs = d.each_with_object({}) do |(name, data), memo|
+              memo[name.to_s] = data.index_klass
+            end
+          end
+
+          self.class.transaction do
+
+            apply_attribute = proc {|att, attr_key, old_new|
+              backend.set(attr_key, old_new.last) unless att.eql?('id')
+
+              if idx_attrs.has_key?(att)
+                # update indices
+                if creating
+                  self.class.send("#{att}_index").add_id( @attributes['id'], old_new.last)
+                else
+                  self.class.send("#{att}_index").move_id( @attributes['id'], old_new.first,
+                                  self.class.send("#{att}_index"), old_new.last)
+                end
+              end
+            }
+
+            attr_keys = attribute_keys
+
+            if creating
+              attribute_keys.each_pair do |att, attr_key|
+                apply_attribute.call(att, attr_key, [nil, @attributes[att]])
+              end
+            else
+              self.changes.each_pair do |att, old_new|
+                apply_attribute.call(att, attr_keys[att], old_new)
+              end
+            end
+
+            # ids is a set, so update won't create duplicates
+            # NB influxdb backend doesn't need this
+            self.class.add_id(@attributes['id'])
+          end
+
+          @is_new = false
+        end
+
+        # AM::Dirty -- private method in 4.1.0+, internal state before that
+        if self.respond_to?(:changes_applied, true)
+          changes_applied
+        else
+          @previously_changed = changes
+          @changed_attributes.clear
+        end
+
+        true
+      end
+
+      def destroy
+        raise "Record was not persisted" if !persisted?
+
+        run_callbacks :destroy do
+
+          assoc_classes = self.class.send(:associated_classes)
+          index_attrs   = self.class.send(:with_index_data) {|d| d.keys }
+
+          self.class.lock(*assoc_classes) do
+            self.class.send(:with_associations, self) do |assoc|
+              assoc.send(:on_remove)
+            end
+
+            self.class.transaction do
+              self.class.delete_id(@attributes['id'])
+              index_attrs.each do |att|
+                idx = self.class.send("#{att}_index")
+                idx.delete_id( @attributes['id'], @attributes[att.to_s])
+              end
+
+              self.class.attribute_types.each_pair {|name, type|
+                key = Zermelo::Records::Key.new(:klass => self.class.send(:class_key),
+                  :id => self.id, :name => name.to_s, :type => type, :object => :attribute)
+                backend.clear(key)
+              }
+
+              record_key = Zermelo::Records::Key.new(:klass => self.class.send(:class_key),
+                  :id => self.id)
+              backend.purge(record_key)
+            end
+          end
+        end
+      end
+
+      private
+
+      def backend
+        self.class.send(:backend)
+      end
+
+      def attribute_keys
+        @attribute_keys ||= self.class.attribute_types.reject {|k, v|
+          k == :id
+        }.inject({}) {|memo, (name, type)|
+          memo[name.to_s] = Zermelo::Records::Key.new(:klass => self.class.send(:class_key),
+            :id => self.id, :name => name.to_s, :type => type, :object => :attribute)
+          memo
+        }
+      end
+
+      # http://stackoverflow.com/questions/7613574/activemodel-fields-not-mapped-to-accessors
+      #
+      # Simulate attribute writers from method_missing
+      def attribute=(att, value)
+        return if value == @attributes[att.to_s]
+        if att.to_s == 'id'
+          raise "Cannot reassign id" unless @attributes['id'].nil?
+          send("id_will_change!")
+          @attributes['id'] = value.to_s
+        else
+          send("#{att}_will_change!")
+          if (self.class.attribute_types[att.to_sym] == :set) && !value.is_a?(Set)
+            @attributes[att.to_s] = Set.new(value)
+          else
+            @attributes[att.to_s] = value
+          end
+        end
+      end
+
+      # Simulate attribute readers from method_missing
+      def attribute(att)
+        value = @attributes[att.to_s]
+        return value unless (self.class.attribute_types[att.to_sym] == :timestamp)
+        value.is_a?(Integer) ? Time.at(value) : value
+      end
+
+      # Used by ActiveModel to lookup attributes during validations.
+      def read_attribute_for_validation(att)
+        @attributes[att.to_s]
+      end
+
+    end
+
+  end
+
+end

data/lib/zermelo/records/key.rb

@@ -0,0 +1,19 @@
+module Zermelo
+  module Records
+    class Key
+
+      # id       / if nil, it's a class variable
+      # object   / :association, :attribute or :index
+      # accessor / if a complex type, some way of getting sub-value
+      attr_reader :klass, :id, :name, :accessor, :type, :object
+
+      # TODO better validation of data, e.g. accessor valid for type, etc.
+      def initialize(opts = {})
+        [:klass, :id, :name, :accessor, :type, :object].each do |iv|
+          instance_variable_set("@#{iv}", opts[iv])
+        end
+      end
+
+    end
+  end
+end

data/lib/zermelo/records/redis_record.rb

@@ -0,0 +1,27 @@
+require 'active_support/concern'
+
+require 'zermelo/records/base'
+
+# TODO check escaping of ids and index_keys -- shouldn't allow bare :, ' '
+
+# TODO callbacks on before/after add/delete on association?
+
+module Zermelo
+
+  module Records
+
+    module RedisRecord
+
+      extend ActiveSupport::Concern
+
+      include Zermelo::Records::Base
+
+      included do
+        set_backend :redis
+      end
+
+    end
+
+  end
+
+end

data/lib/zermelo/records/type_validator.rb

@@ -0,0 +1,20 @@
+module Zermelo
+  module Records
+    class TypeValidator < ActiveModel::Validator
+      def validate(record)
+        attr_types = record.class.attribute_types
+
+        attr_types.each_pair do |name, type|
+          value = record.send(name)
+          next if value.nil?
+          valid_type = Zermelo::ALL_TYPES[type]
+          unless valid_type.any? {|type| value.is_a?(type) }
+            count = (valid_type.size > 1) ? 'one of ' : ''
+            type_str = valid_type.collect {|type| type.name }.join(", ")
+            record.errors.add(name, "should be #{count}#{type_str} but is #{value.class.name}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zermelo/version.rb

@@ -0,0 +1,3 @@
+module Zermelo
+  VERSION = '1.0.0'
+end

data/lib/zermelo.rb

@@ -0,0 +1,102 @@
+require 'zermelo/version'
+
+require 'time'
+
+module Zermelo
+
+  # backport for Ruby 1.8
+  unless Enumerable.instance_methods.include?(:each_with_object)
+    module ::Enumerable
+      def each_with_object(memo)
+        return to_enum :each_with_object, memo unless block_given?
+          each do |element|
+            yield element, memo
+          end
+        memo
+      end
+    end
+  end
+
+  # acceptable class types, which will be normalized on a per-backend basis
+  ATTRIBUTE_TYPES  = {:string     => [String],
+                      :integer    => [Integer],
+                      :float      => [Float],
+                      :id         => [String],
+                      :timestamp  => [Integer, Time, DateTime],
+                      :boolean    => [TrueClass, FalseClass],
+                     }
+
+  COLLECTION_TYPES = {:list       => [Enumerable],
+                      :set        => [Set],
+                      :hash       => [Hash],
+                      :sorted_set => [Enumerable]
+                     }
+
+  ALL_TYPES = ATTRIBUTE_TYPES.merge(COLLECTION_TYPES)
+
+  class << self
+
+    def valid_type?(type)
+      ALL_TYPES.keys.include?(type)
+    end
+
+    # Thread and fiber-local
+    [:redis, :influxdb].each do |backend|
+      define_method(backend) do
+        Thread.current["zermelo_#{backend.to_s}".to_sym]
+      end
+    end
+
+    def redis=(connection)
+      Thread.current[:zermelo_redis] = connection.nil? ? nil :
+        Zermelo::ConnectionProxy.new(connection)
+      Thread.current[:zermelo_redis_version] = nil
+    end
+
+    def influxdb=(connection)
+      Thread.current[:zermelo_influxdb] = Zermelo::ConnectionProxy.new(connection)
+    end
+
+    def redis_version
+      return nil if Zermelo.redis.nil?
+      rv = Thread.current[:zermelo_redis_version]
+      return rv unless rv.nil?
+      Thread.current[:zermelo_redis_version] = Zermelo.redis.info['redis_version']
+    end
+
+    def logger=(l)
+      Thread.current[:zermelo_logger] = l
+    end
+
+    def logger
+      Thread.current[:zermelo_logger]
+    end
+  end
+
+  class ConnectionProxy
+    def initialize(connection)
+      @proxied_connection = connection
+    end
+
+    # need to override Kernel.exec
+    def exec
+      @proxied_connection.exec
+    end
+
+    def respond_to?(name, include_private = false)
+      @proxied_connection.respond_to?(name, include_private)
+    end
+
+    def method_missing(name, *args, &block)
+      unless Zermelo.logger.nil?
+        Zermelo.logger.debug {
+          debug_str = "#{name}"
+          debug_str += " #{args.inspect}" unless args.empty?
+          debug_str
+        }
+      end
+      @proxied_connection.send(name, *args, &block)
+    end
+  end
+
+end

data/spec/lib/zermelo/associations/belongs_to_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'zermelo/associations/belongs_to'
+
+describe Zermelo::Associations::BelongsTo, :redis => true do
+
+end

data/spec/lib/zermelo/associations/has_many_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'zermelo/associations/has_many'
+
+describe Zermelo::Associations::HasMany, :redis => true do
+
+end

data/spec/lib/zermelo/associations/has_one_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'zermelo/associations/has_one'
+
+describe Zermelo::Associations::HasOne, :redis => true do
+
+end

data/spec/lib/zermelo/associations/has_sorted_set.spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'zermelo/associations/has_sorted_set'
+
+describe Zermelo::Associations::HasSortedSet, :redis => true do
+
+end

data/spec/lib/zermelo/associations/index_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'zermelo/associations/index'
+
+describe Zermelo::Associations::Index, :redis => true do
+
+end

data/spec/lib/zermelo/associations/unique_index_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'zermelo/associations/unique_index'
+
+describe Zermelo::Associations::UniqueIndex, :redis => true do
+
+end

data/spec/lib/zermelo/locks/redis_lock_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+require 'zermelo/locks/redis_lock'
+require 'zermelo/records/redis_record'
+
+describe Zermelo::Locks::RedisLock, :redis => true do
+
+  let(:redis) { Zermelo.redis }
+
+  module Zermelo
+    class RedisLockExample
+      include Zermelo::Records::RedisRecord
+      define_attributes :name => :string
+    end
+
+    class AnotherExample
+      include Zermelo::Records::RedisRecord
+      define_attributes :age => :integer
+    end
+  end
+
+  it "locks access to class-level data" do
+    expect(redis.keys('*')).to be_empty
+
+    slock = Zermelo::Locks::RedisLock.new
+    locked = slock.lock(Zermelo::RedisLockExample)
+    expect(locked).to be_truthy
+
+    lock_keys = ["redis_lock_example::lock:owner", "redis_lock_example::lock:expiry"]
+    expect(redis.keys('*')).to match_array(lock_keys)
+
+    example = Zermelo::RedisLockExample.new(:name => 'temporary')
+    example.save
+
+    example_keys = ["redis_lock_example::attrs:ids", "redis_lock_example:#{example.id}:attrs"]
+    expect(redis.keys('*')).to match_array(lock_keys + example_keys)
+
+    unlocked = slock.unlock
+    expect(unlocked).to be_truthy
+    expect(redis.keys('*')).to match_array(example_keys)
+  end
+
+  it "locks access to class-level data from two classes" do
+    expect(redis.keys('*')).to be_empty
+
+    slock = Zermelo::Locks::RedisLock.new
+    locked = slock.lock(Zermelo::RedisLockExample, Zermelo::AnotherExample)
+    expect(locked).to be_truthy
+
+    lock_keys = ["another_example::lock:owner", "another_example::lock:expiry",
+      "redis_lock_example::lock:owner", "redis_lock_example::lock:expiry"]
+    expect(redis.keys('*')).to match_array(lock_keys)
+
+    redis_lock_example = Zermelo::RedisLockExample.new(:name => 'temporary')
+    redis_lock_example.save
+
+    another_example = Zermelo::AnotherExample.new(:age => 36)
+    another_example.save
+
+    example_keys = ["redis_lock_example::attrs:ids", "redis_lock_example:#{redis_lock_example.id}:attrs",
+      "another_example::attrs:ids", "another_example:#{another_example.id}:attrs"]
+    expect(redis.keys('*')).to match_array(lock_keys + example_keys)
+
+    unlocked = slock.unlock
+    expect(unlocked).to be_truthy
+    expect(redis.keys('*')).to match_array(example_keys)
+  end
+
+  it "extends an existing lock", :time => true do
+    slock = Zermelo::Locks::RedisLock.new
+    slock.life = 60
+
+    time = Time.local(2012, 1, 1, 12, 0, 0)
+    Timecop.freeze(time)
+
+    locked = slock.lock(Zermelo::RedisLockExample)
+
+    expiry_time = redis.get("redis_lock_example::lock:expiry")
+    expect(expiry_time.to_i).to eq(time.to_i + 60)
+
+    Timecop.travel(time + 45)
+
+    extended = slock.extend_life(30)
+    expect(extended).to be_truthy
+
+    expiry_time = redis.get("redis_lock_example::lock:expiry")
+    expect(expiry_time.to_i).to eq(time.to_i + 75)
+
+    unlocked = slock.unlock
+    expect(unlocked).to be_truthy
+  end
+
+  it "expires a lock when its lifetime has expired"
+
+  it "stops another thread from accessing a lock on a single class while held" do
+    monitor = Monitor.new
+
+    times = {}
+
+    slock = Zermelo::Locks::RedisLock.new
+    locked = slock.lock(Zermelo::RedisLockExample)
+    expect(locked).to be_truthy
+
+    # ensure Redis connection is instantiated
+    redis
+
+    t = Thread.new do
+      Zermelo.redis = redis # thread-local
+
+      slock.lock(Zermelo::RedisLockExample)
+      expect(locked).to be_truthy
+
+      monitor.synchronize do
+        times['thread'] = Time.now
+      end
+
+      unlocked = slock.unlock
+      expect(unlocked).to be_truthy
+    end
+
+    monitor.synchronize do
+      times['main'] = Time.now
+    end
+
+    sleep 0.25
+    slock.unlock
+
+    t.join
+
+    expect(times['thread'] - times['main']).to be >= 0.25
+  end
+
+  it "stops another thread from accessing a lock on multiple classes while held" do
+    monitor = Monitor.new
+
+    times = {}
+
+    slock = Zermelo::Locks::RedisLock.new
+    locked = slock.lock(Zermelo::RedisLockExample, Zermelo::AnotherExample)
+    expect(locked).to be_truthy
+
+    # ensure Redis connection is instantiated
+    redis
+
+    t = Thread.new do
+      Zermelo.redis = redis # thread-local
+
+      slock.lock(Zermelo::RedisLockExample)
+      expect(locked).to be_truthy
+
+      monitor.synchronize do
+        times['thread'] = Time.now
+      end
+
+      unlocked = slock.unlock
+      expect(unlocked).to be_truthy
+    end
+
+    monitor.synchronize do
+      times['main'] = Time.now
+    end
+
+    sleep 0.25
+    slock.unlock
+
+    t.join
+
+    expect(times['thread'] - times['main']).to be >= 0.25
+  end
+
+end