runapi-core 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba473ca16c3bf3642549224cc1e8e2ace81c302f91a767afc10b06b93cde95ce
-  data.tar.gz: a01ba0a52c124fd881b45705ce8a7580e9b429ca776842693bc1ad262cf85804
+  metadata.gz: ea78f8bdda7cd96b63e4bdac55eac74d6c06bb4b4db80ab0cf98905309fd911c
+  data.tar.gz: d78ae1407c76cc538503619385d19862fcc6277fa5f3cbfc8afd637794bd1df5
 SHA512:
-  metadata.gz: 908a114d22a7113898f4ec49595c40b2f414c02c4c528dba774b3262a871a429627d2337b6516a1923ae25662b38ee3f1352a9b30b31900d0d91e4ab5ad1863c
-  data.tar.gz: 36a9539bb562174708f6d94354b2e4f2c4fe742773665d8603b8c77ff6ed6019e9c1c848ba0decf970e6cd96bec50def79d398057dc748a4bd8bc7ee97511d60
+  metadata.gz: 6d08554a3bbe9e1019c94c2faa1f70af23be53681d025590adde44836c77c4b6a05ec7ea6666307ceb287c281195fb73009f2f33064943c750d993cd9fd20bf8
+  data.tar.gz: 2b99533c6b2c4991066b752d9cff43730939173eb1a0df17639fe90b8c602670b1c22dcb5aeb1350dd59b466558ac67b253219facb8e5e567da2d6c0d80c2e35

data/lib/runapi/core/http_client.rb

@@ -13,7 +13,10 @@ module RunApi
       end
 
       def request(method, path, body: nil, options: nil, raw: false)
-        uri = URI.join(@options.base_url, path)
+        uri = URI.parse(path)
+        uri = URI.join(@options.base_url, path) unless uri.absolute?
+        raise ValidationError, "Request URL must use the configured RunAPI origin" unless base_origin?(uri)
+
         req = build_request(method, uri, body, options)
         max_retries = options&.max_retries || @options.max_retries
         retries = 0
@@ -21,10 +24,7 @@ module RunApi
 
         loop do
           response = begin
-            @pool.with do |http|
-              http.start unless http.started?
-              http.request(req)
-            end
+            perform_request(uri, req)
           rescue *STALE_CONNECTION_ERRORS
             unless stale_retried
               stale_retried = true
@@ -44,16 +44,16 @@ module RunApi
           if response.is_a?(Net::HTTPSuccess)
             return response.body if raw
 
-            body = parse_body(response.body)
+            body = parse_body(response.body, response["content-type"])
             return nil if body.nil?
             return body unless body.is_a?(Hash) || body.is_a?(Array)
 
-            return Response.new(body:, headers: response_headers(response))
+            return Response.new(body:, headers: response_headers(response), status: response.code.to_i)
           end
 
           error = Error.from_response(response, response.body)
 
-          if retryable?(method, response.code.to_i) && retries < max_retries
+          if retryable?(method, response.code.to_i, req) && retries < max_retries
             retries += 1
             sleep(retry_delay(retries, error))
             stale_retried = false
@@ -100,6 +100,10 @@ module RunApi
 
       def build_connection
         uri = URI.parse(@options.base_url)
+        build_connection_for(uri)
+      end
+
+      def build_connection_for(uri)
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = (uri.scheme == "https")
         http.verify_mode = OpenSSL::SSL::VERIFY_PEER
@@ -108,6 +112,22 @@ module RunApi
         http
       end
 
+      def perform_request(uri, request)
+        if base_origin?(uri)
+          return @pool.with do |http|
+            http.start unless http.started?
+            http.request(request)
+          end
+        end
+
+        build_connection_for(uri).start { |http| http.request(request) }
+      end
+
+      def base_origin?(uri)
+        base_uri = URI.parse(@options.base_url)
+        uri.scheme == base_uri.scheme && uri.host == base_uri.host && uri.port == base_uri.port
+      end
+
       def build_request(method, uri, body, options)
         klass = Net::HTTP.const_get(method.to_s.capitalize)
         req = klass.new(uri.request_uri)
@@ -154,11 +174,15 @@ module RunApi
         end
       end
 
-      def retryable?(method, status)
-        Constants::IDEMPOTENT_METHODS.include?(method.to_s.upcase) &&
+      def retryable?(method, status, request)
+        retryable_request?(method, request) &&
           Constants::RETRYABLE_STATUS_CODES.include?(status)
       end
 
+      def retryable_request?(method, request)
+        Constants::IDEMPOTENT_METHODS.include?(method.to_s.upcase) || request["Idempotency-Key"].to_s != ""
+      end
+
       def retry_delay(attempt, error)
         if error.is_a?(RateLimitError) && error.retry_after&.positive?
           return error.retry_after
@@ -169,8 +193,9 @@ module RunApi
         [base + jitter, @options.retry_max_delay].min
       end
 
-      def parse_body(body)
+      def parse_body(body, content_type = nil)
         return nil if body.nil? || body.empty?
+        return body if content_type && !content_type.downcase.include?("json")
 
         JSON.parse(body)
       rescue JSON::ParserError

data/lib/runapi/core/hybrid_lifecycle.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module RunApi
+  module Core
+    module HybridLifecycle
+      StoredHttpResponse = Struct.new(:status, :headers) do
+        def code = status.to_s
+        def [](name) = headers[name]
+        def each_header(&block) = headers.each(&block)
+      end
+
+      private
+
+      def run_hybrid(path, body:, options:, response_class: default_response_class)
+        terminal = nil
+        subscribe_hybrid(path, body:, options:, response_class:).each { |result| terminal = result }
+        terminal
+      end
+
+      def subscribe_hybrid(path, body:, options:, response_class: default_response_class)
+        options = hybrid_request_options(options)
+        Enumerator.new do |subscriber|
+          response = raw_request(:post, path, body:, options:)
+          unless response.status == 202
+            terminal = decode_hybrid_response(response, response_class)
+            subscriber << terminal
+            next terminal
+          end
+
+          location = response.response_headers["Location"]
+          raise Core::TaskFailedError, "Accepted task response is missing Location" if location.to_s.empty?
+
+          poll_hybrid_task(location, options:, response_class:, subscriber:)
+        end
+      end
+
+      def raw_request(method, path, body: :__runapi_no_body__, options: nil)
+        response = if body == :__runapi_no_body__
+          options ? @http.request(method, path, options:) : @http.request(method, path)
+        else
+          kwargs = {body: body}
+          kwargs[:options] = options if options
+          @http.request(method, path, **kwargs)
+        end
+
+        return response if response.is_a?(Core::Response)
+
+        Core::Response.new(body: response, status: 200)
+      end
+
+      def hybrid_request_options(options)
+        headers = options&.headers&.dup || {}
+        return options if headers.keys.any? { |key| key.to_s.casecmp?("Idempotency-Key") }
+
+        headers["Idempotency-Key"] = SecureRandom.uuid
+        Core::RequestOptions.new(
+          headers:,
+          timeout: options&.timeout,
+          max_retries: options&.max_retries,
+          allow_not_modified: options&.allow_not_modified
+        )
+      end
+
+      def poll_hybrid_task(location, options:, response_class:, subscriber:)
+        loop do
+          response = raw_request(:get, location, options:)
+          payload = response.body
+          status = hybrid_task_status(payload)
+
+          if status == "completed"
+            terminal = decode_hybrid_response(stored_hybrid_response(payload, response), response_class)
+            subscriber << terminal
+            break terminal
+          end
+          raise stored_hybrid_error(payload, response) if status == "failed"
+
+          unless Core::Polling::ACTIVE_STATUSES.include?(status)
+            raise_task_failed(payload, response, "Unknown task status: #{status}")
+          end
+
+          subscriber << decode_processing_response(response)
+          sleep retry_after(response)
+        end
+      end
+
+      def hybrid_task_status(payload)
+        case payload
+        when Core::BaseModel
+          payload.status.to_s.downcase
+        when Hash
+          (payload["status"] || payload[:status]).to_s.downcase
+        else
+          ""
+        end
+      end
+
+      def decode_processing_response(response)
+        result = Core::BaseModel.coerce(response.body, as: Core::TaskResponse)
+        attach_response_headers(result, response.response_headers)
+        result
+      end
+
+      def decode_hybrid_response(response, response_class)
+        return response.body unless json_response?(response)
+
+        result = Core::BaseModel.coerce(response.body, as: response_class)
+        attach_response_headers(result, response.response_headers)
+        result
+      end
+
+      def stored_hybrid_response(payload, polling_response)
+        envelope = payload.is_a?(Core::BaseModel) ? payload.to_h : payload
+        stored = envelope.is_a?(Hash) ? (envelope["response"] || envelope[:response]) : nil
+        unless stored.is_a?(Hash)
+          raise_task_failed(payload, polling_response, "Terminal Task Result is missing response")
+        end
+
+        status = stored["status"] || stored[:status]
+        content_type = stored["content_type"] || stored[:content_type]
+        unless status.is_a?(Integer) && content_type.is_a?(String) && !content_type.empty?
+          raise_task_failed(payload, polling_response, "Terminal Task Result response is invalid")
+        end
+
+        headers = (stored["headers"] || stored[:headers] || {}).to_h
+        headers = headers.merge("Content-Type" => content_type)
+        Core::Response.new(body: stored.key?("body") ? stored["body"] : stored[:body], headers:, status:)
+      end
+
+      def stored_hybrid_error(payload, polling_response)
+        response = stored_hybrid_response(payload, polling_response)
+        serialized_body = response.body.is_a?(String) ? response.body : JSON.generate(response.body)
+        Core::Error.from_response(StoredHttpResponse.new(response.status, response.response_headers), serialized_body)
+      end
+
+      def json_response?(response)
+        response.response_headers["Content-Type"].to_s.downcase.include?("json") || response.body.is_a?(Hash) || response.body.is_a?(Array)
+      end
+
+      def retry_after(response)
+        value = Float(response.response_headers["Retry-After"], exception: false)
+        value&.positive? ? value : 0
+      end
+
+      def raise_task_failed(payload, response, message = nil)
+        raise Core::TaskFailedError.new(
+          message || hybrid_task_error(payload) || "Task failed",
+          details: payload,
+          response_headers: response.response_headers
+        )
+      end
+
+      def hybrid_task_error(payload)
+        case payload
+        when Core::BaseModel
+          payload.error
+        when Hash
+          payload["error"] || payload[:error]
+        end
+      end
+
+      def attach_response_headers(result, headers)
+        case result
+        when Core::BaseModel
+          result.with_response_headers(headers)
+        when Array
+          result.each { |item| attach_response_headers(item, headers) }
+        end
+      end
+    end
+  end
+end

