redcar-dev 0.12.17dev

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

@@ -0,0 +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/plugin/storage.rb

@@ -0,0 +1,133 @@
+
+module Redcar
+  class Plugin
+    class BaseStorage
+      
+      # Open a storage file or create it if it doesn't exist.
+      #
+      # @param [String] storage_dir  the path to the directory the storage file should exist in
+      # @param [String] name  a (short) name, should be suitable for use as a filename
+      def initialize(storage_dir, name)
+        @storage_dir = storage_dir
+        @name  = name
+        @mutex = Mutex.new
+        unless File.exists?(@storage_dir)
+          FileUtils.mkdir_p(@storage_dir)
+        end
+        rollback
+      end
+
+      # Save the storage to disk.
+      def save
+        @mutex.synchronize do
+          File.open(path, "w") { |f| YAML.dump(@storage, f) }
+          update_timestamp
+        end
+        self
+      end
+
+      # Rollback the storage to the latest revision saved to disk or empty it if
+      # it hasn't been saved.
+      def rollback
+        if File.exists?(path)
+          @mutex.synchronize do
+            @storage = YAML.load_file(path)
+            raise 'storage file is corrupted--please delete ' + path unless @storage.is_a?(Hash)
+            update_timestamp
+          end
+        else
+          @storage = {}
+        end
+        self
+      end
+      
+      # retrieve key value
+      # note: it does not re-read from disk before returning you this value
+      def [](key)
+        if @last_modified_time
+          if File.stat(path()).mtime != @last_modified_time
+            rollback
+          end
+        end
+        @storage[key]
+      end
+      
+      # set key to value
+      # note: it automatically saves this to disk
+      def []=(key, value)
+        @storage[key] = value
+        save
+        value
+      end
+      
+      # Set a default value for a key and save it to disk
+      def set_default(key, value)
+        unless @storage.has_key?(key)
+          self[key] = value
+        end
+        value
+      end
+      
+      # Get all keys in the storage
+      # @return [Array] the Array with all keys
+      def keys
+        @storage.keys
+      end
+      
+      private
+      
+      def path
+        File.join(@storage_dir, @name + ".yaml")
+      end
+      
+      def update_timestamp
+        @last_modified_time = File.stat(path).mtime
+      end
+    end
+    
+    class Storage < Plugin::BaseStorage
+      def self.storage_dir=(value)
+        @user_dir = value
+      end
+    
+      def self.storage_dir
+        @user_dir ||= File.join(Redcar.user_dir, "storage")
+      end
+      
+      def initialize(name)
+        super(self.class.storage_dir, name)
+      end
+    end
+    
+    # A Storage which is used by multiple plugins. This kind of storage can only
+    # contain arrays, because otherwise plugins could not set their defaults as
+    # addition to the existing ones of other plugins.
+    class SharedStorage < Plugin::Storage
+      # Set a default value for a key or update it, if it already exists
+      def set_or_update_default(key, value)
+        if @storage.has_key?(key)
+          update_default(key, value)
+        else
+          if value.instance_of? Array
+            set_default(key, value)
+          else
+            set_default(key, [value])
+          end
+        end
+        @storage[key] = @storage[key].uniq
+        value
+      end
+      
+      private
+      
+      def update_default(key, value)
+        if value.instance_of? Array
+          self[key] = self[key] + value
+        else
+          self[key] << value
+        end
+      end
+    end
+  end
+end
+

data/plugins/core/lib/core/reentry_helpers.rb

@@ -0,0 +1,13 @@
+module Redcar
+  module ReentryHelpers
+    def ignore_changes
+      @ignore_changes ||= Hash.new(0)
+    end
+    
+    def ignore(name)
+      ignore_changes[name] += 1
+      yield if ignore_changes[name] == 1
+      ignore_changes[name] -= 1
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+
+module Redcar
+  class Resource
+    attr_reader :block, :task
+    
+    class << self
+      attr_accessor :compute_synchronously
+    end
+    
+    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
+      if Resource.compute_synchronously
+        @value = block.call
+      else
+        @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
+    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/plugin.rb

@@ -0,0 +1,7 @@
+
+Plugin.define do
+  name    "core"
+  version "1.0"
+  object  "Redcar::Core"
+  file    "lib", "core"
+end

data/plugins/core/spec/core/base_storage_spec.rb

@@ -0,0 +1,81 @@
+
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Redcar::Plugin::BaseStorage do
+  
+  before :each do
+    @tmp_dir = File.join(File.dirname(__FILE__), "tmp")
+    FileUtils.mkdir_p(@tmp_dir)
+  end
+  
+  after :each do
+    FileUtils.rm_rf(@tmp_dir)
+  end
+  
+  def get_new_storage
+    Redcar::Plugin::BaseStorage.new(@tmp_dir, 'test_storage_saved')
+  end
+  
+  it "acts like a hash" do
+    storage = get_new_storage
+    storage[:some_key] = "some value"
+    storage[:some_key].should == "some value"
+    storage[:some_key] = "some other value"
+    storage[:some_key].should == "some other value"
+  end
+
+  it "saves to disk" do
+    storage = get_new_storage
+    storage[:some_key] = "some value"
+    storage = get_new_storage
+    storage[:some_key].should == "some value"
+    
+    FileUtils.rm_rf(storage.send(:path))
+    storage = get_new_storage
+    storage[:some_key].should be_nil
+  end
+  
+  it "has a set default method" do
+    storage = get_new_storage
+    storage.set_default('a', 'b')    
+    storage['a'].should == 'b'
+    storage = get_new_storage
+    storage['a'].should == 'b'
+    storage['a'] = 'c'
+    storage['a'].should == 'c'
+    storage = get_new_storage
+    storage['a'].should == 'c'
+    storage['b'] = false
+    storage.set_default('b', true)
+    storage['b'].should == false
+  end
+  
+  it "should raise an error when the storage file is invalid/corrupt" do
+    storage = get_new_storage
+    FileUtils.touch(storage.send(:path))
+    lambda { storage.rollback }.should raise_error(RuntimeError)
+  end
+  
+  it "should reload when the storage file itself has been elsewise modified" do
+    storage = get_new_storage
+    storage['a'] = 'b'
+    storage['a'].should == 'b'
+    storage['a'].should == 'b'
+    sleep 1 # windows doesn't have finer granularity than this
+    File.open(storage.send(:path), 'w') do |f|
+      f.write "---
+                a: new"
+    end    
+    storage['a'].should == 'new'
+    storage['a'].should == 'new'
+    storage = get_new_storage
+    storage['a'].should == 'new'    
+  end
+  
+  it "should allow per-instance storage directory" do
+    storage  = Redcar::Plugin::BaseStorage.new(@tmp_dir, 'test_storage_saved')
+    storage2 = Redcar::Plugin::BaseStorage.new(File.join(@tmp_dir, "sub"), 'test_storage_saved')
+    storage.send(:path).should_not == storage2.send(:path)
+  end
+  
+end