liveresource 2.0.0

data/lib/live_resource/redis_client.rb

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'redis'
+require 'yaml'
+require_relative 'log_helper'
+require_relative 'redis_client/attributes'
+require_relative 'redis_client/methods'
+require_relative 'redis_client/registration'
+
+class Redis
+  def clone
+    # Create independent Redis
+    Redis.new(
+          :host => client.host,
+          :port => client.port,
+          :timeout => client.timeout,
+          :logger => client.logger,
+          :password => client.password,
+          :db => client.db)
+  end
+end
+
+module LiveResource
+  class RedisClient
+    include LogHelper
+    attr_writer :redis
+    attr_reader :redis_class, :redis_name
+
+    @@logger = Logger.new(STDERR)
+    @@logger.level = Logger::WARN
+
+    def initialize(resource_class, resource_name)
+      @redis_class = RedisClient.redisized_key(resource_class)
+      @redis_name = RedisClient.redisized_key(resource_name)
+
+      self.logger = self.class.logger
+    end
+
+    def method_missing(method, *params, &block)
+      if self.class.redis.respond_to? method
+        redis_command(method, params, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to?(method)
+      return true if self.class.redis.respond_to?(method)
+      super
+    end
+
+    # Override default (Ruby) exec with Redis exec.
+    def exec
+      redis_command(:exec, nil)
+    end
+
+    def self.redis
+      # Hash of Thread -> Redis instances
+      @@redis ||= {}
+      @@proto_redis ||= Redis.new
+
+      if @@redis[Thread.current].nil?
+        @@redis[Thread.current] = @@proto_redis.clone
+      end
+
+      @@redis[Thread.current]
+    end
+
+    def self.redis=(redis)
+      @@proto_redis = redis
+      @@redis = {}
+    end
+
+    def self.logger
+      @@logger
+    end
+
+    def self.logger=(logger)
+      @@logger = logger
+    end
+
+    def self.redisized_key(word)
+      word = word.to_s.dup
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.gsub!('::', '-')
+      word.downcase!
+      word
+    end
+
+    private
+
+    def redis_command(method, params, &block)
+      debug ">>", method.to_s, *params
+      response = self.class.redis.send(method, *params, &block)
+      debug "<<", response
+      response
+    end
+  end
+end

data/lib/live_resource/redis_client/attributes.rb

@@ -0,0 +1,40 @@
+module LiveResource
+  class RedisClient
+    def remote_attributes_key
+      if @redis_class == "class"
+        "#{@redis_name}.class_attributes"
+      else
+        "#{@redis_class}.attributes"
+      end
+    end
+
+    def register_attributes(attributes)
+      unless attributes.empty?
+        sadd remote_attributes_key, attributes
+      end
+    end
+
+    def registered_attributes
+      attributes = smembers remote_attributes_key
+
+      attributes.map { |a| a.to_sym }
+    end
+
+    def attribute_read(key, options={})
+      deserialize(get("#{@redis_class}.#{@redis_name}.attributes.#{key}"))
+    end
+
+    def attribute_write(key, value, options={})
+      redis_key = "#{@redis_class}.#{@redis_name}.attributes.#{key}"
+      if options[:no_overwrite]
+        setnx(redis_key, serialize(value))
+      else
+        set(redis_key, serialize(value))
+      end
+    end
+
+    def attribute_watch(key)
+      watch("#{@redis_class}.#{redis_name}.attributes.#{key}")
+    end 
+  end
+end

data/lib/live_resource/redis_client/methods.rb

@@ -0,0 +1,194 @@
+require 'yaml'
+
+module LiveResource
+  class RedisClient
+    def remote_methods_key
+      if @redis_class == "class"
+        "#{@redis_name}.class_methods"
+      else
+        "#{@redis_class}.methods"
+      end
+    end
+
+    def methods_list
+      "#{@redis_class}.#{@redis_name}.methods_pending"
+    end
+
+    def methods_in_progress_list
+      "#{@redis_class}.#{@redis_name}.methods_in_progress"
+    end
+
+    def method_details(token)
+      "#{token.redis_class}.#{token.redis_name}.method.#{token.seq}"
+    end
+
+    def result_details(token)
+      "#{token.redis_class}.#{token.redis_name}.result.#{token.seq}"
+    end
+
+    def register_methods(methods)
+      unless methods.empty?
+        sadd remote_methods_key, methods
+      end
+    end
+
+    def registered_methods
+      methods = smembers remote_methods_key
+
+      methods.map { |m| m.to_sym }
+    end
+
+    def method_wait
+      token = brpoplpush methods_list, methods_in_progress_list, 0
+      deserialize(token)
+    end
+
+    def method_push(token)
+      lpush methods_list, serialize(token)
+    end
+
+    def method_done(token)
+      lrem methods_in_progress_list, 0, serialize(token)
+    end
+
+    def method_get(token)
+      method = get method_details(token)
+
+      deserialize(method)
+    end
+
+    def method_send(method)
+      unless method.token
+        # Choose unique token for this action; retry if token is already in
+        # use by another action.
+        loop do
+          method.token = RemoteMethodToken.new(
+                                           @redis_class,
+                                           @redis_name,
+                                           sprintf("%05d", Kernel.rand(100000)))
+
+          break if setnx(method_details(method.token), serialize(method))
+        end
+      else
+        # Re-serialize current state of method to existing location.
+        set method_details(method.token), serialize(method)
+      end
+
+      method_push method.token
+      method
+    end
+
+    def method_result(method, result)
+      token = method.token
+
+      # Need to watch the method while setting the result; if the caller
+      # has given up waiting before we set the result, we don't want to
+      # leave extra crud in Redis.
+      watch method_details(token)
+
+      unless exists(method_details(token))
+        # Caller must have deleted method
+        warn "setting result for method #{token}, but caller deleted it"
+        unwatch
+        return
+      end
+
+      begin
+        multi
+        lpush result_details(token), serialize(result)
+        exec
+      rescue RuntimeError => e
+        # Must have been deleted while we were working on it, bail out.
+        warn e
+        discard
+      end
+    end
+
+    def method_wait_for_result(method, timeout)
+      token = method.token
+      result = nil
+
+      begin
+        list, result = brpop result_details(token), timeout
+
+        if result.nil?
+          raise RuntimeError.new("timed out waiting for method #{token}")
+        end
+
+        result = deserialize(result)
+      rescue
+        # Clean token from any lists before passing up exception
+        method_cleanup(token)
+        raise
+      ensure
+        # Clear out original method call details
+        del method_details(token)
+      end
+    end
+
+    def method_discard_result(token)
+      del result_details(token)
+      del method_details(token)
+    end
+
+    def method_done_with?(method)
+      st = serialize(method.token)
+
+      # Need to do a multi/exec so we can atomically look in 3 lists
+      # for the token
+      multi
+      lrange methods_list, 0, -1
+      lrange methods_in_progress_list, 0, -1
+      lrange result_details(method.token), 0, -1
+      result = exec
+
+      if (result[2] != [])
+        # Result already pending
+        true
+      elsif result[0].include?(st) or result[1].include?(st)
+        # Still in methods or methods-in-progress
+        false
+      else
+        raise ArgumentError.new("No method #{token} pending")
+      end
+    end
+
+    private
+
+    def method_cleanup(token)
+      st = serialize(token)
+
+      # Need to do a multi/exec so we can atomically delete from all 3 lists
+      multi
+      lrem methods_list, 0, st
+      lrem methods_in_progress_list, 0, st
+      lrem result_details(token), 0, st
+      exec
+    end
+
+    def serialize(value)
+      if value.is_a? Exception
+        # YAML can't dump an exception properly, it loses the message.
+        # and the backtrace.  Save those separately as strings.
+        YAML::dump [value, value.message, value.backtrace]
+      else
+        YAML::dump value
+      end
+    end
+
+    def deserialize(value)
+      return nil if value.nil?
+
+      result = YAML::load(value)
+
+      if result.is_a?(Array) and result[0].is_a?(Exception)
+        # Inverse of what serialize() is doing with exceptions.
+        e = result[0].class.new(result[1])
+        e.set_backtrace result[2]
+        result = e
+      end
+
+      result
+    end
+  end
+end

data/lib/live_resource/redis_client/registration.rb

@@ -0,0 +1,25 @@
+module LiveResource
+  class RedisClient
+    def instances_key
+      "#{@redis_class}.instances"
+    end
+
+    def register
+      hincrby instances_key, @redis_name, 1
+    end
+
+    def unregister
+      hincrby instances_key, @redis_name, -1
+    end
+
+    def all
+      names = []
+
+      hgetall(instances_key).each_pair do |i, count|
+        names << i if (count.to_i > 0)
+      end
+
+      names
+    end
+  end
+end

data/lib/live_resource/resource.rb

@@ -0,0 +1,44 @@
+require_relative 'log_helper'
+require_relative 'declarations'
+require_relative 'finders'
+require_relative 'attributes'
+require_relative 'methods'
+require_relative 'methods/forward'
+
+module LiveResource
+
+  # Module for all Resource providers. Any instances of resources should
+  # be registered with LiveResource::register. The class may also be
+  # registered, if any class attributes/methods should be remotely
+  # callable.
+  module Resource
+    include LiveResource::LogHelper
+    include LiveResource::Declarations
+    include LiveResource::Finders
+    include LiveResource::Attributes
+    include LiveResource::Methods
+
+    # Extends resource classes with proper class methods and
+    # class-level method dispatcher.
+    def self.included(base)
+      base.extend(LiveResource::Declarations::ClassMethods)
+
+      # The class is also extended with attribute and method support
+      # (i.e, the method dispatcher).
+      base.extend(LiveResource::Attributes)
+      base.extend(LiveResource::Methods)
+    end
+
+    # Create forward instruction that can be returned by a remote
+    # method, instructing LiveResource to forward to a different
+    # remote method instead of returing directly to the caller.
+    #
+    # @param [LiveResource::ResourceProxy] resource the resource to forward to
+    # @param [Symbol] method the resource's method to call
+    # @param params any parameters to pass with the method call
+    # @return [LiveResource::RemoteMethodForward] a forward instruction, used internally by LiveResource
+    def forward(resource, method, *params)
+      LiveResource::RemoteMethodForward.new(resource, method, params)
+    end
+  end
+end

data/lib/live_resource/resource_proxy.rb

@@ -0,0 +1,180 @@
+require_relative 'log_helper'
+require_relative 'redis_client'
+require_relative 'methods/method'
+require_relative 'methods/future'
+
+module LiveResource
+
+  # Client object that represents a resource, allowing method calls
+  # and getting/setting attributes. Typically these are returned from
+  # LiveResource finder methods (all, find, etc).
+  class ResourceProxy
+    include LiveResource::LogHelper
+
+    attr_reader :redis_class, :redis_name
+
+    # Create a new proxy given its Redis class and name; typically NOT
+    # USED by client code -- use methods of LiveResource::Finders
+    # instead.
+    def initialize(redis_class, redis_name)
+      @redis_class = redis_class
+      @redis_name = redis_name
+      @redis = RedisClient.new(redis_class, redis_name)
+      @remote_methods = @redis.registered_methods
+      @remote_attributes = @redis.registered_attributes
+    end
+
+    # Proxies attribute and remote method calls to the back-end provider.
+    def method_missing(m, *params, &block)
+      # Strip trailing ?, ! for seeing if we support method
+      sm = m.to_s.sub(/[!,?]$/, '').to_sym
+
+      if @remote_attributes.include?(m)
+        # Attribute get/set
+        if m.match(/\=$/)
+          m = m.to_s.sub(/\=$/, '').to_sym # Strip trailing equal
+
+          remote_attribute_write(m, *params)
+        else
+          remote_attribute_read(m)
+        end
+      elsif @remote_methods.include?(sm)
+        # Method call
+        method = RemoteMethod.new(
+                              :method => sm,
+                              :params => params)
+
+        if m.match(/!$/)
+          # Async call, discard result
+          method.flags[:discard_result] = true
+
+          remote_send method
+        elsif m.match(/\?$/)
+          # Async call with future
+          method = remote_send method
+          Future.new(self, method)
+        else
+          # Synchronous method call
+          wait_for_done remote_send(method)
+        end
+      else
+        super
+      end
+    end
+
+    # Checks if method is a supported attribute or remote method.
+    #
+    # @param [LiveResource::RemoteMethod] method method to send
+    # @param [Object] include_private unused
+    def respond_to_missing?(method, include_private)
+      stripped_method = method.to_s.sub(/[!,?]$/, '').to_sym
+
+      @remote_methods.include?(stripped_method) or
+        @remote_attributes.include?(method)
+    end
+
+    # Send a already-created method object; not typically used by
+    # clients -- use method_missing interface instead.
+    #
+    # @param [LiveResource::RemoteMethod] method method to send
+    def remote_send(method)
+      @redis.method_send method
+    end
+
+    # Wait for method to finish, blocks if method not complete. An
+    # exception raised by the remote resource will be captured and
+    # raised in the client's thread. Clients may only wait once for
+    # completion.
+    #
+    # @param [LiveResource::RemoteMethod] method method to wait for
+    # @param [Numeric] timeout seconds to wait for method completion
+    def wait_for_done(method, timeout = 0)
+      result = @redis.method_wait_for_result(method, timeout)
+
+      if result.is_a?(Exception)
+        # Merge the backtrace from the passed exception with this
+        # stack trace so the final backtrace looks like the method_sender
+        # called the method_provider directly.
+        # trace = merge_backtrace caller, result.backtrace
+        # result.set_backtrace trace
+
+        result.set_backtrace result.backtrace
+        raise result
+      else
+        result
+      end
+    end
+
+    # Check if remote method is already complete. May be called multiple times.
+    #
+    # @param [LiveResource::RemoteMethod] method method to check on
+    def done_with?(method)
+      @redis.method_done_with? method
+    end
+
+    # Reads remote attribute.
+    #
+    # @param [Symbol] key attribute name
+    # @return [Object] remote attribute value
+    def remote_attribute_read(key, options = {})
+      @redis.attribute_read(key, options)
+    end
+
+    # Writes remote attribute to new value.
+    #
+    # @param [Symbol] key attribute name
+    # @param [Object] value new value for attribute
+    # @return new value for attribute
+    def remote_attribute_write(key, value, options = {})
+      @redis.attribute_write(key, value, options)
+    end
+
+    def inspect
+      "#{self.class}: #{@redis_class} #{@redis_name}"
+    end
+
+    # Specify custom format when YAML encoding
+    def encode_with coder
+      coder.tag = '!live_resource:resource'
+      coder['class'] = @redis_class
+      coder['name'] = @redis_name
+    end
+
+    private
+
+    # Merge the stack trace from the method sendor and method
+    # provider so it looks like one, seamless stack trace.
+    # LiveResource traces are removed and replaced with a simple
+    # 'via LiveResource' type message.
+    def merge_backtrace(sender_trace, provider_trace)
+      return nil if provider_trace.nil?
+      return provider_trace if sender_trace.nil?
+
+      # Find the first live resource stack trace
+      index = provider_trace.index do |t|
+        t =~ /lib\/live_resource\/method_provider/  ## FIXME
+      end
+
+      # Slice off everything starting at that index
+      result = provider_trace[0 .. (index - 1)]
+
+      # Add a trace that indicates that live resource was used
+      # to link the sender to the provider.
+      result << 'via LiveResource'
+
+      # For the sender trace, remove the 'method_sendor'
+      # part of the trace.
+      index = sender_trace.index do |t| 
+        t =~ /lib\/live_resource\/method_sender/   ## FIXME
+      end
+      result += sender_trace[(index + 1) .. (sender_trace.length - 1)]
+
+      result
+    end
+  end
+end
+
+# Make YAML parser create ResourceProxy objects from our custom type.
+Psych.add_domain_type('live_resource', 'resource') do |type, val|
+  LiveResource::ResourceProxy.new(val['class'], val['name'])
+end