azure-armrest 0.3.7 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d9f6d582f68c38666f0904db56732b7cdad8f90
-  data.tar.gz: e4f320a935c370248d70f24b8365b68fcee4f4eb
+  metadata.gz: cfe77ac7705382e48afa5deeab108cefa90d07ae
+  data.tar.gz: a6c7a2ab379f076af861fb21fcc674a573aee67e
 SHA512:
-  metadata.gz: 77434cab50f1c0834bf422a5b66f48d9ed9a641ac29ffbac671d83100e0c65b6a94fc0ad13efa6d802d29532c5133a90b4d080b55efcb01389bc3bc1603faa76
-  data.tar.gz: c2807304de56ded6362984e23c899fd92c6c59315261ebf33aa11d75df27c6082e8f0c57a47559823333d0de1da3150b6d56c9e10793b01a69c38666a93fc85d
+  metadata.gz: 97bfb012ae0a449c8c95ed107c68e5849dfcb5359a2e7a7d9a566bc12b4406722fa0c88e6678cf8834b0abdba81fbd07804d628ff4025a12940f0428d788e2e4
+  data.tar.gz: ebb632b5bfcf35007a99d6e46f0f65a85dea6fc0796d998d0b6c6620db01a6f99dc82795767db3c4792b226f07d6a81d539d0c53bc42f037d430057e2712e7e4

data/CHANGES

@@ -1,3 +1,17 @@
+= 0.3.8 - 7-Oct-2-16
+* Added more robust exception wrapping, now mostly based on http error code.
+* Refactored the internal fetch_providers method so that it uses our own
+  service class method call, which is cached.
+* Added the TemplateDeploymentService#get_template method.
+* The :list and :list_all methods in the ResourceGroupBasedService class now
+  automatically perform pagination.
+* Replaced our custom inspect with the one provided by pretty_print.
+* Added the :response_code and :response_headers accessors to the BaseModel
+  class. All individual objects and collections now set these.
+* Modified our :poll method to check the :response_code, and to try the
+  :location attribute if :azure_asyncoperation isn't found.
+* Updated the :create documentation for the StorageAccountService class.
+
 = 0.3.7 - 15-Sep-2016
 * Modified the private image listing code in the StorageAccountService class
   to skip over storage accounts when we cannot get a key.

data/lib/azure/armrest.rb

@@ -3,6 +3,7 @@ require 'json'
 require 'thread'
 require 'addressable'
 require 'parallel'
+require 'cache_method'
 
 # The Azure module serves as a namespace.
 module Azure

data/lib/azure/armrest/armrest_collection.rb

@@ -5,6 +5,7 @@ module Azure
     class ArmrestCollection < Array
       attr_accessor :continuation_token
       attr_accessor :response_headers
+      attr_accessor :response_code
 
       alias skip_token continuation_token
       alias skip_token= continuation_token=
@@ -18,6 +19,7 @@ module Azure
           json_response = JSON.parse(response)
           array = new(json_response['value'].map { |hash| klass.new(hash) })
 
+          array.response_code = response.code
           array.response_headers = response.headers
           array.continuation_token = parse_skip_token(json_response)
 

data/lib/azure/armrest/armrest_service.rb

@@ -166,7 +166,8 @@ module Azure
       # such as create or delete.
       #
       def poll(response)
-        url = response.respond_to?(:azure_asyncoperation) ? response.azure_asyncoperation : response.to_s
+        return 'Succeeded' if [200, 201].include?(response.response_code)
+        url = response.try(:azure_asyncoperation) || response.try(:location)
         JSON.parse(rest_get(url))['status']
       end
 
@@ -198,11 +199,9 @@ module Azure
       class << self
         private
 
-        def rest_execute(options, http_method = :get)
-          options = options.merge(
-            :method => http_method,
-            :url    => Addressable::URI.escape(options[:url])
-          )
+        def rest_execute(options, http_method = :get, encode = true)
+          url = encode ? Addressable::URI.encode(options[:url]) : options[:url]
+          options = options.merge(:method => http_method, :url => url)
           RestClient::Request.execute(options)
         rescue RestClient::Exception => e
           raise_api_exception(e)
@@ -232,34 +231,30 @@ module Azure
           rest_execute(options, :head)
         end
 
