ocean-rails 3.8.8 → 3.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e7029f8a24a193b18d67675b993929c586fa83f
-  data.tar.gz: fe5a91ec43553c934329db63ac353d98b6648cb9
+  metadata.gz: 25d86f8d69015565033c12e60edb7017186d6829
+  data.tar.gz: 83a3f9b85153a9708225aa5ab46ad58e5b7837fa
 SHA512:
-  metadata.gz: 2a33fe06e8d9a47f50139608fcba2ca6bfc441237a054d21c7b9324f68941b7b2ac7f26dbf036c675fe05096a17effd6e1379d14844bc9c8a013a9f76d313432
-  data.tar.gz: 47c8f5e6d2c47d92ced28e1ae53f62665f63b87c5e7b96cd7ea69162274108ab86023922549a8633eed4adcd8ccb1b38a471d280621a2a519deece28468af2ec
+  metadata.gz: e7540bf449eb3e0d3aa5755f2fa75fd9ed22b8e74f6fd7409908a4836bd6f3e858e4f82cadbeb50a6236fe50d17d39cc891b9a87068347d14201e7ba8b084a1e
+  data.tar.gz: 00618f27d71e1446ac3f1135757c8944a0b8dd69873d5978166f6d058b6694e47173892ccbbf22bd4104511dc1afc4b41d5a8542e9d3acff1cf783c732b24448

data/lib/ocean/api.rb

@@ -172,7 +172,8 @@ class Api
                    reauthentication: true,
                    ssl_verifypeer: true, ssl_verifyhost: 2,
                    retries: 0, backoff_time: 1, backoff_rate: 0.9, backoff_max: 30,
-                   x_metadata: Thread.current[:metadata])
+                   x_metadata: Thread.current[:metadata],
+                   &block)
     # Set up the request
     headers['Accept'] = "application/json"
     headers['Content-Type'] = "application/json" if [:post, :put].include?(http_method)
@@ -181,63 +182,109 @@ class Api
     headers['X-API-Token'] = x_api_token if x_api_token.present?
     headers['X-Metadata'] = x_metadata if x_metadata.present?
 
-    response = nil
     tries_done = 0
     max_tries = [:get, "GET", "get"].include?(http_method) ? retries + 1 : 1
-    while (true) do
-      tries_done += 1
-      last_try = tries_done >= max_tries
-
-      while (true) do
-        request = Typhoeus::Request.new(url, 
-                                        method: http_method, 
-                                        headers: headers,
-                                        params: args, 
-                                        body: body, 
-                                        ssl_verifypeer: ssl_verifypeer,
-                                        ssl_verifyhost: ssl_verifyhost)
-        # Run it
-        response = Response.new(request.run)
-        # If successful, return
-        return response if response.success?
-
-        # Not successful, deal with it
-        if last_try
-          raise Api::TimeoutError, "Api.request timed out" if response.timed_out?
-          raise Api::NoResponseError, "Api.request could not obtain a response" if response.status == 0
-        else
-          break if response.timed_out?
-          break if response.status == 0
-        end
 
-        # Reauthenticate if necessary
-        if [400, 419].include?(response.status) && reauthentication && x_api_token.present?
-          # Re-authenticate and retry
-          if credentials
-            x_api_token = Api.authenticate(*Api.decode_credentials(credentials))
-            headers['X-API-Token'] = x_api_token
-          else
-            Api.reset_service_token
-            headers['X-API-Token'] = Api.service_token
+    @hydra ||= Typhoeus::Hydra.hydra
+    request = nil   # For clarity
+    response = nil
+
+    # This is a Proc when run queues the request and schedules retries
+    enqueue_request = Proc.new do
+      # First construct a request. It will not be sent yet.
+      request = Typhoeus::Request.new(url,
+                                      method: http_method, 
+                                      headers: headers,
+                                      params: args, 
+                                      body: body, 
+                                      ssl_verifypeer: ssl_verifypeer,
+                                      ssl_verifyhost: ssl_verifyhost)
+
+      # Define a callback to process the response and do retries
+      request.on_complete do |typhoeus_response|
+        response = Response.new(typhoeus_response)
+        case response.status
+        when 100..199
+          enqueue_request.call  # Ignore and retry
+        when 200..299, 304
+          # Success, call the post-processor if any
+          if block
+            response = block.call response
           end
-          reauthentication = false   # This prevents us from ending up here twice
-        elsif (400..499).include?(response.status)
-          return response
+        when 300..399
+          nil  # Done, redirect
+        when 400, 419
+          if reauthentication && x_api_token.present?
+            # Re-authenticate and retry
+            if credentials
+              x_api_token = Api.authenticate(*Api.decode_credentials(credentials))
+              headers['X-API-Token'] = x_api_token
+            else
+              Api.reset_service_token
+              headers['X-API-Token'] = Api.service_token
+            end
+            reauthentication = false   # This prevents us from ending up here twice
+            enqueue_request.call
+          else
+            nil  # Done, fail
+          end          
+        when 400..499
+          nil  # Done, fail
         else
-          # Retry on 500s (will we ever get 300s?)
-          break
+          # Retry if there are any retries left
+          if retries > 0
+            retries -= 1
+            sleep backoff_time
+            backoff_time = [backoff_time + backoff_time * backoff_rate, 30].min
+            enqueue_request.call
+          else
+            nil  # Done, don't retry
+          end
         end
+      end
+
+      # Finally, queue the request (and its callback) for execution
+      @hydra.queue request
+      # Return nil, to emphasise that the side effects are what's important
+      nil
+    end
 
+    # So create and enqueue the request
+    enqueue_request.call
+    # Run it, unless we're accumulating calls inside an Api.simultaneously block
+    unless @inside_simultaneously
+      # The next line blocks until completed, possibly after several retries
+      @hydra.run
+      if response.is_a?(Response)
+        # Raise any exceptions
+        raise Api::TimeoutError, "Api.request timed out" if response.timed_out?
+        raise Api::NoResponseError, "Api.request could not obtain a response" if response.status == 0
       end
-      # Retry
-      break if last_try
-      sleep backoff_time
-      seconds = [backoff_time + backoff_time * backoff_rate, 30].min
-      backoff_time = seconds
+      return response
     end
-    # Return the wrapped response to the failed request
-    response
-  end 
+    # Return nil: we have no response yet
+    nil
+  end
+
+
+  def self.simultaneously (&block)
+    raise "block required" unless block
+    @inside_simultaneously = true   
+    @hydra = nil 
+    block.call
+  ensure
+    @inside_simultaneously = false
+  end
+
+
+  def self.simultaneously?
+    @inside_simultaneously ||= false
+  end
+
+
+  # http://liufengyun.chaos-lab.com/prog/2013/10/23/continuation-in-ruby.html
+  # http://gnuu.org/2009/03/21/demystifying-continuations-in-ruby/
+  # http://www.ruby-doc.org/core-2.1.3/Continuation.html
 
 
   class TimeoutError < StandardError; end
@@ -556,6 +603,7 @@ class Api
     h
   end
 
+
   #
   # Takes the same args as +.async_job_body+, post an +AsyncJob+ and returns the +Response+.
   # The +AsyncJob+ is always created as the service +ApiUser+; the job carries its own
@@ -564,8 +612,13 @@ class Api
   # +:job+ as the only parameter.
   #
   # A block may be given. It will be called with any +TimeoutError+ or +NoResponseError+,
-  # which allows +Api.run_async_job+ to be used very tersely in controllers.
+  # which allows +Api.run_async_job+ to be used very tersely in controllers, e.g.:
   #
+  #   Api.run_async_job(...) do |e| 
+  #     render_api_error 422, e.message
+  #     return
+  #   end
+  # 
   def self.run_async_job(href=nil, method=nil, job: nil, **keywords, &block)
     job ||= async_job_body(href, method, **keywords)
     Api.request "#{INTERNAL_OCEAN_API_URL}/v1/async_jobs", :post,

data/lib/ocean/api_remote_resource.rb

