gilmour 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a61b1be06598f3e75a8a9ba987f972258955edd
-  data.tar.gz: 8198bf46a1945c319c95002a7f0885eb66aa961c
+  metadata.gz: 2f60416d0af8de59564c01a5580ee0a40df3772d
+  data.tar.gz: 2055fa3c380a7524d528c5e079c671e70f4acbfc
 SHA512:
-  metadata.gz: 06e5a201e77837513442296ae6f2d116893f6cfbe4aa84bafeaaab468b56ca89e3f7a5fe91dc730932ad72ad2e8014c5d27e5cc96a8f6ca156dd56aff39d07cd
-  data.tar.gz: 01e1a704c10fd57fc3c29304d24e8f09699ccd28b1dfe2a2d1d870878977f0feb0eadc03bd64dfb7d43bcc736beb85214da9d9a4ce5f5e9aefde74ee12149a1d
+  metadata.gz: 6225255b7c13937b8c0cf83def803eb8827908a8b1580a838d3617b2d3845b743b008294736fb3890af2c090300748d30e4797c8f69de5ee86dfc0ccdf61224f
+  data.tar.gz: c6b4e8128620579b15939d0fe6ca3be4d377acc513495bc2c692e1e2650a6c7c83f7d9942eb9bd90f0dcd36ed74a54e7bbf50a868f4a1dbd79b4f6eec2a8939b

data/.gitignore

@@ -3,3 +3,4 @@
 *.swp
 *.gem
 
+doc

data/README.md

@@ -30,6 +30,7 @@ Microservices increase the granularity of our services oriented architectures. B
 * Composition: `cmd1 | cmd2 | cmd2`
 * AndAnd: `cmd1 && cmd2 && cmd3`
 * Batch: `cmd1; cmd2; cmd3 > out` or `(cmd1; cmd2; cmd3) > out`
+* Parallel: This runs stages in parallel call the callback when all are done. The data passed to the callback is an array of {:data, :code} hashes in no particular order. The code is the highest error code from the array.
 
 Also, you should be able to use these methods of composition in any combination and also in a nexted manner - `(cmd1 | cmd2) && cmd3`. Gilmour enables you to do just that. See `examples/composition.rb`.
 

data/examples/composition.rb

@@ -76,9 +76,9 @@ batch.execute do |data, code|
 end
 batch_waiter.wait
 
-batch_record =  gilmour.batch([{topic: 'one'}, {topic: 'badtwo'},
-                               {topic: 'three', message: {'anotherthree' => 'anotherthree'}}],
-true) # true will record all responses in an array
+batch_record = gilmour.batch([{topic: 'one'}, {topic: 'badtwo'},
+                              {topic: 'three', message: {'anotherthree' => 'anotherthree'}}
+                             ]).with_recorder # with_recorder will record all responses in an array
 batch_record_waiter = Gilmour::Waiter.new
 batch_record.execute do |data, code|
   puts "\nbatch with record:"
@@ -87,6 +87,13 @@ batch_record.execute do |data, code|
 end
 batch_record_waiter.wait
 
+parallel = gilmour.parallel([{topic: 'one'}, {topic: 'badtwo'}])
+parallel.execute do |data, code|
+  puts "\nparallel:"
+  puts code
+  data.each { |d| puts d }
+end
+
 t_andand = gilmour.andand([{topic: 'one'}, {topic: 'two'}])
 # Use the above composition inside another
 compose = gilmour.compose([t_andand, {topic: 'three'}])

data/gilmour.gemspec

@@ -17,7 +17,6 @@ Gem::Specification.new do |s|
   s.add_dependency "mash"
   s.add_dependency "redis"
   s.add_dependency "gilmour-em-hiredis"
-  s.add_dependency "amqp"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/gilmour/backends/redis.rb

@@ -145,7 +145,11 @@ module Gilmour
       end
     end
 
-    def response_handler(sender, payload) #:nodoc:
+    def response_handler(sender, payload)
+      EM.defer { _response_handler(sender, payload) }
+    end
+
+    def _response_handler(sender, payload) #:nodoc:
       data, code, _ = Gilmour::Protocol.parse_response(payload)
       handler = @response_handlers.delete(sender)
       @subscriber.unsubscribe(sender)

data/lib/gilmour/composers.rb

@@ -25,7 +25,11 @@ module Gilmour
 
       def execute(data = {}, &blk)
         if @spec.kind_of?(Proc)
-          res = @spec.call(data)
+          begin
+            res = @spec.call(data)
+          rescue => e
+            code = 500
+          end
           code = res ? 200 : 500
           blk.call(res, code)
         else
@@ -114,8 +118,8 @@ module Gilmour
     # any kind of composition itself, allowing the creation of
     # nested compositions. See examples in the source code.
     #
-    def compose(spec)
-      Compose.new(self, spec)
+    def compose(*spec)
+      Compose.new(self, spec.flatten)
     end
 
     class AndAnd < Pipeline
@@ -142,16 +146,20 @@ module Gilmour
     # It is roughly equivalent to the unix construct
     #   cmd1 && cmd2 && cmd3
 
-    def andand(spec)
-      AndAnd.new(self, spec)
+    def andand(*spec)
+      AndAnd.new(self, spec.flatten)
     end
 
     class Batch < Pipeline
