eryph-compute 0.1.1

data/lib/eryph/compute/operation_tracker.rb

@@ -0,0 +1,247 @@
+require 'set'
+
+module Eryph
+  module Compute
+    # Advanced operation tracker with fluent callback registration
+    # Provides more control over operation tracking than the basic wait_for_operation
+    class OperationTracker
+      attr_reader :operation_id, :client
+
+      def initialize(client, operation_id)
+        @client = client
+        @operation_id = operation_id
+        @processed_log_ids = Set.new
+        @processed_task_ids = Set.new
+        @processed_resource_ids = Set.new
+        @last_timestamp = Time.parse('2018-01-01')
+        @callbacks = {}
+        @raw_json = nil
+      end
+
+      # Register callback for new log entries
+      # @yield [log_entry] callback for each new log entry
+      # @return [self] for method chaining
+      def on_log_entry(&block)
+        @callbacks[:log_entry] = block
+        self
+      end
+
+      # Register callback for new tasks
+      # @yield [task] callback for each new task discovered
+      # @return [self] for method chaining
+      def on_task_new(&block)
+        @callbacks[:task_new] = block
+        self
+      end
+
+      # Register callback for task updates (status/progress changes)
+      # @yield [task] callback for each task update
+      # @return [self] for method chaining
+      def on_task_update(&block)
+        @callbacks[:task_update] = block
+        self
+      end
+
+      # Register callback for new resources
+      # @yield [resource] callback for each new resource discovered
+      # @return [self] for method chaining
+      def on_resource_new(&block)
+        @callbacks[:resource_new] = block
+        self
+      end
+
+      # Register callback for status changes
+      # @yield [operation] callback for each status update
+      # @return [self] for method chaining
+      def on_status_change(&block)
+        @callbacks[:status_change] = block
+        self
+      end
+
+      # Single poll to check current state without blocking
+      # @return [Operation] the current operation state
+      def poll
+        # Get raw JSON using debug_return_type (same approach as Client)
+        begin
+          @raw_json = @client.operations.operations_get(
+            @operation_id,
+            expand: 'logs,tasks,resources',
+            log_time_stamp: @last_timestamp,
+            debug_return_type: 'String'
+          )
+          @client.logger.debug "Raw JSON captured: #{@raw_json ? 'YES' : 'NO'}"
+        rescue StandardError => e
+          @client.logger.debug "Failed to capture raw JSON: #{e.message}"
+        end
+
+        # Get the normal deserialized operation
+        operation = @client.operations.operations_get(
+          @operation_id,
+          expand: 'logs,tasks,resources',
+          log_time_stamp: @last_timestamp
+        )
+
+        process_updates(operation)
+        operation
+      end
+
+      # Track operation until completion with polling
+      # @param timeout [Integer] timeout in seconds (default: 300)
+      # @param poll_interval [Integer] polling interval in seconds (default: 5)
+      # @return [OperationResult] the completed operation result
+      # @raise [Timeout::Error] if the operation times out
+      def track_to_completion(timeout: 300, poll_interval: 5)
+        start_time = Time.now
+
+        @client.logger.info "Tracking operation #{@operation_id} to completion (timeout: #{timeout}s)..."
+
+        loop do
+          operation = poll
+
+          if operation.status == 'Completed'
+            @client.logger.info "Operation #{@operation_id} completed successfully!"
+            @client.logger.info "Raw JSON available: #{@raw_json ? 'YES' : 'NO'}"
+            @client.logger.info "Raw JSON length: #{@raw_json ? @raw_json.length : 'N/A'}"
+            return OperationResult.new(operation, @client, @raw_json)
+          elsif operation.status == 'Failed'
+            @client.logger.error "Operation #{@operation_id} failed: #{operation.status_message}"
+            @client.logger.info "Raw JSON available: #{@raw_json ? 'YES' : 'NO'}"
+            return OperationResult.new(operation, @client, @raw_json)
+          end
+
+          elapsed = Time.now - start_time
+          if elapsed > timeout
+            @client.logger.error "Operation #{@operation_id} timed out after #{timeout} seconds"
+            raise Timeout::Error, "Operation #{@operation_id} timed out after #{timeout} seconds"
+          end
+
+          @client.logger.debug "Operation #{@operation_id} status: #{operation.status} (#{elapsed.round(1)}s elapsed)"
+          sleep poll_interval
+        end
+      end
+
+      # Track with a single callback function (like wait_for_operation)
+      # @param timeout [Integer] timeout in seconds
+      # @param poll_interval [Integer] polling interval in seconds
+      # @yield [event_type, data] callback for operation events
+      # @return [OperationResult] the completed operation result
+      def track(timeout: 300, poll_interval: 5)
+        if block_given?
+          # Set up temporary callback
+          original_callbacks = @callbacks.dup
+
+          @callbacks[:log_entry] = ->(data) { yield(:log_entry, data) }
+          @callbacks[:task_new] = ->(data) { yield(:task_new, data) }
+          @callbacks[:task_update] = ->(data) { yield(:task_update, data) }
+          @callbacks[:resource_new] = ->(data) { yield(:resource_new, data) }
+          @callbacks[:status_change] = ->(data) { yield(:status, data) }
+
+          begin
+            result = track_to_completion(timeout: timeout, poll_interval: poll_interval)
+          ensure
+            # Restore original callbacks
+            @callbacks = original_callbacks
+          end
+
+          result
+        else
+          track_to_completion(timeout: timeout, poll_interval: poll_interval)
+        end
+      end
+
+      # Get current operation state without updating tracking state
+      # @return [Operation] the current operation
+      def current_state
+        @client.operations.operations_get(@operation_id)
+      end
+
+      # Reset tracking state (clears processed IDs and timestamp)
+      # @return [self] for method chaining
+      def reset_state
+        @processed_log_ids.clear
+        @processed_task_ids.clear
+        @processed_resource_ids.clear
+        @last_timestamp = Time.parse('2018-01-01')
+        self
+      end
+
+      # Get statistics about what has been processed so far
+      # @return [Hash] statistics hash
+      def stats
+        {
+          operation_id: @operation_id,
+          processed_logs: @processed_log_ids.size,
+          processed_tasks: @processed_task_ids.size,
+          processed_resources: @processed_resource_ids.size,
+          last_timestamp: @last_timestamp,
+        }
+      end
+
+      # String representation
+      def to_s
+        "#<OperationTracker operation_id=#{@operation_id} stats=#{stats}>"
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      # Process updates from a polled operation
+      # @param operation [Operation] the operation to process
+      def process_updates(operation)
+        # Process new logs
+        operation.log_entries&.each do |log_entry|
+          next if @processed_log_ids.include?(log_entry.id)
+
+          @processed_log_ids.add(log_entry.id)
+          @last_timestamp = log_entry.timestamp if log_entry.timestamp > @last_timestamp
+
+          begin
+            @callbacks[:log_entry]&.call(log_entry)
+          rescue StandardError => e
+            @client.logger.error "Error in log_entry callback: #{e.message}"
+          end
+        end
+
+        # Process new and updated tasks
+        operation.tasks&.each do |task|
+          if @processed_task_ids.include?(task.id)
+            begin
+              @callbacks[:task_update]&.call(task)
+            rescue StandardError => e
+              @client.logger.error "Error in task_update callback: #{e.message}"
+            end
+          else
+            @processed_task_ids.add(task.id)
+            begin
+              @callbacks[:task_new]&.call(task)
+            rescue StandardError => e
+              @client.logger.error "Error in task_new callback: #{e.message}"
+            end
+          end
+        end
+
+        # Process new resources
+        operation.resources&.each do |resource|
+          next if @processed_resource_ids.include?(resource.id)
+
+          @processed_resource_ids.add(resource.id)
+          begin
+            @callbacks[:resource_new]&.call(resource)
+          rescue StandardError => e
+            @client.logger.error "Error in resource_new callback: #{e.message}"
+          end
+        end
+
+        # Status update
+        begin
+          @callbacks[:status_change]&.call(operation)
+        rescue StandardError => e
+          @client.logger.error "Error in status_change callback: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/eryph/compute/problem_details_error.rb

