liveresource 2.0.0

data/lib/live_resource/finders.rb

@@ -0,0 +1,43 @@
+require_relative 'resource_proxy'
+
+module LiveResource
+  module Finders
+
+    def LiveResource.all(resource_class)
+      redis_names = RedisClient.new(resource_class, nil).all
+
+      redis_names.map do |redis_name|
+        ResourceProxy.new(RedisClient.redisized_key(resource_class), redis_name)
+      end
+    end
+
+    def LiveResource.find(resource_class, resource_name = nil, &block)
+      if resource_name.nil? and block.nil?
+        # Find class resource instead of instance resource.
+        resource_name = resource_class
+        resource_class = "class"
+      end
+
+      if block.nil?
+        block = lambda { |name| name == RedisClient.redisized_key(resource_name) ? name : nil }
+      end
+
+      redis_name = RedisClient.new(resource_class, nil).all.find do |name|
+        block.call(name)
+      end
+
+      if redis_name
+        ResourceProxy.new(RedisClient.redisized_key(resource_class), redis_name)
+      else
+        nil
+      end
+    end
+
+    def LiveResource.any(resource_class)
+      resources = all(resource_class)
+
+      resources[rand(resources.length)]
+    end
+  end
+end
+

data/lib/live_resource/log_helper.rb

@@ -0,0 +1,24 @@
+require 'logger'
+
+module LiveResource
+  module LogHelper
+    def logger
+      if @logger.nil?
+        @logger = Logger.new(STDERR)
+        @logger.level = Logger::WARN
+      end
+
+      @logger
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    [:debug, :info, :warn, :error, :fatal].each do |level|
+      define_method(level) do |*params|
+        logger.send(level, params.join(' '))
+      end
+    end
+  end
+end

data/lib/live_resource/methods.rb

@@ -0,0 +1,41 @@
+require_relative 'methods/dispatcher'
+
+module LiveResource
+  module Methods
+    attr_reader :dispatcher
+
+    # Start the method dispatcher for this resource. On return, the
+    # resource will be visible to finders (.all(), etc.)
+    # and remote methods may be called.
+    def start
+      if @dispatcher
+        @dispatcher.start
+      else
+        @dispatcher = RemoteMethodDispatcher.new(self)
+      end
+
+      @dispatcher.wait_for_running
+      self
+    end
+
+    def stop
+      return if @dispatcher.nil?
+
+      @dispatcher.stop
+      self
+    end
+
+    def running?
+      @dispatcher && @dispatcher.running?
+    end
+
+    def remote_methods
+      if self.is_a? Class
+        remote_singleton_methods
+      else
+        self.class.remote_instance_methods
+      end
+    end
+  end
+end
+

data/lib/live_resource/methods/dispatcher.rb

@@ -0,0 +1,176 @@
+require_relative '../log_helper'
+require_relative '../redis_client'
+
+module LiveResource
+  class RemoteMethodDispatcher
+    include LogHelper
+
+    attr_reader :thread, :resource
+
+    def initialize(resource)
+      @resource = resource
+      @thread = nil
+      @running = false
+
+      start
+    end
+
+    def redis
+      @resource.redis
+    end
+
+    def start
+      return if @thread
+
+      @thread = Thread.new { run }
+    end
+
+    def stop
+      return if @thread.nil?
+
+      redis.method_push exit_token
+      @running = false
+      @thread.join
+      @thread = nil
+    end
+
+    def running?
+      (@thread != nil) && @running
+    end
+
+    def wait_for_running
+      while !running? do
+        Thread.pass
+      end
+    end
+
+    def run
+      info("#{self} method dispatcher starting")
+
+      # Register methods and attributes used by this resource class
+      redis.register_methods @resource.remote_methods
+      redis.register_attributes @resource.remote_attributes
+
+      # Need to register our class and instance in Redis so the finders
+      # (all, any, etc.) will work.
+      redis.register
+
+      @running = true
+
+      begin
+        loop do
+          token = redis.method_wait
+
+          if is_exit_token(token)
+            if token == exit_token
+              redis.method_done token
+              break
+            else
+              redis.method_push token
+              next
+            end
+          end
+
+          method = redis.method_get(token)
+
+          begin
+            result = validate_method(method).call(*method.params)
+
+            if result.is_a? Resource
+              # Return descriptor of a resource proxy instead
+              result = ResourceProxy.new(
+                result.redis.redis_class,
+                result.redis.redis_name)
+            elsif result.is_a? RemoteMethodForward
+              # Append forwarding instructions to current method
+              method.forward_to result
+            end
+
+            if method.final_destination?
+              redis.method_result method, result
+            else
+              # Forward on to next step in method's path
+              dest = method.next_destination!
+
+              unless result.is_a? RemoteMethodForward
+                # First parameter(s) to next method will be the result
+                # of this method call.
+                if result.is_a? Array
+                  method.params = result + method.params
+                else
+                  method.params.unshift result
+                end
+              end
+
+              dest.remote_send method
+            end
+          rescue Exception => e
+            # TODO: custom encoding for exception to make it less
+            # Ruby-specific.
+
+            debug "Method #{method.token} failed:", e.message
+            redis.method_result method, e
+          end
+
+          redis.method_done token
+          redis.method_discard_result(token) if method.flags[:discard_result]
+        end
+      ensure
+        # NOTE: if this process crashes outright, or we lose network
+        # connection to Redis, or whatever -- this decrement won't occur.
+        # Supervisor should clean up where possible.
+        redis.unregister
+
+        info("#{self} method dispatcher exiting")
+
+      end
+    end
+
+    private
+
+    # Verify validity of remote method being called
+    def validate_method(m)
+
+      # Check that method is remote callable
+      unless @resource.remote_methods.include?(m.method)
+        raise NoMethodError.new("Undefined method `#{m.method}' (#{@resource.remote_methods.join(', ')})")
+      end
+
+      method = @resource.method(m.method)
+
+      # Check for nil params when method is expecting 1 or more arguments
+      if (method.arity != 0 && m.params.nil?)
+        raise ArgumentError.new("wrong number of arguments to `#{m.method}'" \
+                      "(0 for #{method.arity})")
+      end
+
+      # If the arity is >= 0, then the number of params should be the same as the
+      # arity.
+      #
+      # For variable argument methods, the arity is -n-1 where n is the number of
+      # required arguments. This means if the arity is < -1, there must be at least
+      # (artiy.abs - 1) arguments (NOTE: if there are no required arguments, there's
+      # nothing to check).
+      if (method.arity >= 0 and method.arity != m.params.length) or
+          (method.arity < -1 and (method.arity.abs - 1) > m.params.length)
+        raise ArgumentError.new("wrong number of arguments to `#{m.method}'" \
+                      "(#{m.params.length} for #{method.arity})")
+      end
+
+      method
+    end
+
+    EXIT_PREFIX = 'exit'
+
+    def exit_token
+      # Construct an exit token for this resource
+      "#{EXIT_PREFIX}.#{Socket.gethostname}.#{Process.pid}.#{@thread.object_id}"
+    end
+
+    def is_exit_token(token)
+      # Exit tokens are strings which can be search with a regular expresion.
+      return false unless token.respond_to? :match
+      token.match /^#{EXIT_PREFIX}/
+    end
+  end
+end