-      def initialize(backend, spec, record=false) #:nodoc:
+      def initialize(backend, spec) #:nodoc:
         super(backend, spec)
-        @record = record
+        @record = false
       end
 
+      def with_recorder(record=true)
+        @record = record
+        self
+      end
       # Execute the batch pipeline. This pipeline ignores all errors
       # step is passed to block.
       # See the documentation of the #batch method for more details
@@ -183,8 +191,45 @@ module Gilmour
     # +record+:: If this is false, only the output of the last step
     # is passed to the block passed to execute. If true, all outputs
     # are collected in an array and passed to the block
-    def batch(spec, record=false)
-      Batch.new(self, spec, record)
+    def batch(*spec)
+      Batch.new(self, spec.flatten)
+    end
+
+    class Parallel < Pipeline
+      def initialize(backend, spec) #:nodoc:
+        super(backend, spec)
+      end
+
+      # Execute the batch pipeline. This pipeline ignores all errors
+      # step is passed to block.
+      # See the documentation of the #batch method for more details
+      def execute(data=nil, &blk)
+        results = []
+        blk.call(nil, nil) if pipeline.empty?
+        waiters = []
+        pipeline.each do |p|
+          waiter = Gilmour::Waiter.new
+          waiters << waiter
+          p.execute do |d, c|
+            results << {data: d, code: c}
+            waiter.signal
+          end
+        end 
+        waiters.each(&:wait)
+        code = results.map { |r| r[:code] }.max
+        blk.call(results, code)
+      end 
+    end
+
+    def parallel(*spec)
+      Parallel.new(self, spec.flatten)
+    end
+
+    def sync(*spec, &blk)
+      Parallel.new(self, spec.flatten).execute do |_res, code|
+        res = _res.size == 1 ? _res.first[:data] : _res
+        blk.call(res, code)
+      end
     end
   end
 end

data/lib/gilmour/responder.rb

@@ -29,6 +29,7 @@ module Gilmour
 
     attr_reader :logger
     attr_reader :request
+    attr_reader :backend
 
     def child_logger(writer) #:nodoc:
       logger = Logger.new(STDERR)

data/test/spec/test_pipelines.rb

@@ -131,6 +131,23 @@ describe 'Pipelines' do
     end
   end
 
+  context 'Parallel' do
+    Given(:parallel) {
+      gilmour.parallel([{topic: 'one'}, {topic: 'badtwo'}, 
+                        {topic: 'three', message: {'anotherthree' => 'anotherthree'}}])
+    }
+    Then {
+      done = false
+      parallel.execute do |data, code|
+        expect(data).to be_kind_of(Array)
+        expect(data.size).to eq(3)
+        expect(code).to eq(500)
+        done = true
+      end
+      expect(done).to eq(true)
+    }
+  end
+
   context 'Batch' do
     context 'Without record' do
       Given(:batch) {
@@ -158,8 +175,8 @@ describe 'Pipelines' do
     context 'With record' do
       Given(:batchrecord) {
         gilmour.batch([{topic: 'one'}, {topic: 'badtwo'},
-                        {topic: 'three', message: {'anotherthree' => 'anotherthree'}}],
-                      true)
+                       {topic: 'three', message: {'anotherthree' => 'anotherthree'}}
+                      ]).with_recorder
       }
       Then {
         waiter = Waiter.new
@@ -183,8 +200,13 @@ describe 'Pipelines' do
       Given(:andand) {
         gilmour.andand([{topic: 'one'}, {topic: 'two'}])
       }
+      Given(:parallel) {
+        gilmour.compose([gilmour.parallel([{topic: 'one'}, {topic: 'two'}]),
+                        ->(d) { d.reduce({}) { |m, r| m.merge(r[:data]) } }]
+                       )
+      }
       Given(:compose) {
-        gilmour.compose([andand, {topic: 'three'}])
+        gilmour.compose([andand, parallel, {topic: 'three'}])
       }
       Then {
         waiter = Waiter.new
@@ -195,11 +217,11 @@ describe 'Pipelines' do
           waiter.signal
         end
         waiter.wait
-        expect(data.keys.size).to eq(2)
-        ['two', 'three'].each do |k|
+        expect(code).to eq(200)
+        expect(data.keys.size).to eq(3)
+        ['one', 'two', 'three'].each do |k|
           expect(data.has_key?(k)).to be_truthy
         end
-        expect(code).to eq(200)
       }
     end
   end

data/test/spec/test_subscriber_redis_reply_slot.rb

@@ -11,7 +11,6 @@ def install_test_subscriber
   TestReplier.callback do |topic, data|
     @topic = topic
     @data = data
-    $stderr.puts "Got callback #{topic}, #{data}"
     waiter.signal
   end
   waiter

data/version.rb

@@ -1,3 +1,3 @@
 module Gilmour
-    VERSION = '0.4.4'
+    VERSION = '0.4.5'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gilmour
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors:
 - Aditya Godbole
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-15 00:00:00.000000000 Z
+date: 2015-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -81,20 +81,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: amqp
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: This gem provides a Sinatra like DSL and a simple protocol to enable
   writing services that communicate over AMQP
 email: