haipa_rest 0.11.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ff597bbe79f2fab568de046de5378015b60b2b756f3ed2b4111786b21f4af208
+  data.tar.gz: f2958344b3891002fdd3241707e8995218e9ede792292c0fe4762c4b6e5396e3
+SHA512:
+  metadata.gz: d73c9bf85d5082dce938a67e4f0a0eda038e6d57f0496eb7bdaec71c29a4b3e9797d116e1ff9f95ed6301594bc1cb854d55cf379bbde9a27cb022e78b251825e
+  data.tar.gz: aff4f952f9b3678647e1e56c360dc210646237e86dc40a3cf855cff951aedcbbc9da174efa7c86c3b0c17bb0be3946930bcb08bc8098c965f831062a435168b2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 dbosoft GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# Intro
+
+haipa_rest is a library which supports the Haipa clients generated with Autorest tool. It contains core logic and helper classes for error handling and authentication. 
+Usually it is not supposed to be used as a standalone gem but only as a dependency for generated client gems.
+
+This project has been forked from the Microsoft Azure ruby client (https://github.com/Azure/azure-sdk-for-ruby)
+
+# Supported Ruby Versions
+
+* Ruby 2.0
+* Ruby 2.1
+* Ruby 2.2
+
+Note: x64 Ruby for Windows is known to have some compatibility issues.
+
+# Installation
+
+install the appropriate gem:
+
+```
+gem install haipa_rest
+```
+
+and reference it in your code:
+
+```Ruby
+require 'haipa_rest'
+```
+
+# Running tests
+
+haipa_rest has only unit tests which doesn't require any preparation, just run 'rspec' command from the gem directory.
+
+# Contribution
+
+To start working on the gem the only additional dev dependecy is required - rspec. After you've added a new feature and all specs pass - you're good to go with PR. But before starting any bug/feature - please make sure you've thoroughly discussed it with repository maintainers. This gem already powers a few SDKs and backward compatibility should taken in account.
+
+# Adding gem to you generated SDK
+
+Reference it in the gemfile and also add this line to your client's gemspec file:
+
+```ruby
+spec.add_runtime_dependency 'haipa_rest', '~> 0.11.1'
+```
+Don't forget to correct the version.
+
+

data/lib/haipa_rest.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+require 'ms_rest'
+require 'haipa_rest/async_operation_status.rb'
+require 'haipa_rest/Haipa_operation_error.rb'
+require 'haipa_rest/Haipa_operation_response.rb'
+require 'haipa_rest/Haipa_service_client.rb'
+require 'haipa_rest/cloud_error_data.rb'
+require 'haipa_rest/final_state_via.rb'
+require 'haipa_rest/credentials/application_token_provider.rb'
+require 'haipa_rest/polling_state.rb'
+require 'haipa_rest/serialization.rb'
+require 'haipa_rest/typed_error_info.rb' 
+require 'haipa_rest/version'
+require 'haipa_rest/common/configurable'
+require 'haipa_rest/common/default'
+
+module Haipa end
+module Haipa::Client end
+module Haipa::Client::Serialization end
+module Haipa::Client::Common end
+module Haipa::Client::Common::Configurable end
+module Haipa::Client::Common::Default end

data/lib/haipa_rest/async_operation_status.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+module Haipa::Client
+  #
+  # Defines values for AsyncOperationStatus enum.
+  #
+  class AsyncOperationStatus
+    ACCEPTED = 'Accepted'
+    IN_PROGRESS_STATUS = 'InProgress'
+    RUNNING = 'Running'
+    SUCCESS_STATUS = 'Succeeded'
+    FAILED_STATUS = 'Failed'
+    CANCELED_STATUS = 'Canceled'
+
+    ALL_STATUSES = [ACCEPTED, FAILED_STATUS, CANCELED_STATUS, SUCCESS_STATUS, IN_PROGRESS_STATUS, RUNNING]
+    FAILED_STATUSES = [FAILED_STATUS, CANCELED_STATUS]
+    TERMINAL_STATUSES = [FAILED_STATUS, CANCELED_STATUS, SUCCESS_STATUS]
+
+    DEFAULT_DELAY = 30
+
+    # @return [Integer] delay in seconds which should be used for polling for result of async operation.
+    attr_accessor :retry_after
+
+    # @return [Haipa::Client::CloudErrorData] error information about async operation.
+    attr_accessor :error
+
+    # @return [Stirng] status of polling.
+    attr_accessor :status
+
+    #
+    # Checks if given status is terminal one.
+    # @param status [String] status to verify
+    #
+    # @return [Boolean] True if given status is terminal one, false otherwise.
+    def self.is_terminal_status(status)
+      TERMINAL_STATUSES.any? { |st| st.casecmp(status) == 0 }
+    end
+
+    #
+    # Checks if given status is failed one.
+    # @param status [String] status to verify
+    #
+    # @return [Boolean] True if given status is failed one, false otherwise.
+    def self.is_failed_status(status)
+      FAILED_STATUSES.any? { |st| st.casecmp(status) == 0 }
+    end
+
+    #
+    # Checks if given status is successful one.
+    # @param status [String] status to verify
+    #
+    # @return [Boolean] True if given status is successful one, false otherwise.
+    def self.is_successful_status(status)
+      return (status.casecmp(SUCCESS_STATUS) == 0)
+    end
+
+    #
+    # Deserializes given hash into AsyncOperationStatus object.
+    # @param object [Hash] object to deserialize.
+    #
+    # @return [AsyncOperationStatus] deserialized object.
+    def self.deserialize_object(object)
+      return if object.nil?
+      output_object = AsyncOperationStatus.new
+
+      output_object.status = object['status']
+
+      output_object.error = CloudErrorData.deserialize_object(object['error'])
+
+      output_object.retry_after = Integer(object['retryAfter']) unless object['retryAfter'].nil?
+
+      output_object
+    end
+  end
+
+end

data/lib/haipa_rest/cloud_error_data.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+module Haipa::Client
+  #
+  # Class which represents keeps aux data about Haipa invalid response.
+  #
+  class CloudErrorData
+
+    # @return [String] the error code parsed from the body of the http error response.
+    attr_accessor :code
+
+    # @return [String] the error message parsed from the body of the http error response.
+    attr_accessor :message
+
+    # @return [String] the error target parsed from the body of the http error response.
+    attr_accessor :target
+
+    # @return [Array<TypedErrorInfo>] the list of additional error info parsed from the body of the http error response.
+    attr_accessor :additionalInfo
+
+    #
+    # Deserializes given hash into CloudErrorData object.
+    # @param object [Hash] object to deserialize.
+    #
+    # @return [CloudErrorData] deserialized object.
+    def self.deserialize_object(object)
+      return if object.nil?
+      output_object = CloudErrorData.new
+
+      output_object.code = object['code']
+
+      output_object.message = object['message']
+
+      output_object.target = object['target']
+
+      unless object['additionalInfo'].nil?
+        output_object.additionalInfo = []
+        object['additionalInfo'].each do |info|
+          output_object.additionalInfo << Haipa::Client::TypedErrorInfo.deserialize_object(info)
+        end
+      end
+
+      output_object
+    end
+  end
+end

data/lib/haipa_rest/common/configurable.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+require 'openssl'
+
+module Haipa::Client::Common
+  # The Haipa::Common::Configurable module provides basic configuration for Haipa activities.
+  module Configurable
+
+    # @return [MsRest::ServiceClientCredentials] credentials to authorize HTTP requests made by the service client.
+    attr_accessor :credentials
+
+    # @return [String] client id.
+    attr_accessor :client_id
+
+    # @return [String] path to client key file
+    attr_accessor :client_key_file
+
+    # @return [String] client key
+    attr_accessor :client_key
+
+    # @return [String] url to identity endpoint.
+    attr_accessor :identity_endpoint
+
+    class << self
+      #
+      # List of configurable keys for {Haipa::Client::Common::Client}.
+      # @return [Array] of option keys.
+      #
+      def keys
+        @keys ||= [:client_id, :client_key_file, :identity_endpoint ]
+      end
+    end
+
+    #
+    # Set configuration options using a block.
+    #
+    def configure
+      yield self
+    end
+
+    #
+    # Resets the configurable options to provided options or defaults.
+    # This will also creates MsRest::TokenCredentials to be used for subsequent clients.
+    #
+    def reset!(options = {})
+      Haipa::Client::Common::Configurable.keys.each do |key|
+        default_value = Haipa::Client::Common::Default.options[key]
+        instance_variable_set(:"@#{key}", options.fetch(key, default_value))
+      end
+
+      if(options[:client_key].nil?)
+        # The user has not passed in the client key. try to read it from client_key_file
+        self.client_key = OpenSSL::PKey::RSA.new File.read self.client_key_file unless self.client_key_file.nil?       
+      end
+
+      if(options[:credentials].nil?)
+        # The user has not passed in the credentials. So, the api has to
+        # build the credentials itself.
+        fail ArgumentError, 'client_id is nil' if self.client_id.nil?
+        fail ArgumentError, 'client_key is nil' if self.client_key.nil?
+        fail ArgumentError, 'identity_endpoint is nil' if self.identity_endpoint.nil?
+
+        self.credentials = MsRest::TokenCredentials.new(
+            Haipa::Client::ApplicationTokenProvider.new(
+                self.client_id, self.client_key, self.identity_endpoint))
+      else
+        self.credentials = options[:credentials]
+      end
+
+      self
+    end
+
+    def config
+      self
+    end
+
+    private
+
+    #
+    # configures configurable options to default values
+    #
+    def setup_default_options
+      opts = {}
+      Haipa::Client::Common::Configurable.keys.map do |key|
+        opts[key] = Haipa::Client::Common::Default.options[key]
+      end
+
+      opts
+    end
+  end
+end

data/lib/haipa_rest/common/default.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+module Haipa::Client::Common
+  module Default
+    class << self
+
+      #
+      # Default Haipa Client Id.
+      # @return [String] Haipa Client Id.
+      #
+      def client_id
+        ENV['HAIPA_CLIENT_ID']
+      end
+
+      #
+      # Default Haipa Client Secret.
+      # @return [String] Haipa Client Secret.
+      #
+      def client_key_file
+        ENV['HAIPA_CLIENT_KEY_FILE']
+      end
+
+      #
+      # Default Haipa identity endpoint.
+      # @return [String] Haipa identiy endpoint
+      #
+      def identity_endpoint
+        ENV['HAIPA_IDENTITY_ENDPOINT']
+      end
+
+      #
+      # Configuration options.
+      # @return [Hash] Configuration options.
+      #
+      def options
+        Hash[Haipa::Client::Common::Configurable.keys.map { |key| [key, send(key)]}]
+      end
+    end
+  end
+end

data/lib/haipa_rest/credentials/application_token_provider.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+require 'jwt'
+
+module Haipa::Client
+  #
+  # Class that provides access to authentication token.
+  #
+  class ApplicationTokenProvider < MsRest::TokenProvider
+
+    private
+
+    TOKEN_ACQUIRE_URL = '{identity_endpoint}/connect/token'
+    DEFAULT_SCHEME = 'Bearer'
+
+    # @return [String] client id.
+    attr_accessor :client_id
+
+    # @return [String] client key
+    attr_accessor :client_key
+
+    # @return [String] url to identity endpoint.
+    attr_accessor :identity_endpoint
+
+    # @return [String] auth token.
+    attr_accessor :token
+
+    # @return [Time] the date when the current token expires.
+    attr_accessor :token_expires_on
+
+    # @return [Integer] the amount of time we refresh token before it expires.
+    attr_reader :expiration_threshold
+
+    # @return [String] the type of token.
+    attr_reader :token_type
+
+    public
+
+    #
+    # Creates and initialize new instance of the ApplicationTokenProvider class.
+    # @param client_id [String] client id.
+    # @param client_key [String] client key.
+    # @param identity_endpoint [String] url of identity endpoint.
+    # @param ca_file [String] path to additional ca file.
+    def initialize(client_id, client_key, identity_endpoint)
+      fail ArgumentError, 'Client id cannot be nil' if client_id.nil?
+      fail ArgumentError, 'Client key cannot be nil' if client_key.nil?
+      fail ArgumentError, 'Identity_endpoint url cannot be nil' if identity_endpoint.nil?
+
+      @client_id = client_id
+      @client_key = client_key
+      @identity_endpoint = identity_endpoint
+
+      @expiration_threshold = 5 * 60
+    end
+
+    #
+    # Returns the string value which needs to be attached
+    # to HTTP request header in order to be authorized.
+    #
+    # @return [String] authentication headers.
+    def get_authentication_header
+      acquire_token if token_expired
+      "#{token_type} #{token}"
+    end
+
+    private
+
+    #
+    # Checks whether token is about to expire.
+    #
+    # @return [Bool] True if token is about to expire, false otherwise.
+    def token_expired
+      @token.nil? || Time.now >= @token_expires_on + expiration_threshold
+    end
+
+    #
+    # Retrieves a new authentication token.
+    #
+    # @return [String] new authentication token.
+    def acquire_token
+      token_acquire_url = TOKEN_ACQUIRE_URL.dup
+      token_acquire_url['{identity_endpoint}'] = @identity_endpoint
+
+      url = URI.parse(token_acquire_url)
+
+      connection = Faraday.new(:url => url, :ssl => MsRest.ssl_options)
+      exp = Time.now.to_i + @expiration_threshold
+
+      payload = { iss: client_id,
+        aud: token_acquire_url,
+        sub: @client_id,
+        exp: exp
+      }
+
+      signed_payload = JWT.encode payload, client_key, 'RS256'
+
+      response = connection.post url.path, { 
+        :grant_type => 'client_credentials',
+        :client_id => client_id,
+        :client_assertion_type => 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',
+        :client_assertion => signed_payload,
+        :scope => 'compute_api' }
+      
+      fail HaipaOperationError,
+        'Couldn\'t login to Haipa, please verify your client id and client key' unless response.status == 200
+
+      response_body = JSON.load(response.body)
+      @token = response_body['access_token']
+      @token_expires_on = Time.now + Integer(response_body['expires_in'])
+      @token_type = response_body['token_type']
+      
+    end
+  end
+
+end

data/lib/haipa_rest/final_state_via.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+module Haipa::Client
+  #
+  # Class which represents a final state via of Haipa long running operation.
+  #
+  class FinalStateVia
+    NONE = -1
+    DEFAULT = 0
+    ASYNC_OPERATION = 0
+    LOCATION = 1
+    ORIGINAL_URI = 2
+  end
+end

data/lib/haipa_rest/haipa_cli_error.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+module Haipa::Client
+  #
+  # Class which represents an error with the Haipa CLI.
+  #
+  class HaipaCliError < StandardError
+
+  end
+end

data/lib/haipa_rest/haipa_operation_error.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+module Haipa::Client
+  #
+  # Class which represents an Haipa error.
+  #
+  class HaipaOperationError < MsRest::HttpOperationError
+
+    # @return [String] the error message.
+    attr_accessor :error_message
+
+    # @return [String] the error code.
+    attr_accessor :error_code
+
+    #
+    # Creates and initialize new instance of the HaipaOperationError class.
+    # @param [Hash] the HTTP request data (uri, body, headers).
+    # @param [Faraday::Response] the HTTP response object.
+    # @param [String] body the HTTP response body.
+    # @param [String] error message.
+    #
+    def initialize(*args)
+      super(*args)
+
+      # Try to parse @body to find useful error message and code
+      # Body should meet the error condition response requirements for Microsoft REST API Guidelines
+      # https://github.com/Microsoft/api-guidelines/blob/master/Guidelines.md#7102-error-condition-responses
+      begin
+        unless @body.nil?
+          @error_message = @body['error']['message']
+          @error_code = @body['error']['code']
+          @msg = "#{@msg}: #{@error_code}: #{@error_message}"
+        end
+      rescue
+      end
+    end
+  end
+end

data/lib/haipa_rest/haipa_operation_response.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+module Haipa::Client
+  #
+  # Class which represents the data received and deserialized from Haipa service.
+  #
+  class HaipaOperationResponse < MsRest::HttpOperationResponse
+
+    # @return [String] identificator of the request.
+    attr_accessor :request_id
+
+    # @return [String] Correlation Id of the request.
+    attr_accessor :correlation_request_id
+
+    # @return [String] Client Request Id of the request.
+    attr_accessor :client_request_id
+  end
+end

data/lib/haipa_rest/haipa_service_client.rb

@@ -0,0 +1,304 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+module Haipa::Client
+  #
+  # Class which represents a point of access to the REST API.
+  #
+  class HaipaServiceClient < MsRest::ServiceClient
+
+    # @return [Integer] execution interval for long running operations.
+    attr_accessor :long_running_operation_retry_timeout
+
+    # @return [String] api version of the Haipa service in string format.
+    attr_accessor :api_version
+
+    def initialize(credentials, options = nil)
+      super(credentials, options)
+      # This is the current default for Haipa services, and content-type
+      # and accept supported by Autorest
+      @request_headers =  {
+          'Content-Type' => 'application/json;charset=utf-8',
+          'Accept' => 'application/json'
+      }
+      add_user_agent_information("haipa_rest/#{Haipa::Client::REST_VERSION}")
+      add_user_agent_information("Haipa client for Ruby")
+    end
+
+    #
+    # Retrieves the result of 'POST','DELETE','PUT' or 'PATCH' operation. Performs polling of required.
+    # @param haipa_response [Haipa::Client::HaipaOperationResponse] response from Haipa service.
+    # @param custom_deserialization_block [Proc] custom logic for response deserialization.
+    # @param final_state_via [Haipa::Client::FinalStateVia] Final State via value
+    #
+    # @return [MsRest::HttpOperationResponse] the response.
+    #
+    def get_long_running_operation_result(haipa_response, custom_deserialization_block, final_state_via = FinalStateVia::DEFAULT)
+      check_for_status_code_failure(haipa_response)
+
+      http_method = haipa_response.request.method
+
+      polling_state = PollingState.new(haipa_response, @long_running_operation_retry_timeout)
+      request = haipa_response.request
+
+      if !AsyncOperationStatus.is_terminal_status(polling_state.status)
+        task = Concurrent::TimerTask.new do
+          begin
+            if !polling_state.Haipa_async_operation_header_link.nil?
+              update_state_from_Haipa_async_operation_header(polling_state.get_request(headers: request.headers, base_uri: request.base_uri, user_agent_extended: user_agent_extended), polling_state)
+            elsif !polling_state.location_header_link.nil?
+              update_state_from_location_header(polling_state.get_request(headers: request.headers, base_uri: request.base_uri, user_agent_extended: user_agent_extended), polling_state, custom_deserialization_block, final_state_via)
+            elsif http_method === :put
+              get_request = MsRest::HttpOperationRequest.new(request.base_uri, request.build_path.to_s, :get, {query_params: request.query_params, headers: request.headers, user_agent_extended: user_agent_extended})
+              update_state_from_get_resource_operation(get_request, polling_state, custom_deserialization_block)
+            else
+              task.shutdown
+              if final_state_via == FinalStateVia::LOCATION
+                if !polling_state.response.body.to_s.empty?
+                  body = JSON.load(polling_state.response.body)
+                  polling_state.resource = custom_deserialization_block.call(body)
+                else
+                  fail HaipaOperationError, 'Location header is missing from long running operation'
+                end
+              else
+                fail HaipaOperationError, 'Location header is missing from long running operation'
+              end
+            end
+
+            if AsyncOperationStatus.is_terminal_status(polling_state.status)
+              task.shutdown
+            end
+          rescue Exception => e
+            task.shutdown
+            e
+          end
+        end
+
+        polling_delay = polling_state.get_delay
+        polling_delay = 0.1 if polling_delay.nil? || polling_delay == 0
+
+        task.execution_interval = polling_delay
+        task.execute
+        task.wait_for_termination
+
+        polling_error = task.value
+        fail polling_error if polling_error.is_a?(Exception)
+      end
+
+      if AsyncOperationStatus.is_successful_status(polling_state.status)
+        # Process long-running PUT/PATCH
+        if (http_method === :put || http_method === :patch) && polling_state.resource.nil?
+          get_request = MsRest::HttpOperationRequest.new(request.base_uri, request.build_path.to_s, :get, {query_params: request.query_params, headers: request.headers})
+          update_state_from_get_resource_operation(get_request, polling_state, custom_deserialization_block)
+        end
+
+        if final_state_via == FinalStateVia::LOCATION
+          if((http_method === :post || http_method === :delete) && !polling_state.location_header_link.nil?)
+            update_state_from_location_header(polling_state.get_request(headers: request.headers, base_uri: request.base_uri, user_agent_extended: user_agent_extended), polling_state, custom_deserialization_block, final_state_via)
+          end
+        end
+
+        # Process long-running POST/DELETE operation with schema defined on success status codes
+        if (http_method === :post || http_method === :delete) && custom_deserialization_block && polling_state.response
+          unless polling_state.response.body.to_s.empty?
+            body = JSON.load(polling_state.response.body)
+            polling_state.resource = custom_deserialization_block.call(body)
+          end
+        end
+      end
+
+      if AsyncOperationStatus.is_failed_status(polling_state.status)
+        fail polling_state.get_operation_error
+      end
+
+      polling_state.get_operation_response
+    end
+
+    #
+    # Verifies for unexpected polling status code
+    # @param haipa_response [Haipa::Client::HaipaOperationResponse] response from Haipa service.
+    #
+    def check_for_status_code_failure(haipa_response)
+      fail MsRest::ValidationError, 'Haipa response cannot be nil' if haipa_response.nil?
+      fail MsRest::ValidationError, 'Haipa response cannot have empty response object' if haipa_response.response.nil?
+      fail MsRest::ValidationError, 'Haipa response cannot have empty request object' if haipa_response.request.nil?
+
+      status_code = haipa_response.response.status
+      http_method = haipa_response.request.method
+
+      fail HaipaOperationError, "Unexpected polling status code from long running operation #{status_code}" unless status_code === 200 || status_code === 202 ||
+          (status_code === 201 && http_method === :put) ||
+          (status_code === 204 && (http_method === :delete || http_method === :post))
+    end
+
+    #
+    # Updates polling state based on location header for PUT HTTP requests.
+    # @param request [MsRest::HttpOperationRequest] The url retrieve data from.
+    # @param polling_state [Haipa::Client::PollingState] polling state to update.
+    # @param custom_deserialization_block [Proc] custom deserialization method for parsing response.
+    #
+    def update_state_from_get_resource_operation(request, polling_state, custom_deserialization_block)
+      result = get_async_with_custom_deserialization(request, custom_deserialization_block)
+
+      fail HaipaOperationError, 'The response from long running operation does not contain a body' if result.response.body.nil? || result.response.body.empty?
+
+      # On non flattened resource, we should find provisioning_state inside 'properties'
+      if result.body.respond_to?(:properties) && result.body.properties.respond_to?(:provisioning_state) && !result.body.properties.provisioning_state.nil?
+        polling_state.status = result.body.properties.provisioning_state
+      # On flattened resource, we should find provisioning_state at the top level
+      elsif result.body.respond_to?(:provisioning_state) && !result.body.provisioning_state.nil?
+        polling_state.status = result.body.provisioning_state
+      else
+        polling_state.status = AsyncOperationStatus::SUCCESS_STATUS
+      end
+
+      error_data = CloudErrorData.new
+      error_data.code = polling_state.status
+      error_data.message = "Long running operation failed with status #{polling_state.status}"
+
+      polling_state.error_data = error_data
+      polling_state.update_response(result.response)
+      polling_state.request = result.request
+      polling_state.resource = result.body
+    end
+
+    #
+    # Updates polling state based on location header for HTTP requests.
+    # @param request [MsRest::HttpOperationRequest] The url retrieve data from.
+    # @param polling_state [Haipa::Client::PollingState] polling state to update.
+    # @param custom_deserialization_block [Proc] custom deserialization method for parsing response.
+    # @param final_state_via [Haipa::Client::FinalStateVia] Final State via value
+    #
+    def update_state_from_location_header(request, polling_state, custom_deserialization_block, final_state_via = FinalStateVia::DEFAULT)
+      result = get_async_with_custom_deserialization(request, custom_deserialization_block)
+
+      polling_state.update_response(result.response)
+      polling_state.request = result.request
+      status_code = result.response.status
+      http_method = request.method
+
+      if status_code === 202
+        polling_state.status = AsyncOperationStatus::IN_PROGRESS_STATUS
+      elsif status_code === 200 || (status_code === 201 && http_method === :put) ||
+          (status_code === 204 && (http_method === :delete || http_method === :post || http_method === :get))
+        polling_state.status = AsyncOperationStatus::SUCCESS_STATUS
+
+        error_data = CloudErrorData.new
+        error_data.code = polling_state.status
+        error_data.message = "Long running operation failed with status #{polling_state.status}"
+
+        polling_state.error_data = error_data
+        polling_state.resource = result.body
+      elsif final_state_via == FinalStateVia::LOCATION && status_code === 404 && http_method === :delete && !polling_state.Haipa_async_operation_header_link.nil? && !polling_state.location_header_link.nil?
+        polling_state.status = AsyncOperationStatus::SUCCESS_STATUS
+      else
+        fail HaipaOperationError, "The response from long running operation does not have a valid status code. Method: #{http_method}, Status Code: #{status_code}"
+      end
+    end
+
+    #
+    # Updates polling state from Haipa async operation header.
+    # @param polling_state [Haipa::Client::PollingState] polling state.
+    #
+    def update_state_from_Haipa_async_operation_header(request, polling_state)
+      result = get_async_with_async_operation_deserialization(request)
+
+      fail HaipaOperationError, 'The response from long running operation does not contain a body' if result.body.nil? || result.body.status.nil?
+
+      polling_state.status = result.body.status
+      polling_state.error_data = result.body.error
+      polling_state.response = result.response
+      polling_state.request = result.request
+      polling_state.resource = nil
+
+      polling_state
+    end
+
+    #
+    # Retrieves data by given URL.
+    # @param request [MsRest::HttpOperationRequest] the URL.
+    # @param custom_deserialization_block [Proc] function to perform deserialization of the HTTP response.
+    #
+    # @return [MsRest::HttpOperationResponse] the response.
+    #
+    def get_async_with_custom_deserialization(request, custom_deserialization_block)
+      result = get_async_common(request)
+
+      if !result.body.nil? && !custom_deserialization_block.nil?
+        begin
+          result.body = custom_deserialization_block.call(result.body)
+        rescue Exception => e
+          fail MsRest::DeserializationError.new("Error occured in deserializing the response", e.message, e.backtrace, http_response.body)
+        end
+      end
+
+      result
+    end
+
+    #
+    # Retrieves data by given URL.
+    # @param request [MsRest::HttpOperationRequest] the URL.
+    #
+    # @return [MsRest::HttpOperationResponse] the response.
+    #
+    def get_async_with_async_operation_deserialization(request)
+      result = get_async_common(request)
+
+      result.body = AsyncOperationStatus.deserialize_object(result.body)
+
+      result
+    end
+
+    #
+    # Retrieves data by given URL.
+    # @param request [MsRest::HttpOperationRequest] the URL.
+    #
+    # @return [MsRest::HttpOperationResponse] the response.
+    #
+    def get_async_common(request)
+      fail ValidationError, 'Request cannot be nil' if request.nil?
+
+      request.middlewares = [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]]
+      request.headers.merge!({'x-ms-client-request-id' => SecureRandom.uuid}) unless request.headers.key?('x-ms-client-request-id')
+      request.headers.merge!({'Content-Type' => 'application/json'}) unless request.headers.key?('Content-Type')
+
+      # Send Request
+      http_response = request.run_promise do |req|
+        @credentials.sign_request(req) unless @credentials.nil?
+      end.execute.value!
+
+      status_code = http_response.status
+
+      if status_code != 200 && status_code != 201 && status_code != 202 && status_code != 204
+        json_error_data = JSON.load(http_response.body)
+        error_data = CloudErrorData.deserialize_object(json_error_data)
+
+        fail HaipaOperationError.new request, http_response, error_data, "Long running operation failed with status #{status_code}"
+      end
+
+      result = MsRest::HttpOperationResponse.new(request, http_response, http_response.body)
+
+      begin
+        result.body = JSON.load(http_response.body) unless http_response.body.to_s.empty?
+      rescue Exception => e
+        fail MsRest::DeserializationError.new("Error occured in deserializing the response", e.message, e.backtrace, result)
+      end
+
+      result
+    end
+
+    private
+      #
+      # Retrieves a new instance of the HaipaOperationResponse class.
+      # @param [MsRest::HttpOperationRequest] request the HTTP request object.
+      # @param [Faraday::Response] response the HTTP response object.
+      # @param [String] body the HTTP response body.
+      # @return [Haipa::Client::HaipaOperationResponse] the operation response.
+      #
+      def create_response(request, http_response, body = nil)
+        HaipaOperationResponse.new(request, http_response, body)
+      end
+  end
+
+end

data/lib/haipa_rest/polling_state.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+module Haipa::Client
+  #
+  # Class which represents a state of Haipa long running operation.
+  #
+  class PollingState
+
+    # @return [Net::HTTPRequest] the HTTP request.
+  	attr_accessor :request
+
+    # @return the resource
+  	attr_accessor :resource
+
+    # @return [Net::HTTPResponse] the HTTP response.
+    attr_accessor :response
+
+    # @return [HaipaOperationError] the Haipa error data.
+    attr_accessor :error_data
+
+    # @return [String] the latest value captured from Haipa-AsyncOperation header.
+    attr_accessor :Haipa_async_operation_header_link
+
+    # @return [String] the latest value captured from Location header.
+    attr_accessor :location_header_link
+
+    # @return [String] status of the long running operation.
+    attr_accessor :status
+
+    def initialize(haipa_response, retry_timeout)
+      @retry_timeout = retry_timeout
+      @request = haipa_response.request
+      update_response(haipa_response.response)
+      @resource = haipa_response.body
+
+      case @response.status
+        when 200
+          provisioning_state = get_provisioning_state
+          @status = provisioning_state.nil?? (AsyncOperationStatus::SUCCESS_STATUS):provisioning_state
+        when 201
+          provisioning_state = get_provisioning_state
+          @status = provisioning_state.nil?? (AsyncOperationStatus::IN_PROGRESS_STATUS):provisioning_state
+        when 202
+          @status = AsyncOperationStatus::IN_PROGRESS_STATUS
+        when 204
+          @status = AsyncOperationStatus::SUCCESS_STATUS
+        else
+          @status = AsyncOperationStatus::FAILED_STATUS
+      end
+    end
+
+    #
+    # Returns the provisioning status of the resource
+    #
+    # @return [String] provisioning status of the resource
+    def get_provisioning_state
+      # On non flattened resource, we should find provisioning_state inside 'properties'
+      if (!@resource.nil? && @resource.respond_to?(:properties) && @resource.properties.respond_to?(:provisioning_state) && !@resource.properties.provisioning_state.nil?)
+        @resource.properties.provisioning_state
+        # On flattened resource, we should find provisioning_state at the top level
+      elsif !@resource.nil? && @resource.respond_to?(:provisioning_state) && !@resource.provisioning_state.nil?
+        @resource.provisioning_state
+      else
+        nil
+      end
+    end
+
+    #
+    # Returns the amount of time in seconds for long running operation polling delay.
+    #
+    # @return [Integer] Amount of time in seconds for long running operation polling delay.
+    def get_delay
+      return @retry_timeout unless @retry_timeout.nil?
+
+      if !response.nil? && !response.headers['Retry-After'].nil?
+        return response.headers['Retry-After'].to_i
+      end
+
+      return AsyncOperationStatus::DEFAULT_DELAY
+    end
+
+    #
+    # Updates the polling state from the fields of given response object.
+    # @param response [Net::HTTPResponse] the HTTP response.
+    def update_response(response)
+      @response = response
+
+      unless response.nil?
+        @Haipa_async_operation_header_link = response.headers['Haipa-AsyncOperation'] unless response.headers['Haipa-AsyncOperation'].nil?
+        @location_header_link = response.headers['Location'] unless response.headers['Location'].nil?
+      end
+    end
+
+    #
+    # returns the Haipa's response.
+    #
+    # @return [Haipa::Client::HaipaOperationResponse] Haipa's response.
+    def get_operation_response
+      haipa_response = HaipaOperationResponse.new(@request, @response, @resource)
+      haipa_response
+    end
+
+    #
+    # Composes and returns cloud error.
+    #
+    # @return [HaipaOperationError] the cloud error.
+    def get_operation_error
+      HaipaOperationError.new @request, @response, @error_data, "Long running operation failed with status #{@status}"
+    end
+    
+    def get_request(options = {})
+      link = @Haipa_async_operation_header_link || @location_header_link
+      options[:connection] = create_connection(options[:base_uri])
+      MsRest::HttpOperationRequest.new(nil, link, :get, options)
+    end
+
+    private
+
+    # @return [Integer] retry timeout.
+    attr_accessor :retry_timeout
+
+    attr_accessor :connection
+
+    def create_connection(base_url)
+      @connection ||= Faraday.new(:url => base_url, :ssl => MsRest.ssl_options) do |faraday|
+        [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]].each{ |args| faraday.use(*args) }
+        faraday.adapter Faraday.default_adapter
+        faraday.headers = request.headers
+        logging = ENV['HAIPA_HTTP_LOGGING'] || request.log
+        if logging
+          faraday.response :logger, nil, { :bodies => logging == 'full' }
+        end
+      end
+    end
+  end
+
+end

data/lib/haipa_rest/serialization.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+module Haipa::Client
+  # Base module for Haipa Ruby serialization and deserialization.
+  #
+  # Provides methods to serialize Ruby object into Ruby Hash and
+  # to deserialize Ruby Hash into Ruby object.
+  module Serialization
+    include MsRest::Serialization
+
+    private
+
+    #
+    # Builds serializer
+    #
+    def build_serializer
+      Serialization.new(self)
+    end
+
+    #
+    # Class to handle serialization & deserialization.
+    #
+    class Serialization < MsRest::Serialization::Serialization
+
+      #
+      # Retrieves model of the model_name
+      #
+      # @param model_name [String] Name of the model to retrieve.
+      #
+      def get_model(model_name)
+        begin
+          Object.const_get(@context.class.to_s.split('::')[0...-1].join('::') + "::Models::#{model_name}")
+        rescue NameError
+          # Look into Haipa::Client namespace if model name not found in the models namespace
+          Object.const_get("Haipa::Client::#{model_name}")
+        end
+      end
+
+    end
+  end
+end

data/lib/haipa_rest/typed_error_info.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+module Haipa::Client
+  #
+  # Class which represents the error type and information.
+  #
+  class TypedErrorInfo
+
+    # @return [String] the error type parsed from the body of the http error response.
+    attr_accessor :type
+
+    # @return [Object] the error info parsed from the body of the http error response.
+    attr_accessor :info
+
+    #
+    # Deserializes given hash into TypedErrorInfo object.
+    # @param object [Hash] object to deserialize.
+    #
+    # @return [TypedErrorInfo] deserialized object.
+    def self.deserialize_object(object)
+      return if object.nil?
+      output_object = TypedErrorInfo.new
+
+      output_object.type = object['type']
+
+      output_object.info = object['info']
+
+      output_object
+    end
+  end
+end