data/lib/runapi/core/resource_helpers.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
+require "securerandom"
+require_relative "hybrid_lifecycle"
+
 module RunApi
   module Core
     module ResourceHelpers
+      include HybridLifecycle
+
       private
 
       # Performs an HTTP request and coerces JSON responses into typed model objects.
@@ -274,15 +279,6 @@ module RunApi
         completed.with_response_headers(response.response_headers) if response.is_a?(Core::BaseModel)
         completed
       end
-
-      def attach_response_headers(result, headers)
-        case result
-        when Core::BaseModel
-          result.with_response_headers(headers)
-        when Array
-          result.each { |item| attach_response_headers(item, headers) }
-        end
-      end
     end
   end
 end

data/lib/runapi/core/response.rb

@@ -42,12 +42,13 @@ module RunApi
     end
 
     class Response < Hash
-      attr_reader :response_headers
+      attr_reader :response_headers, :status
 
-      def initialize(body:, headers: nil)
+      def initialize(body:, headers: nil, status: nil)
         super()
         @body = body unless body.is_a?(Hash)
         @response_headers = headers.is_a?(ResponseHeaders) ? headers : ResponseHeaders.new(headers)
+        @status = status
         update(body) if body.is_a?(Hash)
       end
 

data/lib/runapi/core/version.rb

@@ -2,7 +2,7 @@
 
 module RunApi
   module Core
-    VERSION = "0.4.1"
+    VERSION = "0.5.0"
   end
 
   VERSION = Core::VERSION

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: runapi-core
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - RunAPI
@@ -53,6 +53,7 @@ files:
 - lib/runapi/core/errors.rb
 - lib/runapi/core/files.rb
 - lib/runapi/core/http_client.rb
+- lib/runapi/core/hybrid_lifecycle.rb
 - lib/runapi/core/multipart_body.rb
 - lib/runapi/core/polling.rb
 - lib/runapi/core/pricing.rb