@@ -271,7 +271,7 @@ class Api
     # Instance method to GET a resource or any of its hyperlinks. Will raise exceptions
     # if they occur, otherwise will return the resource itself.
     #
-    def get!(hlink=nil)
+    def get!(hlink=nil, args: nil)
       RemoteResource._retrieve self unless present?
       hlink = hlink.to_s if hlink
       if !hlink || hlink == 'self' 
@@ -305,7 +305,7 @@ class Api
     # Instance method to do a PUT to a resource or any of its hyperlinks. Will raise exceptions
     # if they occur, otherwise will return the resource itself.
     #
-    def put!(hlink=nil, body: {})
+    def put!(hlink=nil, args: nil, body: {})
       get!
       hlink = hlink.to_s if hlink
       if !hlink || hlink == 'self' 
@@ -315,7 +315,7 @@ class Api
         hl_data = hyperlink[hlink]
         raise HyperlinkMissing, "#{resource_type} has no #{hlink} hyperlink" unless hl_data
         hl_res = RemoteResource.new(hl_data['href'])
-        hl_res.send :_modify, body
+        hl_res.send :_modify, body, args: args
         hl_res
       end
     end
@@ -325,7 +325,7 @@ class Api
     # exceptions if they occur, but will always return the resource itself.
     # A missing hyperlink, though, will always raise a HyperlinkMissing exception.
     #
-    def put(hlink=nil, body: {})
+    def put(hlink=nil, args: nil, body: {})
       get
       hlink = hlink.to_s if hlink
       if !hlink || hlink == 'self' 
@@ -335,7 +335,7 @@ class Api
         hl_data = hyperlink[hlink]
         raise HyperlinkMissing, "#{resource_type} has no #{hlink} hyperlink" unless hl_data
         hl_res = RemoteResource.new(hl_data['href'])
-        hl_res.send :_modify, body
+        hl_res.send :_modify, body, args: args
         hl_res
       end
     end
@@ -345,12 +345,12 @@ class Api
     # Instance method to do a POST to a resource or any of its hyperlinks. Will raise exceptions
     # if they occur, otherwise will return the resource itself.
     #
-    def post!(hlink=nil, body: {})
+    def post!(hlink=nil, args: nil, body: {})
       get!
       hlink = (hlink || 'self').to_s
       hl_data = hyperlink[hlink]
       raise HyperlinkMissing, "#{resource_type} has no #{hlink} hyperlink" unless hl_data
-      _create(hl_data['href'], body)
+      _create(hl_data['href'], body, args: args)
     end
 
     #
@@ -358,12 +358,12 @@ class Api
     # exceptions if they occur, but will always return the resource itself.
     # A missing hyperlink, though, will always raise a HyperlinkMissing exception.
     #
-    def post(hlink=nil, body: {})
+    def post(hlink=nil, args: nil, body: {})
       get
       hlink = (hlink || 'self').to_s
       hl_data = hyperlink[hlink]
       raise HyperlinkMissing, "#{resource_type} has no #{hlink} hyperlink" unless hl_data
-      _create(hl_data['href'], body) rescue nil
+      _create(hl_data['href'], body, args: args) rescue nil
     end
 
 
@@ -371,12 +371,12 @@ class Api
     # Instance method to do a DELETE to a resource or any of its hyperlinks. Will raise exceptions
     # if they occur, otherwise will return the resource itself.
     #
-    def delete!(hlink=nil)
+    def delete!(hlink=nil, args: nil)
       get!
       hlink = (hlink || 'self').to_s
       hl_data = hyperlink[hlink]
       raise HyperlinkMissing, "#{resource_type} has no #{hlink} hyperlink" unless hl_data
-      _destroy(hl_data['href'])
+      _destroy(hl_data['href'], args: args)
       self
     end
 
@@ -385,12 +385,12 @@ class Api
     # exceptions if they occur, but will always return the resource itself.
     # A missing hyperlink, though, will always raise a HyperlinkMissing exception.
     #
