unified-queues 0.1.0

data/lib/unified-queues/multi/driver.rb

@@ -0,0 +1,176 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "abstract"
+
+
+##
+# Base +Unified Queues+ module.
+#
+
+module UnifiedQueues
+  
+    ##
+    # More queues single interface.
+    #
+    
+    class Multi
+      
+        ##
+        # Abstract multi driver class.
+        # @abstract
+        #
+        
+        class Driver
+          
+            ##
+            # Holds native object.
+            # @return [Object]
+            #
+            
+            attr_accessor :native
+            @native
+            
+            ##
+            # Constructor.
+            #
+            
+            def initialize(cls, *args, &block)
+                if self.instance_of? UniversalQueues::Multi::Driver
+                    not_implemented
+                end
+                
+                if cls.kind_of? Class
+                    @native = cls::new(*args, &block)
+                else
+                    @native = cls
+                end
+            end
+
+            ##
+            # Pushes value to the currently used queue.
+            #
+            # @param [Object] value
+            # @abstract
+            #
+            
+            def push(value, &block)
+                not_implemented
+            end
+            
+            ##
+            # Pops value from the queue. In contrast to default Queue library,
+            # blocks or returns +nil+ if empty.
+            # 
+            # @param [Boolean|Integer] blocking  +true+ or timeout if it should block, +false+ otherwise
+            # @return [Object|nil]
+            # @abstract 
+            #
+            
+            def pop(blocking = false, &block)
+                not_implemented
+            end
+    
+            ##
+            # Sets queue with given name as used. So marks it as target 
+            # for {#push}.
+            #
+            # @param [Object] name name of the required queue
+            # @abstract 
+            #
+            
+            def use(name, &block)
+                not_implemented
+            end
+            
+            ##
+            # Subscribes to the queue. So marks it as target for {#pop}.
+            # Note, than only single queue can be subscribed at one time.
+            #
+            # @param [Object] name  name of the required queue
+            # @abstract
+            #
+            
+            def subscribe(name, &block)
+                not_implemented
+            end
+            
+            ##
+            # Unsubscribes from the queue.
+            #
+            # @param [Object] name  name of the required queue\
+            # @abstract
+            #
+            
+            def unsubscribe(name, &block)
+                not_implemented
+            end
+            
+            ##
+            # Currently used queue.
+            #
+            # @return [Queue]
+            # @abstract
+            #
+             
+            def used(&block)
+                not_implemented
+            end
+            
+            ##
+            # Currently subscribed queue.
+            #
+            # @return [UniversalQueues::Single]
+            # @abstract
+            #
+                
+            def subscribed(&block)
+                not_implemented
+            end
+                
+            ##
+            # Lists names of all available queues.
+            #
+            # @return [Array]
+            # @abstract
+            #
+            
+            def list(&block)
+                not_implemented
+            end
+            
+            ##
+            # Lists all used queues.
+            #
+            # @return [Array]
+            # @abstract
+            #
+            
+            def list_used(&block)
+                not_implemented
+            end
+        
+            ##
+            # Lists all subscribed queues.
+            #
+            # @return [Array]
+            # @abstract
+            #
+                
+            def list_subscribed(&block)
+                not_implemented
+            end
+
+            ##
+            # Closes the session.
+            #
+            
+            def close(&block)
+                yield if not block.nil?
+            end
+            
+            alias :close! :close
+           
+        end
+    end
+end

data/lib/unified-queues/multi/driver/em-jack.rb

@@ -0,0 +1,200 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "hash-utils/array"
+require "hash-utils/object"
+require "lookup-hash"
+
+##
+# Base +Unified Queues+ module.
+#
+
+module UnifiedQueues
+  
+    ##
+    # Universal multi queue interface.
+    #
+    
+    class Multi
+      
+        ##
+        # Abstract multi driver class.
+        # @abstract
+        #
+        
+        class Driver
+                      
+            ##
+            # Wraper according to +UnifiedQueues::Single+ internal structure.
+            #
+            
+            module EMJackDriver
+                
+                ##
+                # Multi queue driver for unified queues single queue interface.
+                #
+                
+                class Connection < Driver
+                 
+                    ##
+                    # Holds native connection object.
+                    # @return EMJack::Connection
+                    #
+                    
+                    @native
+                    
+                    ##
+                    # Tracks currently used queue name.
+                    # @return Object
+                    #
+                    
+                    @used_name
+                    
+                    ##
+                    # Tracks currently subscribed queue names.
+                    # @return [LookupHash]
+                    #
+                    
+                    @subscribed_names
+                     
+                    ##
+                    # Constructor.
+                    #
+                    
+                    def initialize(cls, *args, &block)
+                        @native = cls::new(*args, &block)
+                        @subscribed_names = LookupHash["default"]
+                        @used_name = "default"
+                    end
+                    
+                    ##
+                    # Pushes value to the currently used queue.
+                    #
+                    # @param [Object] value
+                    # @param [Integer] key key for priority queues
+                    #
+                    
+                    def push(value, key = value, &block)
+                        @native.put(value, :priority => key, &block)
+                    end
+                    
+                    ##
+                    # Pops value from the queue. Callback is recurring, so it will 
+                    # keep callback active after +#pop+.
+                    # 
+                    # @param [Boolean] blocking  indicates, it should block or not
+                    # @return [Object, nil] 
+                    #
+                    
+                    def pop(blocking = false, &block)
+                        timeout = blocking ? nil : 0
+                        @native.each_job(timeout) do |job|
+                            result = job.body
+                            job.delete do
+                                yield result
+                            end
+                        end
+                    end
+                    
+                    ##
+                    # Sets queue with given name as used. So marks it as target 
+                    # for {#push}.
+                    #
+                    # @param [Object] name name of the required queue 
+                    #
+                    
+                    def use(name, &block)
+                        if name != @used_name
+                            @used_name = name
+                            @native.use(name, &block)
+                        elsif not block.nil?
+                            EM::next_tick do
+                                yield
+                            end
+                        end
+                    end
+                    
+                    ##
+                    # Subscribes to the queue. So marks it as target for {#pop}.
+                    # Note, than only single queue can be subscribed at one time.
+                    #
+                    # @param [Object] name  name of the required queue
+                    #
+                    
+                    def subscribe(name, &block)
+                        if not name.in? @subscribed_names
+                            @subscribed_names << name
+                            @native.watch(name, &block)
+                        elsif not block.nil?
+                            EM::next_tick do
+                                yield
+                            end
+                        end        
+                    end
+                    
+                    ##
+                    # Unsubscribes from the queue.
+                    # @param [Object] name  name of the required queue\
+                    #
+                    
+                    def unsubscribe(name, &block)
+                        if name.in? @subscribed_names
+                            @subscribed_names.delete name
+                            @native.ignore(name, &block)
+                        elsif not block.nil?
+                            EM::next_tick do
+                                yield
+                            end
+                        end
+                    end
+                    
+                    ##
+                    # Currently used queue.
+                    # @return [Queue]
+                    #
+                     
+                    def used
+                        yield self
+                    end
+                    
+                    ##
+                    # Currently subscribed queue.
+                    # @return [Queue]
+                    #
+                        
+                    def subscribed
+                        yield self
+                    end
+                        
+                    ##
+                    # Lists names of all available queues.
+                    # @return [Array]
+                    #
+                    
+                    def list(&block)
+                        @native.list(&block)
+                    end
+                    
+                    ##
+                    # Lists all used queues.
+                    # @return [Array]
+                    #
+                    
+                    def list_used(&block)
+                        @native.list(:used, &block)
+                    end
+                
+                    ##
+                    # Lists all subscribed queues.
+                    # @return [Array]
+                    #
+                        
+                    def list_subscribed(&block)
+                        @native.list(:watched, &block)
+                    end
+                    
+                end    
+            end
+        end
+    end
+end

data/lib/unified-queues/multi/driver/unified-queues.rb

