azure-armrest 0.2.10 → 0.3.0

data/lib/azure/armrest/billing/usage_service.rb

@@ -0,0 +1,54 @@
+module Azure
+  module Armrest
+    module Billing
+      class UsageService < ArmrestService
+        # Creates and returns a new UsageService object.
+        #
+        def initialize(configuration, options = {})
+          options = options.merge('api_version' => '2015-06-01-preview')
+          super(configuration, 'subscriptions', 'Microsoft.Commerce', options)
+        end
+
+        # List usage details. The +options+ hash may include the following
+        # filters:
+        #
+        #   :reportedStartTime        # e.g. 2016-05-30T00:00:00Z. Mandatory.
+        #   :reportedEndTime          # e.g. 2016-06-01T00:00:00Z. Mandatory.
+        #   :aggregationGranularity   # Either 'Daily' or 'Hourly'. Default is Daily.
+        #   :showDetails              # Either true or false. Default is true.
+        #   :continuationToken        # Token received from previous call. No default.
+        #
+        # The :reportedStartTime and :reportedEndTime values should be in
+        # UTC + iso8601 format. For "Daily" aggregation, the time should be set
+        # to midnight. For "Hourly" aggregation, only the hour should be
+        # set, with minutes and seconds set to "00".
+        #
+        def list(options = {})
+          url = build_url(options)
+          response = rest_get(url)
+          JSON.parse(response)['value'].map { |hash| Azure::Armrest::Usage.new(hash) }
+        end
+
+        private
+
+        def build_url(options = {})
+          url = File.join(
+            Azure::Armrest::COMMON_URI,
+            configuration.subscription_id,
+            'providers',
+            @provider,
+            'UsageAggregates'
+          )
+
+          url << "?api-version=#{@api_version}"
+
+          options.each do |key, value|
+            url << "&#{key}=#{value}"
+          end
+
+          url
+        end
+      end
+    end
+  end
+end

data/lib/azure/armrest/configuration.rb

