asynchronic 0.1.0 → 0.2.0

data/lib/asynchronic/process.rb

@@ -4,43 +4,77 @@ module Asynchronic
     STATUSES = [:pending, :queued, :running, :waiting, :completed, :aborted]
 
     TIME_TRACKING_MAP = {
+      pending: :created_at,
       queued: :queued_at,
       running: :started_at,
       completed: :finalized_at,
       aborted: :finalized_at
     }
 
-    extend Forwardable
+    ATTRIBUTE_NAMES = [:type, :name, :queue, :status, :dependencies, :result, :error] | TIME_TRACKING_MAP.values.uniq
 
-    def_delegators :job, :id, :name, :queue
-    def_delegators :data, :[]
+    attr_reader :id
 
-    attr_reader :job
-    attr_reader :env
+    def initialize(environment, id, &block)
+      @environment = environment
+      @id = DataStore::Key.new id
+      instance_eval &block if block_given?
+    end
+
+    ATTRIBUTE_NAMES.each do |attribute|
+      define_method attribute do
+        data_store[attribute]
+      end
+    end
+
+    STATUSES.each do |status|
+      define_method "#{status}?" do
+        self.status == status
+      end
+    end
+
+    def ready?
+      pending? && dependencies.all?(&:completed?)
+    end
+
+    def finalized?
+      completed? || aborted?
+    end
 
-    def initialize(job, env)
-      @job = job
-      @env = env
+    def params
+      data_store.scoped(:params).readonly
     end
 
-    def pid
-      lookup.id
+    def result
+      data_store.lazy[:result]
     end
 
-    def data
-      parent ? parent.data : env.data_store.to_hash(lookup.data).with_indiferent_access
+    def job
+      type.new self
     end
 
-    def merge(data)
-      parent ? parent.merge(data) : env.data_store.merge(lookup.data, data)
+    def [](process_name)
+      processes.detect { |p| p.name == process_name }
     end
 
-    def enqueue(data={})
-      merge data
-      env.enqueue lookup.id, queue
-      update_status :queued
+    def processes
+      data_store.scoped(:processes).keys.
+        select { |k| k.sections.count == 2 && k.match(/name$/) }.
+        sort.map { |k| Process.new environment, id[:processes][k.remove_last] }
+    end
+
+    def parent
+      Process.new environment, id.remove_last(2) if id.nested?
+    end
+
+    def dependencies
+      return [] unless parent
+      data_store[:dependencies].map { |d| parent[d] }
+    end
 
-      lookup.id
+    def enqueue
+      queued!
+      environment.enqueue id, queue || type.queue
     end
 
     def execute
@@ -51,98 +85,93 @@ module Asynchronic
     def wakeup
       if waiting?
         if processes.any?(&:aborted?)
-          abort Error.new "Error caused by #{processes.select(&:aborted?).map{|p| p.job.name}.join(', ')}"
+          abort! Error.new "Error caused by #{processes.select(&:aborted?).map{|p| p.name}.join(', ')}"
+        elsif processes.all?(&:completed?)
+          completed!
         else
-          if processes.all?(&:completed?)
-            update_status :completed 
-          else
-            processes.select(&:ready?).each { |p| p.enqueue }
-          end
+          processes.select(&:ready?).each(&:enqueue)
         end
       end
 
       parent.wakeup if parent && finalized?
     end
 
-    def error
-      env[lookup.error]
+    def nest(type, params={})
+      self.class.create @environment, type, params.merge(id: id[:processes][processes.count])
     end
 
-    def status
-      env[lookup.status] || :pending
-    end
+    def self.create(environment, type, params={})
+      id = params.delete(:id) || SecureRandom.uuid
 
-    STATUSES.each do |status|
-      define_method "#{status}?" do
-        self.status == status
-      end
-    end
+      Asynchronic.logger.debug('Asynchronic') { "Created process #{type} - #{id} - #{params}" }
 
-    def ready?
-      pending? && dependencies.all?(&:completed?)
+      new(environment, id) do
+        self.type = type
+        self.name = params.delete(:alias) || type
+        self.queue = params.delete :queue
+        self.dependencies = Array(params.delete(:dependencies)) | Array(params.delete(:dependency)) | infer_dependencies(params)
+        self.params = params
+        pending!
+      end
     end
 
-    def finalized?
-      completed? || aborted?
+    def self.all(environment)
+      environment.data_store.keys.
+        select { |k| k.sections.count == 2 && k.match(/created_at$/) }.
+        sort_by { |k| environment.data_store[k] }.reverse.
+        map { |k| Process.new environment, k.remove_last }
     end
 
-    def processes(name=nil)
-      processes = env.data_store.keys(lookup.jobs).
-        select { |k| k.match Regexp.new("^#{lookup.jobs[Asynchronic::UUID_REGEXP]}$") }.
-        map { |k| env.load_process k }
+    private
 
-      name ? processes.detect { |p| p.name == name.to_s } : processes
+    def environment
+      @environment
     end
 
-    def parent
-      @parent ||= Process.new env[job.parent], env if job.parent
+    def data_store
+      @data_store ||= environment.data_store.scoped id
     end
 
-    def dependencies
-      @dependencies ||= parent.processes.select { |p| job.dependencies.include? p.name }
+    ATTRIBUTE_NAMES.each do |attribute|
+      define_method "#{attribute}=" do |value|
+        data_store[attribute] = value
+      end
     end
 
-    def created_at
-      env[lookup.created_at]
+    def params=(params)
+      data_store.scoped(:params).merge params
     end
 
-    def queued_at
-      env[lookup.queued_at]
+    def status=(status)
+      Asynchronic.logger.info('Asynchronic') { "#{status.to_s.capitalize} #{type} (#{id})" }
+      data_store[:status] = status
+      data_store[TIME_TRACKING_MAP[status]] = Time.now if TIME_TRACKING_MAP.key? status
     end
 
-    def started_at
-      env[lookup.started_at]
+    STATUSES.each do |status|
+      define_method "#{status}!" do
+        self.status = status
+      end
     end
 
-    def finalized_at
-      env[lookup.finalized_at]
+    def abort!(exception)
+      self.error = Error.new exception
+      aborted!
     end
 
-    private
-
     def run
-      update_status :running
-      Runtime.evaluate self
-      update_status :waiting
+      running!
+      self.result = job.call
+      waiting!
     rescue Exception => ex
-      message = "Failed job #{job.name} (#{lookup.id})\n#{ex.class} #{ex.message}\n#{ex.backtrace.join("\n")}"
+      message = "Failed process #{type} (#{id})\n#{ex.class} #{ex.message}\n#{ex.backtrace.join("\n")}"
       Asynchronic.logger.error('Asynchronic') { message }
-      abort ex
-    end
-
-    def update_status(status)
-      Asynchronic.logger.info('Asynchronic') { "#{status.to_s.capitalize} #{job.name} (#{lookup.id})" }
-      env[lookup.status] = status
-      env[lookup.send(TIME_TRACKING_MAP[status])] = Time.now if TIME_TRACKING_MAP.key? status
-    end
-
-    def abort(exception)
-      env[lookup.error] = Error.new(exception)
-      update_status :aborted
+      abort! ex
     end
 
-    def lookup
-      @lookup ||= job.lookup
+    def infer_dependencies(params)
+      params.values.select { |v| v.respond_to?(:proxy?) && v.proxy_class == DataStore::LazyValue }
+                   .map { |v| Process.new(environment, v.data_store.scope).name }
     end
 
   end

data/lib/asynchronic/queue_engine/in_memory.rb

@@ -5,10 +5,14 @@ module Asynchronic
       attr_reader :default_queue
 
       def initialize(options={})
-        @default_queue = options.fetch(:default_queue, Asynchronic.default_queue)
+        @default_queue = options[:default_queue]
         @queues ||= Hash.new { |h,k| h[k] = Queue.new }
       end
 
+      def default_queue
+        @default_queue ||= Asynchronic.default_queue
+      end
+
       def [](name)
         @queues[name]
       end

data/lib/asynchronic/queue_engine/ost.rb

@@ -6,10 +6,14 @@ module Asynchronic
 
       def initialize(options={})
         ::Ost.connect options[:redis] if options.key?(:redis)
-        @default_queue = options.fetch(:default_queue, Asynchronic.default_queue)
+        @default_queue = options[:default_queue]
         @queues ||= Hash.new { |h,k| h[k] = Queue.new k }
       end
 
+      def default_queue
+        @default_queue ||= Asynchronic.default_queue
+      end
+
       def [](name)
         @queues[name]
       end

data/lib/asynchronic/queue_engine/synchronic.rb

@@ -0,0 +1,68 @@
+module Asynchronic
+  module QueueEngine
+    class Synchronic
+
+      attr_reader :stubs
+
+      def initialize(options={})
+        @environment = options[:environment]
+        @stubs = {}
+      end
+
+      def default_queue
+        Asynchronic.default_queue
+      end
+
+      def environment
+        @environment ||= Asynchronic.environment
+      end
+
+      def [](name)
+        Queue.new self
+      end
+
+      def stub(job, &block)
+        @stubs[job] = block
+      end
+
+
+      class Queue
+
+        def initialize(engine)
+          @engine = engine
+        end
+
+        def push(message)
+          process = @engine.environment.load_process(message)
+
+          if @engine.stubs[process.type]
+            job = process.job
+            block = @engine.stubs[process.type]
+            process.define_singleton_method :job do
+              MockJob.new job, process, &block
+            end
+          end
+
+          process.execute
+        end
+
+      end
+
+
+      class MockJob < TransparentProxy
+
+        def initialize(job, process, &block)
+          super job
+          @process = process
+          @block = block
+        end
+
+        def call
+          @block.call @process
+        end
+
+      end
+
+    end
+  end
+end

data/lib/asynchronic/transparent_proxy.rb