data/lib/haipa_rest/version.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+# Copyright (c) dbosoft GmbH and Haipa Contributors. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+
+module Haipa end
+module Haipa::Client
+  REST_VERSION = '0.11.1'
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: haipa_rest
+version: !ruby/object:Gem::Version
+  version: 0.11.1
+platform: ruby
+authors:
+- Haipa Contributors
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: unf_ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.7.2
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: ms_rest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.4
+description: Haipa Client Library for Ruby.
+email: package-maintainers@haipa.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/haipa_rest.rb
+- lib/haipa_rest/async_operation_status.rb
+- lib/haipa_rest/cloud_error_data.rb
+- lib/haipa_rest/common/configurable.rb
+- lib/haipa_rest/common/default.rb
+- lib/haipa_rest/credentials/application_token_provider.rb
+- lib/haipa_rest/final_state_via.rb
+- lib/haipa_rest/haipa_cli_error.rb
+- lib/haipa_rest/haipa_operation_error.rb
+- lib/haipa_rest/haipa_operation_response.rb
+- lib/haipa_rest/haipa_service_client.rb
+- lib/haipa_rest/polling_state.rb
+- lib/haipa_rest/serialization.rb
+- lib/haipa_rest/typed_error_info.rb
+- lib/haipa_rest/version.rb
+homepage: https://github.com/haipa/ruby-client
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/haipa/haipa/issues
+  documentation_uri: https://github.com/haipa/ruby-client
+  homepage_uri: https://github.com/haipa/ruby-client
+  source_code_uri: https://github.com/haipa/ruby-client
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Haipa Client Library for Ruby.
+test_files: []