data/lib/live_resource/methods/forward.rb

@@ -0,0 +1,23 @@
+require_relative 'method'
+
+module LiveResource
+  class RemoteMethodForward
+    attr_reader :resource, :method, :params, :next
+
+    def initialize(resource, method, params)
+      @resource = resource
+      @method = method
+      @params = params
+      @next = nil
+    end
+
+    def continue(resource, method, *params)
+      @next = self.class.new(resource, method, params)
+      self
+    end
+
+    def inspect
+      "#{self.class}: #{@resource} #{@method} (#{@params.length} params)"
+    end
+  end
+end

data/lib/live_resource/methods/future.rb

@@ -0,0 +1,27 @@
+module LiveResource
+  # Returned from async method calls, in order to later get a method's
+  # return value.
+  class Future
+    def initialize(proxy, method)
+      @proxy = proxy
+      @method = method
+      @value = nil
+    end
+
+    def value(timeout = 0)
+      if @value.nil?
+        @value = @proxy.wait_for_done(@method, timeout)
+      end
+
+      @value
+    end
+
+    def done?
+      if @value.nil?
+        @proxy.done_with? @method
+      else
+        true
+      end
+    end
+  end
+end

data/lib/live_resource/methods/method.rb

@@ -0,0 +1,93 @@
+require 'yaml'
+require_relative 'token'
+require_relative 'forward'
+
+module LiveResource
+  class RemoteMethod
+    attr_reader :flags, :path
+    attr_accessor :token
+
+    def initialize(params)
+      @path = params[:path]
+      @token = params[:token]
+      @flags = params[:flags] || {}
+
+      if @path.nil?
+        unless params[:method]
+          raise ArgumentError.new("RemoteMethod must have a method")
+        end
+
+        @path = []
+        @path << {
+          :method => params[:method],
+          :params => (params[:params] || []) }
+      end
+    end
+
+    def method
+      @path[0][:method]
+    end
+
+    def params
+      @path[0][:params]
+    end
+
+    def params=(new_params)
+      @path[0][:params] = new_params
+    end
+
+    def add_destination(proxy, method, params)
+      @path << {
+        :resource => proxy,
+        :method => method,
+        :params => params }
+
+      self
+    end
+
+    def forward_to(forward)
+      while forward
+        @path << {
+          :resource => forward.resource,
+          :method => forward.method,
+          :params => forward.params }
+
+        forward = forward.next
+      end
+
+      self
+    end
+
+    def next_destination!
+      @path.shift
+      @path[0][:resource]
+    end
+
+    def final_destination?
+      @path.length == 1
+    end
+
+    def inspect
+      if @path.length == 1
+        "#{self.class}: #{@path[0][:method]} (#{@path[0][:params].length} params)"
+      else
+        "#{self.class}: #{@path.length} path elements"
+      end
+    end
+
+    def encode_with coder
+      coder.tag = '!live_resource:method'
+      coder['flags'] = @flags
+      coder['path'] = @path
+      coder['token'] = @token if @token
+    end
+  end
+end
+
+# Make YAML parser create Method objects from our custom type.
+Psych.add_domain_type('live_resource', 'method') do |type, data|
+  # Convert string keys to symbols
+  data = Hash[data.map { |k,v| [k.to_sym, v] }]
+
+  LiveResource::RemoteMethod.new(data)
+end

data/lib/live_resource/methods/token.rb

@@ -0,0 +1,22 @@
+require 'yaml'
+
+module LiveResource
+  class RemoteMethodToken
+    attr_reader :redis_class, :redis_name, :seq
+
+    def initialize(redis_class, redis_name, seq)
+      @redis_class = redis_class
+      @redis_name = redis_name
+      @seq = seq
+    end
+
+    def encode_with coder
+      coder.represent_scalar '!live_resource:token', "#{@redis_class}.#{@redis_name}.#{@seq}"
+    end
+  end
+end
+
+# Make YAML parser create Method objects from our custom type.
+Psych.add_domain_type('live_resource', 'token') do |type, data|
+  LiveResource::RemoteMethodToken.new(*(data.split '.'))
+end