@@ -0,0 +1,227 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "hash-utils/array"
+require "hash-utils/object"
+
+##
+# Base +Unified Queues+ module.
+#
+
+module UnifiedQueues
+  
+    ##
+    # Universal multi queue interface.
+    #
+    
+    class Multi
+      
+        ##
+        # Abstract multi driver class.
+        # @abstract
+        #
+        
+        class Driver
+                      
+            ##
+            # Wraper according to +UnifiedQueues::Single+ internal structure.
+            #
+            
+            module UnifiedQueuesDriver
+                
+                ##
+                # Multi queue driver for unified queues single queue interface.
+                #
+                
+                class Single < Driver
+                 
+                    ##
+                    # Holds available queues.
+                    # @return Hash
+                    #
+                     
+                    @queues
+                    
+                    ##
+                    # Holds default queue class.
+                    # @return [Class]
+                    #
+                    
+                    @class
+                    
+                    ##
+                    # Contains currently used queue specification.
+                    # @return Array
+                    #
+                    
+                    @used
+                    
+                    ##
+                    # Contains currently subscribed queue specification.
+                    # @return Array
+                    #
+                    
+                    @subscribed
+                    
+                    ##
+                    # Constructor.
+                    #
+                    
+                    def initialize(cls, *args, &block)
+                        @queues = { }
+                        @class = [cls, args, block]
+                    end
+                    
+                    ##
+                    # Pushes value to the currently used queue.
+                    #
+                    # @param [Object] value
+                    # @param [Object] key key for priority queues
+                    #
+                    
+                    def push(value, key = value, &block)
+                        self.used.push(value, key, &block)
+                    end
+                    
+                    ##
+                    # Pops value from the queue. In contrast to default Queue library,
+                    # blocks or returns +nil+ if empty.
+                    # 
+                    # @param [Boolean|Integer] blocking  +true+ or timeout if it should block, +false+ otherwise
+                    # @return [Object|nil] 
+                    #
+                    
+                    def pop(blocking = false, &block)
+                        self.subscribed.pop(blocking, &block)
+                    end
+                    
+                    ##
+                    # Creates new queue under given name.
+                    #
+                    # @param [Object] name identification
+                    # @return [Queue] new queue
+                    #
+                    
+                    def create(name, cls = @class)
+                        if not name.in? @queues
+                            self[name] = cls.first::new(*cls.second, &cls.third)
+                        else
+                            self[name]
+                        end        
+                    end
+                    
+                    ##
+                    # Inserts queue instance to queues.
+                    # 
+                    # @param [Object] name identification
+                    # @param [Containers::Heap] queue  heap instance
+                    # 
+                    
+                    def insert(name, queue) 
+                        @queues[name] = queue
+                    end 
+                    
+                    alias :[]= :insert
+                    
+                    ##
+                    # Returns named queue from instance.
+                    # @param [Object] name  queue name
+                    # 
+                    
+                    def get(name)
+                        @queues[name]
+                    end
+                    
+                    alias :[] :get
+                    
+                    ##
+                    # Sets queue with given name as used. So marks it as target 
+                    # for {#push}.
+                    #
+                    # @param [Object] name name of the required queue 
+                    #
+                    
+                    def use(name, &block)
+                        self.create(name)
+                        @used = [name, self[name]]
+                        yield if not block.nil?
+                    end
+                    
+                    ##
+                    # Subscribes to the queue. So marks it as target for {#pop}.
+                    # Note, than only single queue can be subscribed at one time.
+                    #
+                    # @param [Object] name  name of the required queue
+                    #
+                    
+                    def subscribe(name, &block)
+                        self.create(name)
+                        @subscribed = [name, self[name]]
+                        yield if not block.nil?        
+                    end
+                    
+                    ##
+                    # Unsubscribes from the queue.
+                    # @param [Object] name  name of the required queue\
+                    #
+                    
+                    def unsubscribe(name, &block)
+                        if not @subscribed.nil? and (@subscribed.first == name)
+                            @subscribed = nil
+                        end
+                        
+                        yield if not block.nil?
+                    end
+                    
+                    ##
+                    # Currently used queue.
+                    # @return [Queue]
+                    #
+                     
+                    def used(&block)
+                        yield @used.second if not block.nil?
+                        return @used.second
+                    end
+                    
+                    ##
+                    # Currently subscribed queue.
+                    # @return [Queue]
+                    #
+                        
+                    def subscribed(&block)
+                        yield @subscribed.second if not block.nil?
+                        return @subscribed.second
+                    end
+                        
+                    ##
+                    # Lists names of all available queues.
+                    # @return [Array]
+                    #
+                    
+                    def list
+                        @queues.keys
+                    end
+                    
+                    ##
+                    # Lists all used queues.
+                    # @return [Array]
+                    #
+                    
+                    def list_used
+                        [@used.first]
+                    end
+                
+                    ##
+                    # Lists all subscribed queues.
+                    # @return [Array]
+                    #
+                        
+                    def list_subscribed
+                        [@subscribed.first]
+                    end
+                    
+                end    
+            end
+        end
+    end
+end