knife-azure 4.0.0 → 5.0.1

data/lib/azure/resource_management/rest/arm_client.rb

@@ -0,0 +1,208 @@
+#
+# Copyright:: Copyright (c) 2012-2026 Progress Software Corporation and/or its subsidiaries or affiliates. All Rights Reserved.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "erb" unless defined?(ERB::Util)
+require "uri" unless defined?(URI)
+require_relative "environments"
+require_relative "errors"
+require_relative "http"
+require_relative "rest_object"
+
+module Azure
+  class ResourceManagement
+    module Rest
+      # One method per ARM operation used by knife-azure, replacing the four
+      # retired azure_mgmt_* SDK clients. Responses are wrapped in RestObject so
+      # callers keep using SDK-style dot notation.
+      class ArmClient
+        RESOURCES_API_VERSION = "2025-04-01".freeze
+        COMPUTE_API_VERSION   = "2024-11-01".freeze
+        NETWORK_API_VERSION   = "2025-07-01".freeze
+
+        def initialize(subscription_id, http, environment = Environments.default)
+          @subscription_id = subscription_id
+          @http = http
+          @environment = environment
+        end
+
+        # ----- Resource groups / deployments (Microsoft.Resources) -----
+
+        def resource_group_exist?(resource_group_name)
+          @http.head(rg_url(resource_group_name, RESOURCES_API_VERSION))
+          true
+        rescue OperationError => e
+          return false if e.http_status == 404
+
+          raise
+        end
+
+        def create_resource_group(resource_group_name, location)
+          body = { "location" => location }
+          response = @http.put(rg_url(resource_group_name, RESOURCES_API_VERSION), body)
+          RestObject.wrap(response.body)
+        end
+
+        def delete_resource_group(resource_group_name)
+          @http.request_and_poll(:delete, rg_url(resource_group_name, RESOURCES_API_VERSION))
+          nil
+        end
+
+        def create_deployment(resource_group_name, deployment_name, deployment_body)
+          url = deployment_url(resource_group_name, deployment_name)
+          @http.request_and_poll(:put, url, deployment_body)
+          response = @http.get(url)
+          RestObject.wrap(response.body)
+        end
+
+        # ----- Virtual machines / extensions (Microsoft.Compute) -----
+
+        def list_all_virtual_machines
+          url = base_url("/providers/Microsoft.Compute/virtualMachines", COMPUTE_API_VERSION)
+          @http.get_all(url).map { |vm| RestObject.wrap(vm) }
+        end
+
+        def list_virtual_machines(resource_group_name)
+          url = base_url(
+            "/resourceGroups/#{e(resource_group_name)}/providers/Microsoft.Compute/virtualMachines",
+            COMPUTE_API_VERSION
+          )
+          @http.get_all(url).map { |vm| RestObject.wrap(vm) }
+        end
+
+        def get_virtual_machine(resource_group_name, vm_name)
+          response = @http.get(vm_url(resource_group_name, vm_name))
+          RestObject.wrap(response.body)
+        end
+
+        def get_availability_set(resource_group_name, availability_set_name)
+          url = base_url(
+            "/resourceGroups/#{e(resource_group_name)}/providers/Microsoft.Compute/availabilitySets/#{e(availability_set_name)}",
+            COMPUTE_API_VERSION
+          )
+          response = @http.get(url)
+          RestObject.wrap(response.body)
+        end
+
+        def delete_virtual_machine(resource_group_name, vm_name)
+          @http.request_and_poll(:delete, vm_url(resource_group_name, vm_name))
+          nil
+        end
+
+        def get_vm_extension(resource_group_name, vm_name, extension_name, expand: nil)
+          url = vm_extension_url(resource_group_name, vm_name, extension_name)
+          url += "&$expand=#{e(expand)}" if expand
+          response = @http.get(url)
+          RestObject.wrap(response.body)
+        end
+
+        def create_vm_extension(resource_group_name, vm_name, extension_name, extension_body)
+          url = vm_extension_url(resource_group_name, vm_name, extension_name)
+          # The async PUT resolves to an operation-status document, not the
+          # extension itself, so GET the resource once polling completes.
+          @http.request_and_poll(:put, url, extension_body)
+          response = @http.get(url)
+          RestObject.wrap(response.body)
+        end
+
+        def list_vm_extension_versions(location, publisher, type)
+          path = "/providers/Microsoft.Compute/locations/#{e(location)}/publishers/#{e(publisher)}" \
+                 "/artifacttypes/vmextension/types/#{e(type)}/versions"
+          # This endpoint returns a bare JSON array; get_all handles that shape
+          # as well as the paged { "value": ... } envelope.
+          @http.get_all(base_url(path, COMPUTE_API_VERSION)).map { |v| RestObject.wrap(v) }
+        end
+
+        # ----- Network (Microsoft.Network) -----
+
+        def get_network_interface(resource_group_name, name)
+          response = @http.get(network_url(resource_group_name, "networkInterfaces", name))
+          RestObject.wrap(response.body)
+        end
+
+        def get_public_ip_address(resource_group_name, name)
+          response = @http.get(network_url(resource_group_name, "publicIPAddresses", name))
+          RestObject.wrap(response.body)
+        end
+
+        def get_network_security_group(resource_group_name, name)
+          response = @http.get(network_url(resource_group_name, "networkSecurityGroups", name))
+          RestObject.wrap(response.body)
+        end
+
+        def get_virtual_network(resource_group_name, vnet_name)
+          response = @http.get(network_url(resource_group_name, "virtualNetworks", vnet_name))
+          RestObject.wrap(response.body)
+        end
+
+        def list_subnets(resource_group_name, vnet_name)
+          path = "/resourceGroups/#{e(resource_group_name)}/providers/Microsoft.Network" \
+                 "/virtualNetworks/#{e(vnet_name)}/subnets"
+          url = base_url(path, NETWORK_API_VERSION)
+          @http.get_all(url).map { |subnet| RestObject.wrap(subnet) }
+        end
+
+        private
+
+        def base_url(path, api_version)
+          "#{@environment.resource_manager_endpoint_url}/subscriptions/#{e(@subscription_id)}" \
+            "#{path}?api-version=#{api_version}"
+        end
+
+        def rg_url(resource_group_name, api_version)
+          base_url("/resourceGroups/#{e(resource_group_name)}", api_version)
+        end
+
+        def deployment_url(resource_group_name, deployment_name)
+          base_url(
+            "/resourceGroups/#{e(resource_group_name)}/providers/Microsoft.Resources/deployments/#{e(deployment_name)}",
+            RESOURCES_API_VERSION
+          )
+        end
+
+        def vm_url(resource_group_name, vm_name)
+          base_url(
+            "/resourceGroups/#{e(resource_group_name)}/providers/Microsoft.Compute/virtualMachines/#{e(vm_name)}",
+            COMPUTE_API_VERSION
+          )
+        end
+
+        def vm_extension_url(resource_group_name, vm_name, extension_name)
+          base_url(
+            "/resourceGroups/#{e(resource_group_name)}/providers/Microsoft.Compute/virtualMachines/" \
+              "#{e(vm_name)}/extensions/#{e(extension_name)}",
+            COMPUTE_API_VERSION
+          )
+        end
+
+        def network_url(resource_group_name, resource_type, name)
+          base_url(
+            "/resourceGroups/#{e(resource_group_name)}/providers/Microsoft.Network/#{resource_type}/#{e(name)}",
+            NETWORK_API_VERSION
+          )
+        end
+
+        # Percent-encode a value for use as a single URI *path* segment.
+        # URI.encode_www_form_component is for query strings (it turns spaces
+        # into "+"), which is wrong inside a path; ERB::Util.url_encode emits
+        # %20 and escapes "/" so a name can never break out of its segment.
+        def e(value)
+          ERB::Util.url_encode(value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/azure/resource_management/rest/environments.rb

@@ -0,0 +1,89 @@
+#
+# Copyright:: Copyright (c) 2012-2026 Progress Software Corporation and/or its subsidiaries or affiliates. All Rights Reserved.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Azure
+  class ResourceManagement
+    module Rest
+      # ARM + Azure AD endpoints per cloud. Public cloud is the default; the
+      # other clouds are provided for completeness and parity with the retired
+      # Azure SDK, which supported them too.
+      class Environments
+        ENVIRONMENTS = {
+          "AzureCloud" => {
+            resource_manager_endpoint_url: "https://management.azure.com",
+            active_directory_endpoint_url: "https://login.microsoftonline.com",
+            token_audience: "https://management.azure.com/",
+          },
+          "AzureUSGovernment" => {
+            resource_manager_endpoint_url: "https://management.usgovcloudapi.net",
+            active_directory_endpoint_url: "https://login.microsoftonline.us",
+            token_audience: "https://management.usgovcloudapi.net/",
+          },
+          "AzureChinaCloud" => {
+            resource_manager_endpoint_url: "https://management.chinacloudapi.cn",
+            active_directory_endpoint_url: "https://login.chinacloudapi.cn",
+            token_audience: "https://management.chinacloudapi.cn/",
+          },
+          "AzureGermanCloud" => {
+            resource_manager_endpoint_url: "https://management.microsoftazure.de",
+            active_directory_endpoint_url: "https://login.microsoftonline.de",
+            token_audience: "https://management.microsoftazure.de/",
+          },
+        }.freeze
+
+        DEFAULT_ENVIRONMENT = "AzureCloud".freeze
+
+        attr_reader :resource_manager_endpoint_url, :active_directory_endpoint_url, :token_audience
+
+        def initialize(name = DEFAULT_ENVIRONMENT)
+          config = ENVIRONMENTS[name] || ENVIRONMENTS[DEFAULT_ENVIRONMENT]
+          @resource_manager_endpoint_url = config[:resource_manager_endpoint_url]
+          @active_directory_endpoint_url = config[:active_directory_endpoint_url]
+          @token_audience = config[:token_audience]
+        end
+
+        def self.default
+          new(DEFAULT_ENVIRONMENT)
+        end
+
+        # Resolves a caller-supplied cloud name (e.g. "AzureUSGovernment") to an
+        # Environments instance, defaulting to the public cloud only when no
+        # value was given. An unrecognized name is rejected outright: silently
+        # falling back to the public cloud would otherwise post service-principal
+        # secrets and ARM requests to the wrong (public) endpoints whenever an
+        # operator intending a sovereign cloud makes a typo.
+        def self.from_name(name)
+          normalized = name.to_s.strip
+          return new(DEFAULT_ENVIRONMENT) if normalized.empty?
+
+          unless ENVIRONMENTS.key?(normalized)
+            raise ArgumentError,
+              "Unknown Azure environment '#{normalized}'. Valid values are: #{names.join(", ")}."
+          end
+
+          new(normalized)
+        end
+
+        # Names of the clouds this client understands, exposed so callers can
+        # validate a user-provided setting.
+        def self.names
+          ENVIRONMENTS.keys
+        end
+      end
+    end
+  end
+end

data/lib/azure/resource_management/rest/errors.rb

@@ -0,0 +1,57 @@
+#
+# Copyright:: Copyright (c) 2012-2026 Progress Software Corporation and/or its subsidiaries or affiliates. All Rights Reserved.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Azure
+  class ResourceManagement
+    module Rest
+      # Raised for network/transport failures and throttling (HTTP 429/5xx).
+      # These are considered retryable by the HTTP layer. When Azure supplies a
+      # Retry-After hint, it is carried here so the caller can honour it.
+      class TransientError < StandardError
+        attr_reader :retry_after
+
+        def initialize(message = nil, retry_after: nil)
+          @retry_after = retry_after
+          super(message)
+        end
+      end
+
+      # Raised when Azure Resource Manager returns an API error (HTTP 4xx, or a
+      # failed long-running operation). This is the direct replacement for the
+      # retired SDK's MsRestAzure2::AzureOperationError and preserves the same
+      # accessors that consuming code relied on: #body returns the raw response
+      # body string, and #response.body returns the same string.
+      class OperationError < StandardError
+        # Minimal stand-in for the SDK response object; only #body is consumed.
+        ResponseBody = Struct.new(:body)
+
+        attr_reader :body, :code, :http_status
+
+        def initialize(message, body: nil, code: nil, http_status: nil)
+          @body = body
+          @code = code
+          @http_status = http_status
+          super(message)
+        end
+
+        def response
+          ResponseBody.new(@body)
+        end
+      end
+    end
+  end
+end

data/lib/azure/resource_management/rest/http.rb

@@ -0,0 +1,335 @@
+#
+# Copyright:: Copyright (c) 2012-2026 Progress Software Corporation and/or its subsidiaries or affiliates. All Rights Reserved.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "net/http" unless defined?(Net::HTTP)
+require "uri" unless defined?(URI)
+require "json" unless defined?(JSON)
+require "time" unless defined?(Time.httpdate)
+require_relative "errors"
+require_relative "secure_connection"
+require_relative "environments"
+
+module Azure
+  class ResourceManagement
+    module Rest
+      # Thin Net::HTTP wrapper for talking to Azure Resource Manager. It:
+      #
+      #   * separates transient/transport failures (retried) from Azure API
+      #     errors (surfaced immediately as OperationError), instead of the
+      #     retired SDK's behaviour of retrying every failure five times;
+      #   * follows nextLink paging for list operations;
+      #   * polls long-running operations (LRO) to a terminal state.
+      class Http
+        # Simple value object for a completed HTTP response.
+        Response = Struct.new(:status, :headers, :body)
+
+        TRANSIENT_STATUS = [429, 500, 502, 503, 504].freeze
+        DEFAULT_MAX_RETRIES = 3
+        DEFAULT_RETRY_INTERVAL = 5 # seconds
+        # Hard caps so a stuck long-running operation cannot poll forever.
+        DEFAULT_LRO_TIMEOUT = 30 * 60 # seconds
+        DEFAULT_MAX_POLLS = 360
+
+        def initialize(token_provider, max_retries: DEFAULT_MAX_RETRIES, retry_interval: DEFAULT_RETRY_INTERVAL,
+                       lro_timeout: DEFAULT_LRO_TIMEOUT, max_polls: DEFAULT_MAX_POLLS,
+                       open_timeout: SecureConnection::DEFAULT_OPEN_TIMEOUT,
+                       read_timeout: SecureConnection::DEFAULT_READ_TIMEOUT,
+                       environment: Environments.default)
+          @token_provider = token_provider
+          @max_retries = max_retries
+          @retry_interval = retry_interval
+          @lro_timeout = lro_timeout
+          @max_polls = max_polls
+          @open_timeout = open_timeout
+          @read_timeout = read_timeout
+          # nextLink, Location and Azure-AsyncOperation URLs are followed from
+          # values Azure itself returns and are requested with the same bearer
+          # token as the original call. Pin them to the configured ARM host so
+          # a malformed/compromised follow-up URL can never exfiltrate the
+          # token to an unrelated HTTPS host.
+          @allowed_host = URI.parse(environment.resource_manager_endpoint_url).host
+        end
+
+        def get(url)
+          request(:get, url)
+        end
+
+        def head(url)
+          request(:head, url)
+        end
+
+        def put(url, body)
+          request(:put, url, body)
+        end
+
+        def post(url, body)
+          request(:post, url, body)
+        end
+
+        def delete(url)
+          request(:delete, url)
+        end
+
+        # Issues a GET and returns the full list of items. Handles both ARM
+        # list shapes: most endpoints return a paged { "value": [...],
+        # "nextLink": ... } envelope, but a few (e.g. VM extension image
+        # versions) return a bare JSON array. nextLink is followed for the
+        # paged shape.
+        def get_all(url)
+          items = []
+          next_url = url
+          until next_url.nil?
+            body = get(next_url).body
+            if body.is_a?(Array)
+              items.concat(body)
+              next_url = nil
+            else
+              body ||= {}
+              items.concat(Array(body["value"]))
+              next_url = body["nextLink"]
+            end
+          end
+          items
+        end
+
+        # Performs an LRO request (PUT/DELETE) and polls the async operation to
+        # completion. Returns the final resource body (for a PUT) or nil.
+        def request_and_poll(method, url, body = nil)
+          response = request(method, url, body)
+          poll_until_complete(response)
+        end
+
+        private
+
+        def request(method, url, body = nil)
+          attempts = 0
+          begin
+            do_request(method, url, body)
+          rescue TransientError => e
+            attempts += 1
+            raise if attempts > @max_retries
+
+            # Honour the server's Retry-After hint (throttling) when present.
+            sleep(e.retry_after || @retry_interval)
+            retry
+          end
+        end
+
+        def do_request(method, url, body)
+          uri = URI.parse(url)
+          validate_uri!(uri, url)
+
+          http = SecureConnection.build(uri, open_timeout: @open_timeout, read_timeout: @read_timeout)
+
+          request = build_request(method, uri, body)
+
+          begin
+            raw = http.request(request)
+          rescue Timeout::Error, SocketError, Errno::ECONNRESET, Errno::ECONNREFUSED, IOError => e
+            raise TransientError, "Transport error talking to Azure: #{e.message}"
+          end
+
+          handle_response(raw)
+        end
+
+        # ARM-supplied follow-up URLs (nextLink, Location, Azure-AsyncOperation)
+        # are requested with the same bearer token as the original call, so a
+        # malformed or compromised monitor URL must never be allowed to
+        # downgrade the connection to plaintext HTTP, nor redirect the token to
+        # a host outside the configured ARM cloud.
+        def validate_uri!(uri, url)
+          unless uri.scheme == "https"
+            raise ArgumentError, "Refusing to send an Azure request to a non-HTTPS URL: #{url}"
+          end
+
+          unless uri.host && uri.host.casecmp?(@allowed_host)
+            raise ArgumentError,
+              "Refusing to send an Azure request (with the bearer token) to untrusted host " \
+                "'#{uri.host}'; expected '#{@allowed_host}': #{url}"
+          end
+        end
+
+        def build_request(method, uri, body)
+          klass = {
+            get: Net::HTTP::Get,
+            head: Net::HTTP::Head,
+            put: Net::HTTP::Put,
+            post: Net::HTTP::Post,
+            delete: Net::HTTP::Delete,
+          }[method]
+
+          path = uri.path
+          path += "?#{uri.query}" if uri.query
+          request = klass.new(path)
+          request["Authorization"] = @token_provider.authorization_header
+          request["Content-Type"] = "application/json"
+          request["Accept"] = "application/json"
+          unless body.nil?
+            request.body = body.is_a?(String) ? body : JSON.generate(body)
+          end
+          request
+        end
+
+        def handle_response(raw)
+          status = raw.code.to_i
+          headers = normalize_headers(raw)
+          parsed = parse_body(raw.body)
+
+          if TRANSIENT_STATUS.include?(status)
+            raise TransientError.new(
+              "Azure returned a transient error (HTTP #{status}).",
+              retry_after: parse_retry_after(headers["retry-after"])
+            )
+          elsif status >= 400
+            raise OperationError.new(
+              error_message(parsed, status),
+              body: raw.body,
+              code: error_code(parsed),
+              http_status: status
+            )
+          end
+
+          Response.new(status, headers, parsed)
+        end
+
+        def parse_body(raw_body)
+          return nil if raw_body.nil? || raw_body.strip.empty?
+
+          JSON.parse(raw_body)
+        rescue JSON::ParserError
+          nil
+        end
+
+        def normalize_headers(raw)
+          headers = {}
+          raw.each_header { |k, v| headers[k.downcase] = v }
+          headers
+        end
+
+        # Azure Resource Manager errors are nested ({ "error": { "code",
+        # "message" } }); the AAD/OAuth token endpoint returns a flat shape
+        # ({ "error": "invalid_client", "error_description": "..." }). Both are
+        # handled here so a meaningful message/code is surfaced either way.
+        def error_code(parsed)
+          return nil unless parsed.is_a?(Hash)
+
+          err = parsed["error"]
+          err.is_a?(Hash) ? err["code"] : err
+        end
+
+        def error_message(parsed, status)
+          fallback = "Azure API error (HTTP #{status})."
+          return fallback unless parsed.is_a?(Hash)
+
+          err = parsed["error"]
+          if err.is_a?(Hash)
+            err["message"] || fallback
+          elsif err.is_a?(String)
+            parsed["error_description"] ? "#{err}: #{parsed["error_description"]}" : err
+          else
+            fallback
+          end
+        end
+
+        # Parse a Retry-After header value (delta-seconds or an HTTP-date) into
+        # a number of seconds, or nil when absent/unparseable.
+        def parse_retry_after(value)
+          return nil if value.nil? || value.to_s.strip.empty?
+
+          return value.to_i if value.to_s =~ /\A\d+\z/
+
+          begin
+            seconds = (Time.httpdate(value) - Time.now).round
+            seconds > 0 ? seconds : 0
+          rescue ArgumentError
+            nil
+          end
+        end
+
+        # Poll a long-running operation to a terminal state, honouring
+        # Retry-After. Azure exposes two distinct monitor styles that must be
+        # handled differently:
+        #
+        #   * Azure-AsyncOperation: a status monitor whose body carries a
+        #     "status" field ("InProgress"/"Succeeded"/"Failed"/"Canceled").
+        #     Terminal state comes from that field, not the HTTP code.
+        #   * Location: a resource monitor that returns 202 while the operation
+        #     is still running and a non-202 (200/204, often with no status
+        #     body) once it has completed. Terminal success is signalled by the
+        #     HTTP code, so a bodyless 200/204 here means "done", not "keep
+        #     polling". Azure-AsyncOperation takes precedence when both exist.
+        def poll_until_complete(response)
+          async_op_url = response.headers["azure-asyncoperation"]
+          location_url = response.headers["location"]
+          return response.body if async_op_url.nil? && location_url.nil?
+
+          deadline = Time.now + @lro_timeout
+          polls = 0
+          loop do
+            polls += 1
+            if polls > @max_polls || Time.now >= deadline
+              raise OperationError.new(
+                "Timed out waiting for the long-running operation to complete " \
+                  "(after #{polls - 1} polls / #{@lro_timeout}s).",
+                body: JSON.generate(response.body || {}),
+                code: "PollingTimeout",
+                http_status: response.status
+              )
+            end
+
+            sleep(retry_after(response))
+
+            if async_op_url
+              response = get(async_op_url)
+              state = provisioning_state(response.body)
+              case state
+              when "Succeeded"
+                return response.body
+              when "Failed", "Canceled"
+                raise OperationError.new(
+                  "Long-running operation ended in state '#{state}'.",
+                  body: JSON.generate(response.body || {}),
+                  code: state,
+                  http_status: response.status
+                )
+              end
+              async_op_url = response.headers["azure-asyncoperation"] || async_op_url
+              location_url = response.headers["location"] || location_url
+            else
+              response = get(location_url)
+              # Any non-202 response on a Location monitor is terminal success,
+              # even when there is no status body.
+              return response.body if response.status != 202
+
+              location_url = response.headers["location"] || location_url
+            end
+          end
+        end
+
+        def provisioning_state(body)
+          return nil unless body.is_a?(Hash)
+
+          body["status"] || (body["properties"] && body["properties"]["provisioningState"])
+        end
+
+        def retry_after(response)
+          parse_retry_after(response.headers && response.headers["retry-after"]) || @retry_interval
+        end
+      end
+    end
+  end
+end