-        def raise_api_exception(e)
+        def raise_api_exception(err)
           begin
-            response = JSON.parse(e.http_body)
-            code = response['error']['code']
-            message = response['error']['message']
+            response = JSON.parse(err.http_body)
+            code     = response['error']['code']
+            message  = response['error']['message']
           rescue
-            message = e.http_body
+            code = err.try(:http_code) || err.try(:code)
+            message = err.try(:http_body) || err.try(:message)
           end
-          message = e.http_body unless message
-
-          exception_type = case e
-                           when RestClient::NotFound
-                             ResourceNotFoundException
-                           when RestClient::BadRequest
-                             BadRequestException
-                           when RestClient::GatewayTimeout
-                             GatewayTimeoutException
-                           when RestClient::BadGateway
-                             BadGatewayException
-                           when RestClient::Unauthorized, RestClient::Forbidden
-                             UnauthorizedException
-                           when RestClient::TooManyRequests
-                             TooManyRequestsException
-                           else
-                             ApiException
-                           end
-
-          raise exception_type.new(code, message, e)
+
+          exception_type = Azure::Armrest::EXCEPTION_MAP[err.http_code]
+
+          # If this is an exception that doesn't map directly to an HTTP code
+          # then parse it the exception class name and re-raise it as our own.
+          if exception_type.nil?
+            begin
+              klass = "Azure::Armrest::" + err.class.to_s.split("::").last + "Exception"
+              exception_type = const_get(klass)
+            rescue NameError
+              exception_type = Azure::Armrest::ApiException
+            end
+          end
+
+          raise exception_type.new(code, message, err)
         end
       end
 
@@ -267,7 +262,7 @@ module Azure
 
       # REST verb methods
 