-    def delete(hlink=nil)
+    def delete(hlink=nil, args: nil)
       get
       hlink = (hlink || 'self').to_s
       hl_data = hyperlink[hlink]
       raise HyperlinkMissing, "#{resource_type} has no #{hlink} hyperlink" unless hl_data
-      _destroy(hl_data['href']) rescue nil
+      _destroy(hl_data['href'], args: args) rescue nil
       self
     end
 
@@ -466,6 +466,7 @@ class Api
       rr
     end
 
+
     def _conditional_get
       credentials, token = RemoteResource._credentials(self)
       response = Api.request Api.internalize_uri(uri), :get, 
@@ -515,12 +516,12 @@ class Api
     end
 
 
-    def _modify(body)
+    def _modify(body, args: nil)
       credentials, token = RemoteResource._credentials(self)
       response = Api.request Api.internalize_uri(uri), :put, headers: {}, body: body.to_json,
                              credentials: credentials, x_api_token: token,
                              retries: retries, backoff_time: backoff_time, backoff_rate: backoff_rate, 
-                             backoff_max: backoff_max
+                             backoff_max: backoff_max, args: args
       self.response = response
       self.status = response.status
       self.status_message = response.message
@@ -540,12 +541,12 @@ class Api
     end
 
 
-    def _create(post_uri, body)
+    def _create(post_uri, body, args: nil)
       credentials, token = RemoteResource._credentials(self)
       response = Api.request Api.internalize_uri(post_uri), :post, headers: {}, body: body.to_json,
                              credentials: credentials, x_api_token: token,
                              retries: retries, backoff_time: backoff_time, backoff_rate: backoff_rate, 
-                             backoff_max: backoff_max
+                             backoff_max: backoff_max, args: args
       self.response = response
       self.status = response.status
       self.status_message = response.message
@@ -564,12 +565,12 @@ class Api
     end
 
 
-    def _destroy(delete_uri)
+    def _destroy(delete_uri, args: nil)
       credentials, token = RemoteResource._credentials(self)
       response = Api.request Api.internalize_uri(delete_uri), :delete, headers: {},
                              credentials: credentials, x_api_token: token,
                              retries: retries, backoff_time: backoff_time, backoff_rate: backoff_rate, 
-                             backoff_max: backoff_max
+                             backoff_max: backoff_max, args: args
       self.response = response
       self.status = response.status
       self.status_message = response.message

data/lib/ocean/continuation_experiments.rb