@@ -0,0 +1,139 @@
+require 'json'
+
+module Eryph
+  module Compute
+    # Exception class for API errors that include ProblemDetails in the response
+    # Extends StandardError with parsed problem details information
+    class ProblemDetailsError < StandardError
+      attr_reader :problem_details, :problem_type, :title, :detail, :instance, :problem_status, :code,
+                  :response_headers, :response_body
+
+      # Create a new ProblemDetailsError
+      # @param api_error [Object] the original API error (could be ComputeClient::ApiError or similar)
+      # @param problem_details [Object, Hash] the parsed problem details
+      def initialize(api_error, problem_details = nil)
+        # Extract basic error information
+        @code = api_error.respond_to?(:code) ? api_error.code : nil
+        @response_headers = api_error.respond_to?(:response_headers) ? api_error.response_headers : nil
+        @response_body = api_error.respond_to?(:response_body) ? api_error.response_body : nil
+
+        # Initialize with the original error's message or a default
+        original_message = api_error.respond_to?(:message) ? api_error.message : api_error.to_s
+        super(original_message)
+
+        @problem_details = problem_details
+
+        return unless problem_details
+
+        if problem_details.respond_to?(:type)
+          # ComputeClient::ProblemDetails object
+          @problem_type = problem_details.type
+          @title = problem_details.title
+          @detail = problem_details.detail
+          @instance = problem_details.instance
+          @problem_status = problem_details.status
+        elsif problem_details.is_a?(Hash)
+          # Hash representation
+          @problem_type = problem_details[:type] || problem_details['type']
+          @title = problem_details[:title] || problem_details['title']
+          @detail = problem_details[:detail] || problem_details['detail']
+          @instance = problem_details[:instance] || problem_details['instance']
+          @problem_status = problem_details[:status] || problem_details['status']
+        end
+      end
+
+      # Create a ProblemDetailsError from an ApiError by parsing the response body
+      # @param api_error [Object] the original API error
+      # @return [ProblemDetailsError, Object] parsed error or original if not parseable
+      def self.from_api_error(api_error)
+        response_body = api_error.respond_to?(:response_body) ? api_error.response_body : nil
+        problem_details = parse_problem_details(response_body)
+
+        if problem_details
+          new(api_error, problem_details)
+        else
+          api_error
+        end
+      end
+
+      # Parse ProblemDetails from a response body
+      # @param response_body [String] the HTTP response body
+      # @return [Object, Hash, nil] parsed problem details or nil if not parseable
+      def self.parse_problem_details(response_body)
+        return nil if response_body.nil? || response_body.empty?
+
+        begin
+          json_data = JSON.parse(response_body)
+
+          # Check if it looks like a problem details response
+          if json_data.is_a?(Hash) && (json_data.key?('type') || json_data.key?('title'))
+            # Try to create a proper ProblemDetails object if the class is available
+            begin
+              if defined?(ComputeClient::ProblemDetails)
+                ComputeClient::ProblemDetails.build_from_hash(json_data)
+              else
+                # Fall back to hash representation if class not available
+                json_data
+              end
+            rescue StandardError
+              # Fall back to hash representation if object creation fails
+              json_data
+            end
+          end
+        rescue JSON::ParserError
+          nil
+        end
+      end
+
+      # Check if this error has problem details information
+      # @return [Boolean] true if problem details are available
+      def problem_details?
+        !@problem_details.nil?
+      end
+
+      # Get a user-friendly error message
+      # @return [String] formatted error message
+      def friendly_message
+        if problem_details?
+          parts = []
+          parts << @title if @title && !@title.empty?
+          parts << @detail if @detail && !@detail.empty?
+
+          if parts.empty?
+            "API Error: #{@problem_type || 'Unknown error'}"
+          else
+            parts.join(': ')
+          end
+        else
+          super.message
+        end
+      end
+
+      # Override message to provide better error information
+      def message
+        if problem_details?
+          msg = friendly_message
+          msg += "\nProblem Type: #{@problem_type}" if @problem_type
+          msg += "\nInstance: #{@instance}" if @instance
+          msg += "\nHTTP Status: #{code}" if code
+          msg
+        else
+          super
+        end
+      end
+
+      # String representation
+      def to_s
+        friendly_message
+      end
+
+      def inspect
+        if problem_details?
+          "#<ProblemDetailsError problem_type=#{@problem_type.inspect} title=#{@title.inspect} status=#{code}>"
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/eryph/compute/version.rb

