redcar 0.3.4.3 → 0.3.5

data/plugins/core/lib/core.rb

@@ -14,7 +14,19 @@ require "core/persistent_cache"
 require "core/plugin"
 require "core/plugin/storage"
 
+require "core/task"
+require "core/task_queue"
+require "core/resource"
+
 module Redcar
+  def self.tmp_dir
+    path = File.join(Redcar.user_dir, "tmp")
+    unless File.exists?(path)
+      FileUtils.mkdir(path)
+    end
+    path
+  end
+    
   class Core
     include HasLogger
     
@@ -25,6 +37,5 @@ module Redcar
       end
       PersistentCache.storage_dir = File.join(Redcar.user_dir, "cache")
     end
-    
   end
 end

data/plugins/core/lib/core/observable.rb

@@ -66,11 +66,11 @@ module Redcar
     def add_listener(*event_names, &block)
       if event_names.first.is_a?(Hash)
         event_names.first.each do |aspect, event_name|
-          events(event_name.to_s)[ASPECTS[aspect]] << block
+          observable_events(event_name.to_s)[ASPECTS[aspect]] << block
         end
       else
         event_names.each do |event_name|
-          events(event_name.to_s)[ASPECTS[:after]] << block
+          observable_events(event_name.to_s)[ASPECTS[:after]] << block
         end
       end
       block
@@ -91,19 +91,19 @@ module Redcar
     # @param [Symbol] name of event being run
     # @param [*Object] event parameters
     def notify_listeners(event_name, *args)
-      run_blocks(event_name, :before, args)
+      observable_run_blocks(event_name, :before, args)
       yield if block_given?
-      run_blocks(event_name, :after, args)
+      observable_run_blocks(event_name, :after, args)
     end
     
     private
     
-    def run_blocks(event_name, aspect, args)
-      blocks = events(event_name.to_s)[ASPECTS[aspect]].clone
+    def observable_run_blocks(event_name, aspect, args)
+      blocks = observable_events(event_name.to_s)[ASPECTS[aspect]].clone
       blocks.each {|b| b.call(*args) }
     end
     
-    def events(event_name)
+    def observable_events(event_name)
       @events ||= {}
       @events[event_name.to_s] ||= [[], []]
     end

data/plugins/core/lib/core/persistent_cache.rb

@@ -18,8 +18,8 @@ module Redcar
     end
     
     def cache
-      if File.exist?(cache_file_name)
-        Marshal.load(File.read(cache_file_name))
+      if result = read_cache_file
+        result
       else
         result = yield
         write_cache_file(Marshal.dump(result))
@@ -41,5 +41,17 @@ module Redcar
       FileUtils.mkdir_p(PersistentCache.storage_dir)
       File.open(cache_file_name, "w") {|f| f.puts contents }
     end
+    
+    def read_cache_file
+      if File.exist?(cache_file_name)
+        begin
+          Marshal.load(File.read(cache_file_name))
+        rescue => e
+          puts "WARNING: couldn't load #{cache_file_name}, despite it existing."
+          puts e.class.name + " " + e.message
+          puts e.backtrace
+        end
+      end
+    end
   end
 end

data/plugins/core/lib/core/plugin.rb

@@ -1,5 +1,12 @@
 
 module Redcar
   class Plugin
+    def self.call(obj, method, default, *args, &block)
+      if obj.respond_to?(method)
+        obj.send(method, *args, &block)
+      else
+        default
+      end
+    end
   end
 end

data/plugins/core/lib/core/resource.rb

@@ -0,0 +1,78 @@
+
+module Redcar
+  class Resource
+    attr_reader :block, :task
+    
+    def self.task_queue
+      Redcar.app.task_queue
+    end
+    
+    def initialize(description=nil, &block)
+      @description = description
+      @block  = block
+      @value  = nil
+      @future = nil
+      @task   = nil
+      @mutex  = Mutex.new
+    end
+    
+    def value
+      return @value if @value
+      
+      object = nil
+      @mutex.synchronize do
+        if @future
+          if @task.pending?
+            @task.cancel
+            @future = nil
+            @task   = nil
+            object = @block
+          else
+            object = @future
+          end
+        else
+          object = @block
+        end
+      end
+      
+      case object
+      when Proc
+        @value = object.call
+      else
+        @value = object.get
+      end
+    end
+    
+    def compute
+      @mutex.synchronize do
+        unless @task and @task.pending?
+          @task = Resource::Task.new(self)
+          @task.description = @description
+          @future = Resource.task_queue.submit(@task)
+        end
+      end
+    end
+    
+    class Task < Redcar::Task
+      def initialize(resource)
+        @resource = resource
+      end
+      
+      def execute
+        result = @resource.block.call
+        @resource.send(:set_value_from_background, result)
+        result
+      end
+    end
+    
+    private
+    
+    def set_value_from_background(value)
+      @mutex.synchronize do
+        @value  = value
+        @future = nil
+        @task   = nil
+      end
+    end
+  end
+end

data/plugins/core/lib/core/task.rb