@@ -0,0 +1,139 @@
+require 'continuation'
+
+  # Api.simultaneously takes a block. It executes the block straight away. 
+  #
+  # When executing inside an Api.simultaneously block, Api.request only enqueues its request,
+  # but doesn't run it. They register on_complete handlers that will be run asynchronously
+  # when Api.simultaneously fires hydra to run after the block.
+  #
+  # When Api.request runs outside Api.simultaneously, it simply returns an Api::Response.
+  # When running inside Api.simultaneously, however, Api.request creates a continuation
+  # and registers it with Api.simultaneously. After the block has run, Api.simultaneously
+  # invokes each continuation in turn with another continuation to allow the next 
+  # continuation to be called. When there are no more continuations to process, 
+  # Api.simultaneously returns normally. In this way, all continuations are executed serially 
+  # to process the Api.request results, no matter who called them or from where.
+
+class Quux
+
+  require 'continuation'
+
+
+  def self.simultaneously?
+    !!@continuations
+  end
+
+  def self.accumulating?
+    @accumulating
+  end
+
+
+  def self.simultaneously
+    raise "Api.simultaneously may not be nested" if simultaneously?
+    @continuations = []
+    # Execute the block
+    begin
+      puts "--------------------------- ACCUMULATING ------------------------"
+      @accumulating = true
+      yield @continuations
+    ensure
+      @accumulating = false
+    end
+
+    # The continuations array should now have entries. Create a continuation
+    # to return to this point.
+    begin
+      puts '', "--------------------------- EXECUTING ------------------------"
+    cc, results, result = callcc { |cc, results, result| [cc, [], :init] }
+    # '-BACK AT TOP LEVEL-----', [cc, results, result].inspect
+    raise "must be a continuation" unless cc.is_a? Continuation
+    results << result if result && result != :init
+    # Call the first accumulated continuation (if any) with it. When they call
+    # here, the next continuation will be called (if any). This is a loop,
+    # continuation style.
+      if @continuations.size > 0
+        @continuations.shift.call(cc, results)
+      end
+      ensure
+    # No longer nested
+    @continuations = nil
+    end
+    results
+  end
+
+
+  def self.doubler (arg, k: nil)
+    raise "K is not a continuation: #{k.inspect}" if k && !k.is_a?(Continuation)
+    cc, acc = callcc { |cc, acc| [cc, acc] }
+    puts '', '-CONTINUATION CALL TO DOUBLER-----', [cc, acc].inspect
+    return cc if accumulating?
+
+    # Execution phase
+
+    # Calculate a result
+    result = arg * 2                # Calculate the result
+
+    # Transfer back
+    k.call(k, result) if k          # Go elsewhere if k is there (e.g. to a nested caller)
+    cc.call(cc, acc, result)        # Return to caller
+  end
+
+
+  def self.nested(arg, k: nil)
+    raise "K is not a continuation: #{k.inspect}" if k && !k.is_a?(Continuation)
+    cc, acc = callcc { |cc, acc| [cc, acc] }
+    puts '', '-CONTINUATION CALL TO NESTED-----', [cc, acc].inspect
+    return cc if accumulating?
+
+    # Execution phase
+    # Set up the overriding continuation for the callee
+    callee_k, result = callcc { |callee_k, result| [callee_k, result] }
+    # The callee returns to the following statement
+    result = doubler(arg, k: callee_k) unless result   # Can't be nil or false (fix later)
+
+    # Calculate a result
+    result = "#{result} processed"
+
+    # Transfer back
+    k.call(k, result) if k          # Go elsewhere if k is there (e.g. to a nested caller)
+    cc.call(cc, acc, result)        # Return to caller
+  end
+
+
+  def self.deeply_nested(arg, k: nil)
+    raise "K is not a continuation: #{k.inspect}" if k && !k.is_a?(Continuation)
+    cc, acc = callcc { |cc, acc| [cc, acc] }
+    puts '', '-CONTINUATION CALL TO DEEPLY_NESTED-----', [cc, acc].inspect
+    return cc if accumulating?
+
+    # Execution phase
+    # Set up the overriding continuation for the callee
+    callee_k, result = callcc { |callee_k, result| [callee_k, result] }
+    # The callee returns to the following statement
+    result = nested(arg, k: callee_k) unless result   # Can't be nil or false (fix later)
+
+    # Calculate a result
+    result = "#{result} more deeply"
+
+    # Transfer back
+    k.call(k, result) if k          # Go elsewhere if k is there (e.g. to a nested caller)
+    cc.call(cc, acc, result)        # Return to caller
+  end
+
+end
+
+
+
+# This accumulates stuff
+res = Quux.simultaneously do |r|
+  r << Quux.doubler(24)
+  r << Quux.nested("hej")
+  r << Quux.doubler(100)
+  r << Quux.deeply_nested("woo")
+  r << Quux.doubler(1)
+end
+
+puts
+puts res.inspect
+puts
+

data/lib/ocean/version.rb

@@ -1,3 +1,3 @@
 module Ocean
-  VERSION = "3.8.8"
+  VERSION = "3.8.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ocean-rails
 version: !ruby/object:Gem::Version
-  version: 3.8.8
+  version: 3.8.9
 platform: ruby
 authors:
 - Peter Bengtson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-09 00:00:00.000000000 Z
+date: 2014-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -252,6 +252,7 @@ files:
 - lib/ocean/api.rb
 - lib/ocean/api_remote_resource.rb
 - lib/ocean/api_resource.rb
+- lib/ocean/continuation_experiments.rb
 - lib/ocean/engine.rb
 - lib/ocean/flooding.rb
 - lib/ocean/ocean_application_controller.rb