@@ -0,0 +1,6 @@
+module Eryph
+  module Compute
+    # Current version of the Eryph Compute Client
+    VERSION = '1.0.0'.freeze
+  end
+end

data/lib/eryph/compute.rb

@@ -0,0 +1,40 @@
+# Eryph Compute Client
+# High-level client for the Eryph Compute API
+
+require_relative 'compute/version'
+require_relative 'compute/operation_result'
+require_relative 'compute/operation_tracker'
+require_relative 'compute/problem_details_error'
+require_relative 'compute/client'
+
+module Eryph
+  # Compute API client module
+  module Compute
+    # Error raised when compute API operations fail
+    class ComputeError < StandardError; end
+
+    # Error raised when API responses are invalid
+    class ApiError < ComputeError
+      # @return [Integer] HTTP response code
+      attr_reader :code
+
+      # @return [String] response body
+      attr_reader :response_body
+
+      # @return [Hash] response headers
+      attr_reader :response_headers
+
+      # Initialize API error
+      # @param message [String] error message
+      # @param code [Integer] HTTP response code
+      # @param response_body [String] response body
+      # @param response_headers [Hash] response headers
+      def initialize(message, code: nil, response_body: nil, response_headers: nil)
+        super(message)
+        @code = code
+        @response_body = response_body
+        @response_headers = response_headers
+      end
+    end
+  end
+end