-      def rest_execute(url, body = nil, http_method = :get)
+      def rest_execute(url, body = nil, http_method = :get, encode = true)
         options = {
           :url         => url,
           :proxy       => configuration.proxy,
@@ -282,13 +277,17 @@ module Azure
 
         options[:payload] = body if body
 
-        self.class.send(:rest_execute, options, http_method)
+        self.class.send(:rest_execute, options, http_method, encode)
       end
 
       def rest_get(url)
         rest_execute(url)
       end
 
+      def rest_get_without_encoding(url)
+        rest_execute(url, nil, :get, false)
+      end
+
       def rest_put(url, body = '')
         rest_execute(url, body, :put)
       end

data/lib/azure/armrest/configuration.rb

@@ -162,7 +162,11 @@ module Azure
 
       # Return the default api version for the given provider and service
       def provider_default_api_version(provider, service)
-        @provider_api_versions[provider.downcase][service.downcase]
+        if @provider_api_versions
+          @provider_api_versions[provider.downcase][service.downcase]
+        else
+          nil # Typically only for the fetch_providers method.
+        end
       end
 
       # The name of the file or handle used to log http requests.
@@ -266,22 +270,7 @@ module Azure
       end
 
       def fetch_providers
-        uri = Addressable::URI.join(Azure::Armrest::RESOURCE, 'providers')
-        uri.query = "api-version=#{api_version}"
-
-        response = ArmrestService.send(
-          :rest_get,
-          :url         => uri.to_s,
-          :proxy       => proxy,
-          :ssl_version => ssl_version,
-          :ssl_verify  => ssl_verify,
-          :headers     => {
-            :content_type  => content_type,
-            :authorization => token
-          }
-        )
-
-        JSON.parse(response.body)['value'].map { |hash| Azure::Armrest::ResourceProvider.new(hash) }
+        Azure::Armrest::ResourceProviderService.new(self).list
       end
 
       def fetch_token

data/lib/azure/armrest/exception.rb

@@ -52,18 +52,100 @@ module Azure
       end
     end
 
-    # A list of predefined exceptions that we wrap around RestClient exceptions.
-
-    class ResourceNotFoundException < ApiException; end
-
+    # Rewrapped HTTP errors
+    class BadGatewayException < ApiException; end
     class BadRequestException < ApiException; end
-
+    class BandwidthLimitExceededException < ApiException; end
+    class BlockedByWindowsParentalControlsException < ApiException; end
+    class ConflictException < ApiException; end
+    class ExpectationFailedException < ApiException; end
+    class FailedDependencyException < ApiException; end
+    class ForbiddenException < ApiException; end
+    class GatewayTimeoutException < ApiException; end
+    class GoneException < ApiException; end
+    class HTTPVersionNotSupportedException < ApiException; end
+    class ImATeapotException < ApiException; end
+    class InsufficientStorageException < ApiException; end
+    class InternalServerErrorException < ApiException; end
+    class LengthRequiredException < ApiException; end
+    class LockedException < ApiException; end
+    class LoopDetectedException < ApiException; end
+    class MethodNotAllowedException < ApiException; end
+    class NetworkAuthenticationRequiredException < ApiException; end
+    class NotAcceptableException < ApiException; end
+    class NotExtendedException < ApiException; end
+    class NotFoundException < ApiException; end
+    class NotImplementedException < ApiException; end
+    class PayloadTooLargeException < ApiException; end
+    class PaymentRequiredException < ApiException; end
+    class PreconditionFailedException < ApiException; end
+    class PreconditionRequiredException < ApiException; end
+    class ProxyAuthenticationRequiredException < ApiException; end
+    class RangeNotSatisfiableException < ApiException; end
+    class RequestHeaderFieldsTooLargeException < ApiException; end
+    class RequestTimeoutException < ApiException; end
+    class RetryWithException < ApiException; end
+    class ServiceUnavailableException < ApiException; end
+    class TooManyConnectionsFromThisIPException < ApiException; end
+    class TooManyRequestsException < ApiException; end
+    class URITooLongException < ApiException; end
     class UnauthorizedException < ApiException; end
+    class UnorderedCollectionException < ApiException; end
+    class UnprocessableEntityException < ApiException; end
+    class UnsupportedMediaTypeException < ApiException; end
+    class UpgradeRequiredException < ApiException; end
+    class VariantAlsoNegotiatesException < ApiException; end
 
-    class BadGatewayException < ApiException; end
-
-    class GatewayTimeoutException < ApiException; end
+    # Custom errors or other wrapped exceptions
+    class ResourceNotFoundException < ApiException; end
+    class TimeoutException < RequestTimeoutException; end
+    class OpenTimeoutException < TimeoutException; end
+    class ReadTimeoutException < TimeoutException; end
 
-    class TooManyRequestsException < ApiException; end
+    # Map HTTP error codes to our exception classes
+    EXCEPTION_MAP = {
+      400 => BadRequestException,
+      401 => UnauthorizedException,
+      402 => PaymentRequiredException,
+      403 => ForbiddenException,
+      404 => NotFoundException,
+      405 => MethodNotAllowedException,
+      406 => NotAcceptableException,
+      407 => ProxyAuthenticationRequiredException,
+      408 => RequestTimeoutException,
+      409 => ConflictException,
+      410 => GoneException,
+      411 => LengthRequiredException,
+      412 => PreconditionFailedException,
+      413 => PayloadTooLargeException,
+      414 => URITooLongException,
+      415 => UnsupportedMediaTypeException,
+      416 => RangeNotSatisfiableException,
+      417 => ExpectationFailedException,
+      418 => ImATeapotException,
+      421 => TooManyConnectionsFromThisIPException,
+      422 => UnprocessableEntityException,
+      423 => LockedException,
+      424 => FailedDependencyException,
+      425 => UnorderedCollectionException,
+      426 => UpgradeRequiredException,
+      428 => PreconditionRequiredException,
+      429 => TooManyRequestsException,
+      431 => RequestHeaderFieldsTooLargeException,
+      449 => RetryWithException,
+      450 => BlockedByWindowsParentalControlsException,
+      500 => InternalServerErrorException,
+      501 => NotImplementedException,
+      502 => BadGatewayException,
+      503 => ServiceUnavailableException,
+      504 => GatewayTimeoutException,
+      505 => HTTPVersionNotSupportedException,
+      506 => VariantAlsoNegotiatesException,
+      507 => InsufficientStorageException,
+      508 => LoopDetectedException,
+      509 => BandwidthLimitExceededException,
+      510 => NotExtendedException,
+      511 => NetworkAuthenticationRequiredException
+    }.freeze
   end
 end

data/lib/azure/armrest/model/base_model.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/string/inflections'
+require 'pp'
 
 module Azure
   module Armrest
@@ -23,6 +24,7 @@ module Azure
       attr_hash :tags
 
       attr_accessor :response_headers
+      attr_accessor :response_code
 
       # Constructs and returns a new JSON wrapper class. Pass in a plain
       # JSON string and it will automatically give you accessor methods
@@ -91,19 +93,9 @@ module Azure
         @json
       end
 
-      def inspect_method_list
-        methods(false).reject { |m| m.to_s.end_with?('=') }
-      end
-      private :inspect_method_list
-
-      def inspect
-        Kernel.instance_method(:to_s).bind(self).call.chomp!('>') <<
-          ' ' <<
-          inspect_method_list.map { |m| "#{m}=#{send(m).inspect}" }.join(', ') <<
-          '>'
-      end
-
       def pretty_print(q)
+        inspect_method_list = methods(false).reject { |m| m.to_s.end_with?('=') }
+
         q.object_address_group(self) {
           q.seplist(inspect_method_list, lambda { q.text ',' }) {|v|
             q.breakable
@@ -117,6 +109,8 @@ module Azure
         }
       end
 
+      alias_method :inspect, :pretty_print_inspect
+
       def ==(other)
         return false unless other.kind_of?(BaseModel)
         __getobj__ == other.__getobj__
@@ -186,6 +180,7 @@ module Azure
     # Initial class definitions. Reopen these classes as needed.
 
     class AvailabilitySet < BaseModel; end
+    class DeploymentTemplate < BaseModel; end
     class Event < BaseModel; end
     class ImageVersion < BaseModel; end
     class Offer < BaseModel; end
@@ -196,7 +191,9 @@ module Azure
     class Sku < BaseModel; end
     class Usage < BaseModel; end
 
-    class ResponseHeaders < BaseModel; end
+    class ResponseHeaders < BaseModel
+      undef_method :response_headers
+    end
 
     class StorageAccount < BaseModel; end
     class StorageAccountKey < StorageAccount

data/lib/azure/armrest/resource_group_based_service.rb

@@ -21,13 +21,18 @@ module Azure
         url = yield(url) || url if block_given?
         response = rest_put(url, options.to_json)
 
-        obj = nil
+        headers = Azure::Armrest::ResponseHeaders.new(response.headers)
+        headers.response_code = response.code
 
-        unless response.empty?
+        if response.body.empty?
+          obj = get(name, rgroup)
+        else
           obj = model_class.new(response.body)
-          obj.response_headers = Azure::Armrest::ResponseHeaders.new(response.headers)
         end
 
+        obj.response_headers = headers
+        obj.response_code = headers.response_code
+
         obj
       end
 
@@ -46,7 +51,7 @@ module Azure
         url = yield(url) || url if block_given?
         response = rest_get(url)
 
-        Azure::Armrest::ArmrestCollection.create_from_response(response, model_class)
+        get_all_results(response)
       end
 
       # Use a single call to get all resources for the service. You may
@@ -63,7 +68,7 @@ module Azure
         url = yield(url) || url if block_given?
 
         response = rest_get(url)
-        results  = Azure::Armrest::ArmrestCollection.create_from_response(response, model_class)
+        results  = get_all_results(response)
 
         filter.empty? ? results : results.select { |obj| filter.all? { |k, v| obj.public_send(k) == v } }
       end
@@ -81,6 +86,7 @@ module Azure
 
         obj = model_class.new(response.body)
         obj.response_headers = Azure::Armrest::ResponseHeaders.new(response.headers)
+        obj.response_code = response.code
 
         obj
       end
@@ -106,11 +112,29 @@ module Azure
           raise Azure::Armrest::ResourceNotFoundException.new(response.code, msg, response)
         end
 
-        Azure::Armrest::ResponseHeaders.new(response.headers)
+        headers = Azure::Armrest::ResponseHeaders.new(response.headers)
+        headers.response_code = response.code
+
+        headers
       end
 
       private
 
+      # Make additional calls and concatenate the results if a continuation URL is found.
+      def get_all_results(response)
+        results  = Azure::Armrest::ArmrestCollection.create_from_response(response, model_class)
+        nextlink = JSON.parse(response)['nextLink']
+
+        while nextlink
+          response = rest_get_without_encoding(nextlink)
+          more = Azure::Armrest::ArmrestCollection.create_from_response(response, model_class)
+          results.concat(more)
+          nextlink = JSON.parse(response)['nextLink']
+        end
+
+        results
+      end
+
       def validate_resource_group(name)
         raise ArgumentError, "must specify resource group" unless name
       end
@@ -144,17 +168,22 @@ module Azure
         array   = []
         mutex   = Mutex.new
         headers = nil
+        code    = nil
 
         Parallel.each(list_resource_groups, :in_threads => configuration.max_threads) do |rg|
           response = rest_get(build_url(rg.name))
           json_response = JSON.parse(response.body)['value']
           headers = Azure::Armrest::ResponseHeaders.new(response.headers)
+          code = response.code
           results = json_response.map { |hash| model_class.new(hash) }
           mutex.synchronize { array << results } unless results.blank?
         end
 
         array = ArmrestCollection.new(array.flatten)
-        array.response_headers = headers # Use the last set of headers for the overall result
+
+        # Use the last set of headers and response code for the overall result.
+        array.response_headers = headers
+        array.response_code = code
 
         array
       end

data/lib/azure/armrest/resource_provider_service.rb

@@ -1,5 +1,3 @@
-require 'cache_method'
-
 module Azure
   module Armrest
     class ResourceProviderService < ArmrestService
@@ -39,6 +37,8 @@ module Azure
         _list.map{ |hash| Azure::Armrest::ResourceProvider.new(hash) }
       end
 
+      # This is split out for the cache_method feature.
+      #
       def _list
         response = rest_get(build_url)
         JSON.parse(response)["value"]

data/lib/azure/armrest/storage_account_service.rb

@@ -44,7 +44,8 @@ module Azure
       # specified parameters.
       #
       # Note that the name of the storage account within the specified
-      # must be 3-24 alphanumeric lowercase characters.
+      # must be 3-24 alphanumeric lowercase characters. This name must be
+      # unique across all subscriptions.
       #
       # The options available are as follows:
       #
@@ -68,15 +69,14 @@ module Azure
       #
       #   sas = Azure::Armrest::StorageAccountService(config)
       #
-      #   sas.create(
-      #     "your_storage_account",
-      #     "your_resource_group",
-      #     {
-      #       :location   => "West US",
-      #       :properties => {:accountType => "Standard_ZRS"},
-      #       :tags       => {:YourCompany => true}
-      #     }
-      #   )
+      #   options = {
+      #     :location => "Central US",
+      #     :tags     => {:redhat => true},
+      #     :sku      => {:name => "Standard_LRS"},
+      #     :kind     => "Storage"
+      #   }
+      #
+      #   sas.create("your_storage_account", "your_resource_group", options)
       #
       def create(account_name, rgroup = configuration.resource_group, options)
         validating = options.delete(:validating)
@@ -86,10 +86,6 @@ module Azure
           url << "&validating=" << validating if validating
         end
 
-        # An initial create call will return nil because the response body is
-        # empty. In that case, make another call to get the object properties.
-        acct = get(account_name, rgroup) unless acct
-
         acct.proxy       = configuration.proxy
         acct.ssl_version = configuration.ssl_version
         acct.ssl_verify  = configuration.ssl_verify

data/lib/azure/armrest/template_deployment_service.rb

@@ -37,6 +37,18 @@ module Azure
         response = rest_get(url)
         TemplateDeploymentOperation.new(response)
       end
+
+      # Returns the json template as an object for the given deployment.
+      #
+      # If you want the plain JSON text then call .to_json on the returned object.
+      #
+      def get_template(deploy_name, resource_group = configuration.resource_group)
+        validate_resource_group(resource_group)
+        validate_resource(deploy_name)
+        url = build_url(resource_group, deploy_name, 'exportTemplate')
+        response = JSON.parse(rest_post(url))['template']
+        DeploymentTemplate.new(response)
+      end
     end
   end
 end

data/lib/azure/armrest/version.rb

@@ -1,5 +1,5 @@
 module Azure
   module Armrest
-    VERSION = '0.3.7'.freeze
+    VERSION = '0.3.8'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: azure-armrest
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.3.8
 platform: ruby
 authors:
 - Daniel J. Berger
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-15 00:00:00.000000000 Z
+date: 2016-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json