@@ -0,0 +1,62 @@
+
+module Redcar
+  class Task
+    include java.util.concurrent.Callable
+ 
+    attr_accessor :_queue, :enqueue_time, :start_time, :completed_time, :description
+    attr_reader   :error
+
+    def pending?
+      @enqueue_time and !@start_time
+    end
+    
+    def in_process?
+      @start_time and !@completed_time
+    end
+    
+    def completed?
+      @completed_time
+    end
+    
+    def cancel
+      @cancelled = true
+      _queue.send(:completed_task, self)
+    end
+    
+    def cancelled?
+      @cancelled
+    end
+    
+    def call
+      begin
+        unless cancelled?
+          _queue.send(:started_task, self)
+          @start_time = Time.now
+          result = execute
+          @completed_time = Time.now
+          _queue.send(:completed_task, self)
+          result
+        end
+      rescue Object => e
+        @error = e
+        @completed_time = Time.now
+        _queue.send(:completed_task, self)
+        nil
+      end
+    end
+    
+    def execute
+      raise "implement me!"
+    end
+    
+    def inspect
+      "<Task>"
+    end
+    
+    private
+    
+    def _set_cancelled
+      @cancelled = true
+    end
+  end
+end

data/plugins/core/lib/core/task_queue.rb

@@ -0,0 +1,72 @@
+
+module Redcar
+  class TaskQueue
+    MAX_COMPLETED_LENGTH = 20
+    
+    attr_reader :in_process, :mutex
+    
+    def initialize
+      @executor = java.util.concurrent.Executors.newSingleThreadExecutor
+      @mutex    = Mutex.new
+      @pending   = []
+      @completed = []
+      @in_process = nil
+    end
+    
+    def submit(task)
+      @mutex.synchronize do
+        @pending << task
+        task._queue        = self
+        task.enqueue_time = Time.now
+        future = @executor.submit(task)
+      end
+    end
+    
+    def pending
+      @mutex.synchronize do
+        @pending.dup
+      end
+    end
+    
+    def completed
+      @mutex.synchronize do
+        @completed.dup
+      end
+    end
+        
+    def stop
+      @mutex.synchronize do
+        @executor.shutdown_now
+      end
+    end
+    
+    def cancel_all
+      @mutex.synchronize do
+        @pending.each {|task| task.send(:_set_cancelled) }
+        @completed += @pending
+        @pending   = []
+      end
+    end
+
+    private
+    
+    def started_task(task)
+      @mutex.synchronize do
+        @in_process = task
+        @pending.delete(task)
+      end
+    end
+    
+    def completed_task(task)
+      @mutex.synchronize do
+        @pending.delete(task)
+        @in_process = nil if @in_process == task
+        @completed << task
+        if @completed.length > MAX_COMPLETED_LENGTH
+          @completed = @completed[(-1*MAX_COMPLETED_LENGTH)..-1]
+        end
+      end
+    end
+  end
+end
+

data/plugins/core/spec/core/resource_spec.rb

@@ -0,0 +1,124 @@
+
+require 'java'
+
+require File.join(File.dirname(__FILE__), *%w".. spec_helper")
+
+TaskQueue = Redcar::TaskQueue
+Task      = Redcar::Task
+Resource  = Redcar::Resource
+
+describe Resource do
+  before do
+    $started_tasks = []
+    @block_runs = 0
+    @started_flag = false
+    @finish_flag  = false
+    $wait_task_finish = false
+    @q = TaskQueue.new
+    Resource.stub!(:task_queue).and_return(@q)
+  end
+  
+  after do
+    @q.stop
+  end
+  
+  describe "synchronous get" do
+    it "should let you synchronously get the value" do
+      resource = Resource.new { 101 }
+      resource.value.should == 101
+    end
+    
+    it "should cache the value across multiple calls" do
+      resource = Resource.new { @block_runs += 1; 101 }
+      resource.value
+      resource.value
+      resource.value.should == 101
+      @block_runs.should == 1
+    end
+      
+    it "should wait for a background job to finish if one is already in progress" do
+      resource = Resource.new do
+        @block_runs += 1
+        1 until @finish_flag
+      end
+      resource.compute
+      Thread.new do
+        resource.value
+      end
+      sleep 0.1
+      @finish_flag = true
+      @block_runs.should == 1
+    end
+    
+    it "should not wait for a background job if it pending, because it may have a long wait" do
+      @q.submit(BlockingTask.new)
+      resource = Resource.new do
+        @block_runs += 1
+        911
+      end
+      resource.compute
+      Thread.new do
+        resource.value
+      end
+      sleep 0.1
+      resource.value.should == 911
+      @block_runs.should == 1
+    end
+    
+    it "should cancel background jobs that it overtakes" do
+      @q.submit(BlockingTask.new)
+      resource = Resource.new do
+        @block_runs += 1
+        911
+      end
+      resource.compute
+      task = resource.task
+      Thread.new do
+        resource.value
+      end
+      sleep 0.1
+      task.should be_cancelled
+    end
+  end
+  
+  it "should let you compute the resource in the background" do
+    resource = Resource.new do
+      1 until @started_flag
+      @block_runs += 1
+      @finish_flag = true
+    end
+    resource.compute
+    @block_runs.should == 0
+    @started_flag = true
+    1 until @finish_flag
+    @block_runs.should == 1
+  end
+  
+  it "should have the background computed value" do
+    resource = Resource.new do
+      @block_runs += 1
+      @started_flag = true
+      999
+    end
+    resource.compute
+    1 until @started_flag
+    sleep 0.1
+    resource.value.should == 999
+    @block_runs.should == 1
+  end
+  
+  it "should not compute lots of times" do
+    resource = Resource.new do
+      @block_runs += 1
+      1 until @finish_flag
+      999
+    end
+    20.times { resource.compute }
+    @finish_flag = true
+    resource.value.should == 999
+    1 until @block_runs == 2
+    @block_runs.should == 2
+  end
+end
+
+