asynchronic 0.1.0 → 0.2.0

data/lib/asynchronic.rb

@@ -9,8 +9,6 @@ Dir.glob(File.expand_path('asynchronic/**/*.rb', File.dirname(__FILE__))).sort.e
 
 module Asynchronic
 
-  UUID_REGEXP = '[a-z\d]{8}-[a-z\d]{4}-[a-z\d]{4}-[a-z\d]{4}-[a-z\d]{12}'
-
   extend ClassConfig
 
   attr_config :default_queue, :asynchronic

data/lib/asynchronic/data_store/helper.rb

@@ -0,0 +1,42 @@
+module Asynchronic
+  module DataStore
+    module Helper
+
+      include Enumerable
+
+      def each
+        keys.each { |k| yield [k, self[k]] }
+        nil
+      end
+
+      def merge(hash)
+        hash.each { |k,v| self[k] = v }
+      end
+
+      def clear
+        keys.each { |k| delete k }
+      end
+
+      def scoped(key)
+        ScopedStore.new self, key
+      end
+
+      def readonly?
+        false
+      end
+
+      def readonly
+        ReadonlyStore.new self
+      end
+
+      def lazy?
+        false
+      end
+
+      def lazy
+        LazyStore.new self
+      end
+
+    end
+  end
+end

data/lib/asynchronic/data_store/in_memory.rb

@@ -2,44 +2,40 @@ module Asynchronic
   module DataStore
     class InMemory
 
-      def initialize
+      include Helper
+
+      def initialize(hash={})
         @hash = {}
         @mutex = Mutex.new
+        self.class.connections[object_id] = self
       end
 
-      def get(key)
+      def [](key)
         @hash[key.to_s]
       end
 
-      def set(key, value)
+      def []=(key, value)
         @mutex.synchronize { @hash[key.to_s] = value }
       end
 
-      def merge(key, hash)
-        scoped_key = Key.new key
-        hash.each do |k,v|
-          set scoped_key[k].to_s, v
-        end
+      def delete(key)
+        @hash.delete key.to_s
       end
 
-      def to_hash(key)
-        children_key = "#{key}:"
-        keys(children_key).inject({}) do |hash, k|
-          hash[k[children_key.size..-1]] = get k
-          hash
-        end
+      def keys
+        @hash.keys.map { |k| Key.new k }
       end
 
-      def keys(key=nil)
-        key ? keys.select { |k| k.start_with? key.to_s } : @hash.keys
+      alias_method :connection, :object_id
+
+      def self.connect(object_id)
+        connections[object_id]
       end
 
-      def clear(key=nil)
-        if key
-          @hash.delete_if { |k,v| k.start_with? key.to_s }
-        else
-          @hash.clear
-        end
+      private
+
+      def self.connections
+        @connections ||= {}
       end
 
     end

data/lib/asynchronic/data_store/key.rb

@@ -2,12 +2,30 @@ module Asynchronic
   module DataStore
     class Key < String
     
+      SEPARATOR = '|'
+      
       def initialize(key)
         super key.to_s
       end
 
       def [](key)
-        self.class.new "#{self}:#{key}"
+        self.class.new [self,key].join(SEPARATOR)
+      end
+
+      def sections
+        split SEPARATOR
+      end
+
+      def nested?
+        sections.count > 1
+      end
+
+      def remove_first(count=1)
+        self.class.new sections[count..-1].join(SEPARATOR)
+      end
+
+      def remove_last(count=1)
+        self.class.new sections[0..-count-1].join(SEPARATOR)
       end
 
     end

data/lib/asynchronic/data_store/lazy_store.rb

@@ -0,0 +1,17 @@
+require_relative '../transparent_proxy'
+
+module Asynchronic
+  module DataStore
+    class LazyStore < TransparentProxy
+
+      def [](key)
+        LazyValue.new __getobj__, key
+      end
+
+      def lazy?
+        true
+      end
+
+    end
+  end
+end

data/lib/asynchronic/data_store/lazy_value.rb

@@ -0,0 +1,34 @@
+require_relative '../transparent_proxy'
+
+module Asynchronic
+  module DataStore
+    class LazyValue < TransparentProxy
+
+      def initialize(data_store, key)
+        @data_store_class = data_store.class
+        @data_store_connection = data_store.connection
+        @key = key
+      end
+
+      def reload
+        @value = nil
+        self
+      end
+
+      def inspect
+        "#<#{proxy_class} @data_store_class=#{@data_store_class} @data_store_connection=#{@data_store_connection} @key=#{@key}>"
+      end
+
+      def data_store
+        @data_store_class.connect @data_store_connection
+      end
+
+      private
+
+      def __getobj__
+        @value ||= data_store[@key]
+      end
+
+    end
+  end
+end

data/lib/asynchronic/data_store/readonly_store.rb

@@ -0,0 +1,17 @@
+require_relative '../transparent_proxy'
+
+module Asynchronic
+  module DataStore
+    class ReadonlyStore < TransparentProxy
+ 
+      def []=(key, value)
+        raise "Can't modify read only data store"
+      end
+
+      def readonly?
+        true
+      end
+
+    end
+  end
+end

data/lib/asynchronic/data_store/redis.rb

@@ -2,49 +2,38 @@ module Asynchronic
   module DataStore
     class Redis
 
-      attr_reader :connection
+      include Helper
 
       def initialize(*args)
         @connection = ::Redis.new *args
       end
 
-      def get(key)
-        value = connection.get root[key]
+      def [](key)
+        value = @connection.get key.to_s
         value ? Marshal.load(value) : nil