data/lib/eryph/version.rb

@@ -0,0 +1,4 @@
+module Eryph
+  # Current version of the Eryph Ruby Compute Client
+  VERSION = '0.1.1'.freeze
+end

data/lib/eryph.rb

@@ -0,0 +1,68 @@
+# Eryph Ruby Compute Client
+# Main entry point for the Eryph compute client library
+
+require_relative 'eryph/version'
+require_relative 'eryph/clientruntime'
+require_relative 'eryph/compute'
+
+# Only load generated client if dependencies are available
+begin
+  require_relative 'eryph/compute/generated'
+rescue LoadError => e
+  # Generated client dependencies not available, API clients will fall back to placeholder mode
+  warn "Warning: Generated compute client not available (#{e.message}). Run generate.ps1 to create the API client."
+end
+
+module Eryph
+  class << self
+    # Create compute client with automatic or specific credential discovery
+    # @param config_name [String, nil] configuration name for specific config, nil for automatic discovery
+    # @param client_id [String, nil] specific client ID to use
+    # @param options [Hash] additional options
+    # @option options [Logger] :logger logger instance
+    # @option options [Array<String>] :scopes OAuth2 scopes
+    # @option options [Hash] :ssl_config SSL configuration options
+    # @option options [Environment] :environment environment for dependency injection
+    # @return [Compute::Client] a new compute client instance
+    # @example Automatic discovery
+    #   client = Eryph.compute_client
+    # @example Specific configuration
+    #   client = Eryph.compute_client('zero')
+    # @example Specific client ID
+    #   client = Eryph.compute_client('myconfig', client_id: 'my-client-id')
+    # @example With options
+    #   client = Eryph.compute_client(logger: my_logger, ssl_config: { verify_ssl: false })
+    def compute_client(config_name = nil, client_id: nil, **options)
+      Compute::Client.new(
+        config_name,
+        client_id: client_id,
+        logger: options[:logger],
+        scopes: options[:scopes],
+        ssl_config: options[:ssl_config] || {},
+        environment: options[:environment]
+      )
+    end
+
+    # Test if credentials are available for the specified configuration
+    # @param config_name [String, nil] configuration name, nil for automatic discovery
+    # @return [Boolean] true if credentials are available
+    # @example
+    #   Eryph.credentials_available?           # automatic discovery
+    #   Eryph.credentials_available?('zero')   # specific config
+    def credentials_available?(config_name = nil)
+      ClientRuntime.credentials_available?(config_name: config_name)
+    end
+
+    # Check if eryph-zero is running locally
+    # @return [Boolean] true if eryph-zero is running
+    def zero_running?
+      ClientRuntime.zero_running?
+    end
+
+    # Get endpoints from running eryph-zero instance
+    # @return [Hash] endpoint name -> URL mapping
+    def zero_endpoints
+      ClientRuntime.zero_endpoints
+    end
+  end
+end