@@ -0,0 +1,258 @@
+module Azure
+  module Armrest
+    class Configuration
+      # Clear all class level caches. Typically used for testing only.
+      def self.clear_caches
+        # Used to store unique token information.
+        @token_cache = Hash.new { |h, k| h[k] = [] }
+      end
+
+      clear_caches # Clear caches at load time.
+
+      # Retrieve the cached token for a configuration.
+      # Return both the token and its expiration date, or nil if not cached
+      def self.retrieve_token(configuration)
+        @token_cache[configuration.hash]
+      end
+
+      # Cache the token for a configuration that a token has been fetched from Azure
+      def self.cache_token(configuration)
+        raise ArgumentError, "Configuration does not have a token" if configuration.token.nil?
+        @token_cache[configuration.hash] = [configuration.token, configuration.token_expiration]
+      end
+
+      # The api-version string
+      attr_accessor :api_version
+
+      # The client ID used to gather token information.
+      attr_accessor :client_id
+
+      # The client key used to gather token information.
+      attr_accessor :client_key
+
+      # The tenant ID used to gather token information.
+      attr_accessor :tenant_id
+
+      # The subscription ID used for each http request.
+      attr_accessor :subscription_id
+
+      # The resource group used for http requests.
+      attr_accessor :resource_group
+
+      # The grant type. The default is client_credentials.
+      attr_accessor :grant_type
+
+      # The content type specified for http requests. The default is 'application/json'
+      attr_accessor :content_type
+
+      # The accept type specified for http request results. The default is 'application/json'
+      attr_accessor :accept
+
+      # Proxy to be used for all http requests.
+      attr_accessor :proxy
+
+      # SSL version to be used for all http requests.
+      attr_accessor :ssl_version
+
+      # SSL verify mode for all http requests.
+      attr_accessor :ssl_verify
+
+      # Namespace providers, their resource types, locations and supported api-version strings.
+      attr_reader :providers
+
+      # Yields a new Azure::Armrest::Configuration objects. Note that you must
+      # specify a client_id, client_key, tenant_id and subscription_id. All other
+      # parameters are optional.
+      #
+      # Example:
+      #
+      #   config = Azure::Armrest::Configuration.new(
+      #     :client_id       => 'xxxx',
+      #     :client_key      => 'yyyy',
+      #     :tenant_id       => 'zzzz',
+      #     :subscription_id => 'abcd'
+      #   )
+      #
+      # If you specify a :resource_group, that group will be used for resource
+      # group based service class requests. Otherwise, you will need to specify
+      # a resource group for most service methods.
+      #
+      # Although you can specify an :api_version, it is typically overridden
+      # by individual service classes.
+      #
+      def initialize(args)
+        # Use defaults, and override with provided arguments
+        options = {
+          :api_version  => '2015-01-01',
+          :accept       => 'application/json',
+          :content_type => 'application/json',
+          :grant_type   => 'client_credentials',
+          :proxy        => ENV['http_proxy'],
+          :ssl_version  => 'TLSv1',
+        }.merge(args.symbolize_keys)
+
+        user_token = options.delete(:token)
+        user_token_expiration = options.delete(:token_expiration)
+
+        options.each { |key, value| send("#{key}=", value) }
+
+        unless client_id && client_key && tenant_id && subscription_id
+          raise ArgumentError, "client_id, client_key, tenant_id and subscription_id must all be specified"
+        end
+
+        if user_token && user_token_expiration
+          set_token(user_token, user_token_expiration)
+        elsif user_token || user_token_expiration
+          raise ArgumentError, "token and token_expiration must be both specified"
+        end
+
+        # Allows for URI objects or Strings.
+        @proxy = @proxy.to_s if @proxy
+
+        @providers = fetch_providers
+        set_provider_api_versions
+      end
+
+      def hash
+        [tenant_id, client_id, client_key].join('_').hash
+      end
+
+      def eql?(other)
+        return true if equal?(other)
+        return false unless self.class == other.class
+        tenant_id == other.tenant_id && client_id == other.client_id && client_key == other.client_key
+      end
+
+      # Returns the token for the current cache key, or sets it if it does not
+      # exist or it has expired.
+      #
+      def token
+        ensure_token
+        @token
+      end
+
+      # Set the token value and expiration time.
+      #
+      def set_token(token, token_expiration)
+        validate_token_time(token_expiration)
+
+        @token, @token_expiration = token, token_expiration.utc
+        self.class.cache_token(self)
+      end
+
+      # Returns the expiration datetime of the current token
+      #
+      def token_expiration
+        ensure_token
+        @token_expiration
+      end
+
+      # 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]
+      end
+
+      # The name of the file or handle used to log http requests.
+      #--
+      # We have to do a little extra work here to convert a possible
+      # file handle to a file name.
+      #
+      def self.log
+        file = RestClient.log.instance_variable_get("@target_file")
+        file || RestClient.log
+      end
+
+      # Sets the log to +output+, which can be a file or a handle.
+      #
+      def self.log=(output)
+        RestClient.log = output
+      end
+
+      private
+
+      def ensure_token
+        @token, @token_expiration = self.class.retrieve_token(self) if @token.nil?
+        fetch_token if @token.nil? || Time.now.utc > @token_expiration
+      end
+
+      # Don't allow tokens from the past to be set.
+      #
+      def validate_token_time(time)
+        if time.utc < Time.now.utc
+          raise ArgumentError, 'token_expiration date invalid'
+        end
+      end
+
+      # Build a one-time lookup hash that sets the appropriate api-version
+      # string for a given provider and resource type. If possible, select
+      # a non-preview version that is not set in the future. Otherwise, just
+      # just the most recent one.
+      #
+      def set_provider_api_versions
+        # A lookup table for getting api-version strings per provider and service.
+        @provider_api_versions = Hash.new { |hash, key| hash[key] = {} }
+
+        providers.each do |rp|
+          rp.resource_types.each do |rt|
+            if rt.api_versions.any? { |v| v !~ /preview/i && Time.parse(v).utc <= Time.now.utc }
+              api_version = rt.api_versions.reject do |version|
+                version =~ /preview/i || Time.parse(version).utc > Time.now.utc
+              end.first
+            else
+              api_version = rt.api_versions.first
+            end
+
+            namespace     = rp['namespace'].downcase # Avoid name collision
+            resource_type = rt.resource_type.downcase
+
+            @provider_api_versions[namespace][resource_type] = api_version
+          end
+        end
+      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) }
+      end
+
+      def fetch_token
+        token_url = File.join(Azure::Armrest::AUTHORITY, tenant_id, 'oauth2/token')
+
+        response = JSON.parse(
+          ArmrestService.send(
+            :rest_post,
+            :url         => token_url,
+            :proxy       => proxy,
+            :ssl_version => ssl_version,
+            :ssl_verify  => ssl_verify,
+            :payload     => {
+              :grant_type    => grant_type,
+              :client_id     => client_id,
+              :client_secret => client_key,
+              :resource      => Azure::Armrest::RESOURCE
+            }
+          )
+        )
+
+        @token = 'Bearer ' + response['access_token']
+        @token_expiration = Time.now.utc + response['expires_in'].to_i
+
+        self.class.cache_token(self)
+      end
+    end
+  end
+end

data/lib/azure/armrest/exception.rb

@@ -4,30 +4,15 @@ module Azure
       attr_accessor :cause
       attr_writer :message
 
-      # Create a new Armrest::Exception object. The +message+ should be an
-      # error string, while +cause_exception+ is typically set to the
-      # raw RestClient exception.
-      #
-      # You will not typically use this object directly.
-      #
       def initialize(message = nil, cause_exception = nil)
         @message = message
         @cause = cause_exception
       end
 
-      # The stringified version (message) of the exception.
-      #
       def to_s
-        if cause
-          "#{message} (cause: #{cause})"
-        else
-          message
-        end
+        message
       end
 
-      # The error message or, if the message is not set, the name of the
-      # exception class.
-      #
       def message
         @message || self.class.name
       end