+      rescue => ex
+        Asynchronic.logger.warn('Asynchronic') { ex.message }
+        value
       end
 
-      def set(key, value)
-        connection.set root[key], Marshal.dump(value)
+      def []=(key, value)
+        @connection.set key.to_s, Marshal.dump(value)
       end
 
-      def merge(key, hash)
-        scoped_key = Key.new key
-        hash.each do |k,v|
-          set scoped_key[k], v
-        end
+      def delete(key)
+        @connection.del key.to_s
       end
 
-      def to_hash(key)
-        children_key = "#{key}:"
-        keys(children_key).inject({}) do |hash, k|
-          hash[k[children_key.size..-1]] = get k
-          hash
-        end
+      def keys
+        @connection.keys.map { |k| Key.new k }
       end
 
-      def keys(key=nil)
-        keys = key ? connection.keys("#{root[key]}*") : connection.keys
-        keys.map { |k| k[(root.size + 1)..-1] }
+      def connection
+        @connection.client.options
       end
 
-      def clear(key=nil)
-        keys(key).each { |k| connection.del root[k] }
-      end
-
-      private
-
-      def root
-        Key.new :asynchronic
+      def self.connect(options)
+        new options
       end
       
     end

data/lib/asynchronic/data_store/scoped_store.rb

@@ -0,0 +1,52 @@
+module Asynchronic
+  module DataStore
+    class ScopedStore
+
+      include Helper
+
+      attr_reader :data_store
+      attr_reader :scope
+      
+      def initialize(data_store, scope)
+        @data_store = data_store
+        @scope = Key.new scope
+      end
+
+      def [](key)
+        @data_store[@scope[key]]
+      end
+
+      def []=(key, value)
+        @data_store[@scope[key]] = value
+      end
+
+      def delete(key)
+        @data_store.delete @scope[key]
+      end
+
+      def keys
+        @data_store.keys.
+          select { |k| k.start_with? @scope[''] }.
+          map { |k| Key.new(k).remove_first @scope.sections.count }
+      end
+
+      def connection
+        {
+          data_store_class: @data_store.class,
+          data_store_connection: @data_store.connection,
+          scope: @scope
+        }
+      end
+
+      def self.connect(options)
+        data_store = options[:data_store_class].connect options[:data_store_connection]
+        new data_store, options[:scope]
+      end
+
+      def to_s
+        "#<#{self.class} @data_store=#{@data_store} @scope=#{@scope}>"
+      end
+
+    end
+  end
+end

data/lib/asynchronic/environment.rb

@@ -6,15 +6,7 @@ module Asynchronic
     
     def initialize(queue_engine, data_store)
       @queue_engine = queue_engine
-      @data_store = data_store
-    end
-
-    def [](key)
-      data_store.get key
-    end
-
-    def []=(key, value)
-      data_store.set key, value
+      @data_store = data_store.scoped :asynchronic
     end
 
     def queue(name)
@@ -29,28 +21,16 @@ module Asynchronic
       queue(queue || queue_engine.default_queue).push msg
     end
 
-    def build_job(job_class, options={})
-      Asynchronic.logger.debug('Asynchronic') { "Building job #{job_class} - #{options}" }
-      job_class.new(options).tap do |job|
-        self[job.lookup.id] = job
-        self[job.lookup.created_at] = Time.now
-      end
+    def create_process(type, params={})
+      Process.create self, type, params
     end
 
-    def build_process(job_class, options={})
-      Process.new build_job(job_class, options), self
+    def load_process(id)
+      Process.new self, id
     end
-
-    def load_process(pid)
-      Process.new self[pid], self
-    end
-
+    
     def processes
-      data_store.keys.
-        select { |k| k.match Regexp.new("job:#{Asynchronic::UUID_REGEXP}:created_at$") }.
-        sort_by {|k| data_store.get k }.
-        reverse.
-        map { |k| load_process k.gsub(':created_at', '') }
+      Process.all self
     end
 
   end

data/lib/asynchronic/job.rb

@@ -1,45 +1,33 @@
 module Asynchronic
   class Job
 
-    attr_reader :id
-    attr_reader :name
-    attr_reader :queue
-    attr_reader :parent
-    attr_reader :dependencies
-    attr_reader :local
-
-    def initialize(options={})
-      @id = SecureRandom.uuid
-      @name = options.key?(:alias) ? options[:alias].to_s : self.class.to_s
-      @queue = options[:queue] || self.class.queue
-      @parent = options[:parent]
-      @dependencies = Array(options[:dependencies] || options[:dependency]).map(&:to_s)
-      @local = options[:local] || {}
-
-      raise 'Cant have dependencies without parent job' if dependencies.any? && parent.nil?
+    def initialize(process)
+      @process = process
     end
 
-    def lookup
-      DataStore::Lookup.new self
+    def params
+      @process.params
     end
 
-    def self.queue(queue=nil)
-      queue ? @queue = queue : @queue
+    def result(reference)
+      @process[reference].result
     end
 
-    def self.implementation
-      @implementation
+    def self.queue(name=nil)
+      name ? @queue = name : @queue
     end
 
-    def self.enqueue(data={})
-      process = Asynchronic.environment.build_process self
-      process.enqueue data
+    def self.enqueue(params={})
+      process = Asynchronic.environment.create_process self, params
+      process.enqueue
+      process.id
     end
 
     private
 
-    def self.define(&block)
-      @implementation = block
+    def async(type, params={})
+      @process.nest type, params
+      nil
     end
 
   end