@@ -0,0 +1,52 @@
+module Asynchronic
+  class TransparentProxy
+
+    PROXY_METHODS = [:class, :methods, :respond_to?]
+    
+    SAFE_METHODS = [:__send__, :__id__, :object_id, :tap] + PROXY_METHODS.map { |m| "proxy_#{m}".to_sym }
+
+    PROXY_METHODS.each { |m| alias_method "proxy_#{m}".to_sym, m }
+
+    instance_methods.reject { |m| SAFE_METHODS.include? m }.
+                     each   { |m| undef_method m }
+
+    def inspect
+      __getobj__.inspect
+    end
+
+    def proxy_inspect
+      "#<#{proxy_class} @object=#{inspect}>"
+    end
+
+    def methods(*args)
+      proxy_methods(*args) | __getobj__.methods(*args)
+    end
+
+    def respond_to?(*args)
+      proxy_respond_to?(*args) || __getobj__.respond_to?(*args)
+    end
+
+    def proxy?
+      true
+    end
+
+    private
+
+    def initialize(object)
+      __setobj__ object
+    end
+
+    def __getobj__
+      @object
+    end
+
+    def __setobj__(object)
+      @object = object
+    end
+
+    def method_missing(method, *args, &block)
+      __getobj__.send(method, *args, &block)
+    end
+
+  end
+end

data/lib/asynchronic/version.rb

@@ -1,3 +1,3 @@
 module Asynchronic
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/data_store/data_store_examples.rb

@@ -1,62 +1,78 @@
 module DataStoreExamples
   
   it 'Get/Set value' do
-    data_store.set 'test_key', 123
-    data_store.get('test_key').must_equal 123
+    data_store[:key] = 123
+    data_store[:key].must_equal 123
   end
 
   it 'Key not found' do
-    data_store.get('test_key').must_be_nil
+    data_store[:key].must_be_nil
   end
 
   it 'Keys' do
     data_store.keys.must_be_empty
-    data_store.set 'test_key', 123
-    data_store.keys.must_equal ['test_key']
+    data_store[:key] = 123
+    data_store.keys.must_equal ['key']
   end
 
-  it 'Merge' do
-    data_store.set 'a:1', 0
-    data_store.merge 'a', '1' => 1, '2' => 2
-
-    data_store.get('a:1').must_equal 1
-    data_store.get('a:2').must_equal 2
+  it 'Delete' do
+    data_store[:key] = 123
+    data_store.delete :key
+    data_store[:key].must_be_nil
   end
 
-  it 'To hash' do
-    data_store.set 'a', 0
-    data_store.set 'a:1', 1
-    data_store.set 'a:2', 2
-    data_store.set 'b:3', 3
+  it 'Each' do
+    data_store[:a] = 1
+    data_store[:b] = 2
 
-    data_store.to_hash('a').must_equal '1' => 1, '2' => 2
+    array = []
+    data_store.each { |k,v| array << "#{k} => #{v}" }
+    array.must_equal_contents ['a => 1', 'b => 2']
   end
 
-  it 'Nested keys' do
-    data_store.set 'a', 0
-    data_store.set 'a:1', 1
-    data_store.set 'a:2', 2
-    data_store.set 'b:3', 3
+  it 'Merge' do
+    data_store[:a] =  0
+    data_store.merge a: 1, b: 2
 
-    data_store.keys('a').must_equal_contents %w(a a:1 a:2)
-    data_store.keys('a:').must_equal_contents %w(a:1 a:2)
+    data_store[:a].must_equal 1
+    data_store[:b].must_equal 2
   end
 
   it 'Clear' do
-    data_store.set 'test_key', 123
+    data_store[:key] = 123
     data_store.clear
     data_store.keys.must_be_empty
   end
 
-  it 'Nested clear' do
-    data_store.set 'a', 0
-    data_store.set 'a:1', 1
-    data_store.set 'a:2', 2
-    data_store.set 'b:3', 3
+  it 'Scoped' do
+    data_store['x|y|z'] = 1
+    data_store.scoped(:x)['y|z'].must_equal 1
+    data_store.scoped(:x).scoped(:y)[:z].must_equal 1
+  end
+
+  it 'Read only' do
+    data_store[:key] = 1
+    data_store.wont_be :readonly?
+    data_store.readonly.tap do |ds|
+      ds[:key].must_equal 1
+      ds.must_be :readonly?
+      proc { ds[:key] = 2 }.must_raise RuntimeError
+    end
+  end
+
+  it 'Lazy' do
+    data_store[:key] =  1
+    lazy_store = data_store.lazy
+    lazy_value = lazy_store[:key]
+
+    data_store.wont_be :lazy?
+    lazy_store.must_be :lazy?
+    lazy_value.must_equal 1
 
-    data_store.clear 'a:'
+    data_store[:key] =  2
 
-    data_store.keys.must_equal_contents %w(a b:3)
+    lazy_value.must_equal 1
+    lazy_value.reload.must_equal 2
   end
   
 end