@@ -36,24 +21,16 @@ module Azure
     class ApiException < Exception
       attr_accessor :code
 
-      # Create a new ApiException class. The +code+ is the error code.
-      #
-      # This class serves as the parent
       def initialize(code, message, cause_exception)
         @code = code
         super(message, cause_exception)
       end
 
-      # A stringified version of the error. If self is a plain ApiException,
-      # then the cause is included to aid in debugging.
-      #
       def to_s
-        "[#{code}] #{super}"
+        "[#{code}] #{message}"
       end
     end
 
-    # A list of predefined exceptions that we wrap around RestClient exceptions.
-
     class ResourceNotFoundException < ApiException; end
 
     class BadRequestException < ApiException; end
@@ -64,5 +41,7 @@ module Azure
 
     class GatewayTimeoutException < ApiException; end
 
+    class TooManyRequestsException < ApiException; end
+
   end
 end

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

@@ -89,11 +89,30 @@ module Azure
         @json
       end
 
+      def inspect_method_list
+        methods(false).reject { |m| m.to_s.end_with?('=') }
+      end
+      private :inspect_method_list
+
       def inspect
-        string = "<#{self.class} "
-        method_list = methods(false).select { |m| !m.to_s.include?('=') }
-        string << method_list.map { |m| "#{m}=#{send(m).inspect}" }.join(', ')
-        string << '>'
+        Kernel.instance_method(:to_s).bind(self).call.chomp!('>') <<
+          ' ' <<
+          inspect_method_list.map { |m| "#{m}=#{send(m).inspect}" }.join(', ') <<
+          '>'
+      end
+
+      def pretty_print(q)
+        q.object_address_group(self) {
+          q.seplist(inspect_method_list, lambda { q.text ',' }) {|v|
+            q.breakable
+            q.text v.to_s
+            q.text '='
+            q.group(1) {
+              q.breakable ''
+              q.pp(send(v))
+            }
+          }
+        }
       end
 
       def ==(other)
@@ -173,6 +192,7 @@ module Azure
     class ResourceGroup < BaseModel; end
     class ResourceProvider < BaseModel; end
     class Sku < BaseModel; end
+    class Usage < BaseModel; end
 
     class StorageAccount < BaseModel; end
     class StorageAccountKey < StorageAccount

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

@@ -169,7 +169,8 @@ module Azure
 
         headers = build_headers(url, key, :blob, :verb => 'HEAD')
 
-        response = ArmrestService.rest_head(
+        response = ArmrestService.send(
+          :rest_head,
           :url         => url,
           :headers     => headers,
           :proxy       => proxy,
@@ -192,7 +193,8 @@ module Azure
 
         headers = build_headers(url, key)
 
-        response = ArmrestService.rest_get(
+        response = ArmrestService.send(
+          :rest_get,
           :url         => url,
           :headers     => headers,
           :proxy       => proxy,
@@ -283,7 +285,8 @@ module Azure
 
         headers = build_headers(dst_url, key, :blob, options)
 
-        response = ArmrestService.rest_put(
+        response = ArmrestService.send(
+          :rest_put,
           :url         => dst_url,
           :payload     => '',
           :headers     => headers,
@@ -305,7 +308,8 @@ module Azure
 
         headers = build_headers(url, key, :blob, :verb => 'DELETE')
 
-        response = ArmrestService.rest_delete(
+        ArmrestService.send(
+          :rest_delete,
           :url         => url,
           :headers     => headers,
           :proxy       => proxy,
@@ -335,7 +339,8 @@ module Azure
         options = options.merge(data)
         headers = build_headers(url, key, :blob, options)
 
-        response = ArmrestService.rest_put(
+        response = ArmrestService.send(
+          :rest_put,
           :url         => url,
           :payload     => '',
           :headers     => headers,
@@ -355,7 +360,8 @@ module Azure
 
         headers = build_headers(url, key, :blob, :verb => 'PUT')
 
-        response = ArmrestService.rest_put(
+        response = ArmrestService.send(
+          :rest_put,
           :url         => url,
           :payload     => '',
           :headers     => headers,
@@ -432,7 +438,8 @@ module Azure
 
         headers = build_headers(url, key, :blob, additional_headers)
 
-        ArmrestService.rest_get(
+        ArmrestService.send(
+          :rest_get,
           :url         => url,
           :headers     => headers,
           :proxy       => proxy,
@@ -486,7 +493,8 @@ module Azure
         url = File.join(properties.primary_endpoints.blob, *args) + "?#{query}"
         headers = build_headers(url, key, 'blob')
 
-        ArmrestService.rest_get(
+        ArmrestService.send(
+          :rest_get,
           :url         => url,
           :headers     => headers,
           :proxy       => proxy,
@@ -508,7 +516,8 @@ module Azure
           url << "?#{query}"
         end
 
-        ArmrestService.rest_get(
+        ArmrestService.send(
+          :rest_get,
           :url         => url,
           :headers     => headers,
           :proxy       => proxy,