azure-armrest 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bfd3dade5a1dad37a43cb98080c1509d58d9bd31
-  data.tar.gz: b3aeb02c6b2ee98cb38a4bda0f71f6e221c81789
+  metadata.gz: 1e916135112c85ebd2e061a02e63091e8eb6a629
+  data.tar.gz: a3c229e0a8fdf72bd06f81da392273548d5cb62a
 SHA512:
-  metadata.gz: b9268be1252d095820a642cf5c20adf895d67555ad4354f6ad78fc35b381c26b693efd3ec1802fbd8cbbb7e9f897889509b9cb28c8cdbb363752325d404bde17
-  data.tar.gz: cd67fb3c615bd1d8e83644152e28826b816b1f17586c4b84a314a976fde879ea76cb3b620bbb9fbe0bbbb755ad2dc3cf763bdea3c7e3ccbc4739b75a96a2861a
+  metadata.gz: bbdbea8e75c851b6ada07023ad9b6e4cce25a6cae9f14ab4e579030538518fd7489a86ae318786bfca0f512a951090fa9059ca2a2b772859b98fd1fcd6756a6f
+  data.tar.gz: b327fa9ceea6ebda436f4f51aa5bf4db18d75735f884a1566c48d835a807201f0e31492dca373e709ad49585dceebaaf4e46bb9737163be2a773b327f05453e9

data/CHANGES

@@ -1,3 +1,15 @@
+= 0.1.1 - 26-Feb-2016
+* Added proxy support for both the storage model and main configure method.
+* Added the SqlDatabaseService and SqlServerService classes.
+* Added the ResourceGroupBaseedSubservice abstract base class.
+* When fetching a default subscription, enabled subscriptions are chosen
+  before disabled subscriptions. If only a disabled subscription can be
+  found then a warning is issued.
+* You can now create blobs and blob snapshots with the storage model.
+  Thanks go to Alexandre Lamandé and Nguyễn Tấn Tài and for their patches.
+* Some internal refactoring to use our own helper methods for various
+  RestClient methods, and other cleanup.
+
 = 0.1.0 - 26-Jan-2015
 * Refactored the ArmrestService class api_version and provider handling.
 * The ArmrestService class no longer uses "preview" api versions by default.

data/lib/azure/armrest.rb

@@ -24,6 +24,7 @@ require 'azure/armrest/version'
 require 'azure/armrest/exception'
 require 'azure/armrest/armrest_service'
 require 'azure/armrest/resource_group_based_service'
+require 'azure/armrest/resource_group_based_subservice'
 require 'azure/armrest/storage_account_service'
 require 'azure/armrest/availability_set_service'
 require 'azure/armrest/virtual_machine_service'
@@ -43,6 +44,8 @@ require 'azure/armrest/network/virtual_network_service'
 require 'azure/armrest/network/subnet_service'
 require 'azure/armrest/role/assignment_service'
 require 'azure/armrest/role/definition_service'
+require 'azure/armrest/sql/sql_server_service'
+require 'azure/armrest/sql/sql_database_service'
 
 # JSON wrapper classes. The service classes should require their own
 # wrappers from this point on.

data/lib/azure/armrest/armrest_service.rb

@@ -15,7 +15,8 @@ module Azure
         :content_type,
         :accept,
         :token,
-        :token_expiration # token expiration local system date
+        :token_expiration, # token expiration local system date
+        :proxy
       ) do
         @@tokens = Hash.new([])
 
@@ -35,13 +36,19 @@ module Azure
         def fetch_token
           token_url = Azure::Armrest::AUTHORITY + tenant_id + "/oauth2/token"
 
-          response = JSON.parse(ArmrestService.rest_post(
-            token_url,
-            :grant_type    => grant_type,
-            :client_id     => client_id,
-            :client_secret => client_key,
-            :resource      => Azure::Armrest::RESOURCE
-          ))
+          response = JSON.parse(
+            ArmrestService.rest_post(
+              :url     => token_url,
+              :proxy   => proxy,
+              :payload => {
+                :grant_type    => grant_type,
+                :client_id     => client_id,
+                :client_secret => client_key,
+                :resource      => Azure::Armrest::RESOURCE
+              }
+            )
+          )
+
           token = 'Bearer ' + response['access_token']
           @@tokens[as_cache_key] = [token, Time.now + response['expires_in'].to_i]
         end
@@ -61,6 +68,9 @@ module Azure
       # The api-version string used for each request.
       attr_accessor :api_version
 
+      # The http proxy used for each request. Uses ENV['http_proxy'] if set.
+      attr_accessor :proxy
+
       @@providers_hash = {} # Set in constructor
 
       @@tokens = {} # token caches
@@ -120,26 +130,40 @@ module Azure
         configuration.content_type    ||= 'application/json'
         configuration.accept          ||= 'application/json'
         configuration.subscription_id ||= fetch_subscription_id(configuration)
+        configuration.proxy           ||= ENV['http_proxy']
 
         configuration
       end
 
+      # Find the first enabled subscription if one isn't provided or cached.
+      #
       def self.fetch_subscription_id(config)
         return @@subscriptions[config.as_cache_key] if @@subscriptions.has_key?(config.as_cache_key)
 
         url = File.join(Azure::Armrest::RESOURCE, "subscriptions?api-version=#{config.api_version}")
 
         response = rest_get(
-          url,
-          :content_type  => config.content_type,
-          :authorization => config.token
+          :url     => url,
+          :proxy   => config.proxy,
+          :headers => {
+            :content_type  => config.content_type,
+            :authorization => config.token
+          }
         )
 
-        hash = JSON.parse(response)["value"].first
+        array = JSON.parse(response)["value"]
+
+        if array.nil? || array.empty?
+          raise ArgumentError, "No associated subscription found"
+        end
+
+        # Look for the first enabled subscription, otherwise just take the first subscription found.
+        hash = array.find{ |h| h['state'] == 'Enabled' } || array.first
 
-        raise ArgumentError, "No associated subscription found" if hash.empty?
+        id = hash.fetch('subscriptionId')
+
+        warn "Warning: subscription #{id} is not enabled" unless hash['state'] == 'Enabled'
 
-        id = hash.fetch("subscriptionId")
         @@subscriptions[config.as_cache_key] = id
       end
 
@@ -287,34 +311,34 @@ module Azure
         JSON.parse(resp.body)['value'].map{ |hash| Azure::Armrest::Tenant.new(hash) }
       end
 
-      def self.rest_get(url, headers = {})
-        RestClient.get(url, headers)
+      def self.rest_execute(options, http_method = :get)
+        RestClient::Request.execute(options.merge(:method => http_method))
       rescue RestClient::Exception => e
         raise_api_exception(e)
       end
 
-      def self.rest_post(url, body, headers = {})
-        RestClient.post(url, body, headers)
-      rescue RestClient::Exception => e
-        raise_api_exception(e)
+      def self.rest_get(options)
+        rest_execute(options, :get)
       end
 
-      def self.rest_patch(url, body, headers = {})
-        RestClient.patch(url, body, headers)
-      rescue RestClient::Exception => e
-        raise_api_exception(e)
+      def self.rest_post(options)
+        rest_execute(options, :post)
       end
 
-      def self.rest_delete(url, headers = {})
-        RestClient.delete(url, headers)
-      rescue RestClient::Exception => e
-        raise_api_exception(e)
+      def self.rest_patch(options)
+        rest_execute(options, :patch)
       end
 
-      def self.rest_put(url, body, headers = {})
-        RestClient.put(url, body, headers)
-      rescue RestClient::Exception => e
-        raise_api_exception(e)
+      def self.rest_delete(options)
+        rest_execute(options, :delete)
+      end
+
+      def self.rest_put(options)
+        rest_execute(options, :put)
+      end
+
+      def self.rest_head(options)
+        rest_execute(options, :head)
       end
 
       def self.raise_api_exception(e)
@@ -350,52 +374,44 @@ module Azure
 
       # REST verb methods
 
+      def rest_execute(url, body = nil, http_method = :get)
+        options = {
+          :url     => url,
+          :proxy   => armrest_configuration.proxy,
+          :headers => {
+            :accept        => armrest_configuration.accept,
+            :content_type  => armrest_configuration.content_type,
+            :authorization => armrest_configuration.token
+          }
+        }
+
+        options[:payload] = body if body
+
+        self.class.rest_execute(options, http_method)
+      end
+
       def rest_get(url)
-        self.class.rest_get(
-          url,
-          :accept        => armrest_configuration.accept,
-          :content_type  => armrest_configuration.content_type,
-          :authorization => armrest_configuration.token,
-        )
+        rest_execute(url)
       end
 
       def rest_put(url, body = '')
-        self.class.rest_put(
-          url,
-          body,
-          :accept        => armrest_configuration.accept,
-          :content_type  => armrest_configuration.content_type,
-          :authorization => armrest_configuration.token,
-        )
+        rest_execute(url, body, :put)
       end
 
       def rest_post(url, body = '')
-        self.class.rest_post(
-          url,
-          body,
-          :accept        => armrest_configuration.accept,
-          :content_type  => armrest_configuration.content_type,
-          :authorization => armrest_configuration.token,
-        )
+        rest_execute(url, body, :post)
       end
 
       def rest_patch(url, body = '')
-        self.class.rest_patch(
-          url,
-          body,
-          :accept        => armrest_configuration.accept,
-          :content_type  => armrest_configuration.content_type,
-          :authorization => armrest_configuration.token,
-        )
+        rest_execute(url, body, :patch)
       end
 
       def rest_delete(url)
-        self.class.rest_delete(
-          url,
-          :accept        => armrest_configuration.accept,
-          :content_type  => armrest_configuration.content_type,
-          :authorization => armrest_configuration.token,
-        )
+        rest_execute(url, nil, :delete)
+      end
+
+      def rest_head(url)
+        rest_execute(url, nil, :head)
       end
 
       # Take an array of URI elements and join the together with the API version.

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

@@ -200,6 +200,11 @@ module Azure
       class Assignment < BaseModel; end
       class Definition < BaseModel; end
     end
+
+    module Sql
+      class SqlServer < BaseModel; end
+      class SqlDatabase < BaseModel; end
+    end
   end
 end
 

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

@@ -14,6 +14,7 @@ module Azure
       class BlobServiceProperty < BaseModel; end
       class BlobServiceStat < BaseModel; end
       class BlobMetadata < BaseModel; end
+      class BlobSnapshot < Blob; end
 
       # Classes used to wrap table information
       class Table < BaseModel; end
@@ -23,9 +24,13 @@ module Azure
       # request. The default is 2015-02-21.
       attr_accessor :storage_api_version
 
+      # An http proxy to use per request. Defaults to ENV['http_proxy'] if set.
+      attr_accessor :proxy
+
       def initialize(json)
         super
         @storage_api_version = '2015-02-21'
+        @proxy = ENV['http_proxy']
       end
 
       # Returns a list of tables for the given storage account +key+. Note
@@ -127,7 +132,12 @@ module Azure
         url += "?snapshot=" + options[:date] if options[:date]
 
         headers = build_headers(url, key, :blob, :verb => 'HEAD')
-        response = RestClient.head(url, headers)
+
+        response = ArmrestService.rest_head(
+          :url     => url,
+          :headers => headers,
+          :proxy   => proxy
+        )
 
         BlobProperty.new(response.headers)
       end
@@ -135,19 +145,26 @@ module Azure
       # Return a list of blobs for the given +container+ using the given +key+
       # or the key1 property of the StorageAccount object.
       #
-      def blobs(container, key = nil)
+      def blobs(container, key = nil, include_snapshot = false)
         key ||= properties.key1
 
         url = File.join(properties.primary_endpoints.blob, container)
         url += "?restype=container&comp=list"
+        url += "&include=snapshots" if include_snapshot
 
         headers = build_headers(url, key)
-        response = RestClient.get(url, headers)
+
+        response = ArmrestService.rest_get(
+          :url     => url,
+          :headers => headers,
+          :proxy   => proxy
+        )
+
         doc = Nokogiri::XML(response.body)
 
         doc.xpath('//Blobs/Blob').map do |node|
           hash = Hash.from_xml(node.to_s)['Blob'].merge(:container => container)
-          Blob.new(hash)
+          hash.key?('Snapshot') ? BlobSnapshot.new(hash) : Blob.new(hash)
         end
       end
 
@@ -226,11 +243,11 @@ module Azure
 
         headers = build_headers(dst_url, key, :blob, options)
 
-        # RestClient will set the Content-Type to application/x-www-form-urlencoded.
-        # We must override this setting or the request will fail.
-        headers['Content-Type'] = ''
-
-        response = RestClient.put(dst_url, '', headers)
+        response = ArmrestService.rest_put(
+          :url     => dst_url,
+          :payload => '',
+          :headers => headers
+        )
 
         Blob.new(response.headers)
       end
@@ -244,11 +261,67 @@ module Azure
         url += "?snapshot=" + options[:date] if options[:date]
 
         headers = build_headers(url, key, :blob, :verb => 'DELETE')
-        response = RestClient.delete(url, headers)
+
+        response = ArmrestService.rest_delete(
+          :url      => url,
+          :headers  => headers,
+          :proxy    => proxy
+        )
 
         true
       end
 
+      # Create new blob for a container.
+      #
+      # The +data+ parameter is a hash that contains the blob's information:
+      #
+      # data['x-ms-blob-type']
+      # # - Required. Specifies the type of blob to create: block, page or append.
+      #
+      # data['x-ms-blob-content-encoding']
+      # # - Optional. Set the blob’s content encoding.
+      # ...
+      def create_blob(container, blob, data, key = nil)
+        key ||= properties.key1
+
+        url = File.join(properties.primary_endpoints.blob, container, blob)
+
+        options = {:verb => 'PUT'}
+        options = options.merge(data)
+        headers = build_headers(url, key, :blob, options)
+
+        response = ArmrestService.rest_put(
+          :url     => url,
+          :payload => '',
+          :headers => headers,
+          :proxy   => proxy
+        )
+
+        Blob.new(response.headers)
+      end
+
+      def create_blob_snapshot(container, blob, key = nil)
+        key ||= properties.key1
+
+        url = File.join(properties.primary_endpoints.blob, container, blob)
+        url += "?comp=snapshot"
+
+        headers = build_headers(url, key, :blob, :verb => 'PUT')
+
+        response = ArmrestService.rest_put(
+          :url     => url,
+          :payload => '',
+          :headers => headers,
+          :proxy   => proxy
+        )
+
+        BlobSnapshot.new(
+          'name'          => blob,
+          'last_modified' => response.headers.fetch(:last_modified),
+          'snapshot'      => response.headers.fetch(:x_ms_snapshot)
+        )
+      end
+
       private
 
       # Using the blob primary endpoint as a base, join any arguments to the
@@ -257,7 +330,7 @@ module Azure
       def blob_response(key, query, *args)
         url = File.join(properties.primary_endpoints.blob, *args) + "?#{query}"
         headers = build_headers(url, key, 'blob')
-        RestClient.get(url, headers)
+        ArmrestService.rest_get(:url => url, :headers => headers, :proxy => proxy)
       end
 
       # Using the blob primary endpoint as a base, join any arguments to the
@@ -270,7 +343,7 @@ module Azure
 
         url << "?#{query}" if query # Must happen after headers are built
 
-        RestClient.get(url, headers)
+        ArmrestService.rest_get(:url => url, :headers => headers, :proxy => proxy)
       end
 
       # Set the headers needed, including the Authorization header.
@@ -279,7 +352,11 @@ module Azure
         sig = Signature.new(url, key)
         sig_type ||= 'blob'
 
+        # RestClient will set the Content-Type to application/x-www-form-urlencoded.
+        # We must override this setting or the request will fail in some cases.
+
         headers = {
+          'Content-Type'  => '',
           'x-ms-date'     => Time.now.httpdate,
           'x-ms-version'  => @storage_api_version,
           :auth_string    => true

data/lib/azure/armrest/network/network_security_rule_service.rb

@@ -2,44 +2,9 @@ module Azure
   module Armrest
     module Network
       # Base class for managing securityRules
-      class NetworkSecurityRuleService < NetworkSecurityGroupService
-        # Creates a new +rule_name+ on +security_group+ using the given +options+.
-        def create(rule_name, security_group, resource_group = armrest_configuration.resource_group, options = {})
-          super(combine(security_group, rule_name), resource_group, options)
-        end
-
-        alias update create
-
-        # Deletes the given +rule_name+ in +security_group+.
-        #
-        def delete(rule_name, security_group, resource_group = armrest_configuration.resource_group)
-          super(combine(security_group, rule_name), resource_group)
-        end
-
-        # Retrieves information for the provided +rule_name+ in +security_group+ for
-        # the current subscription.
-        #
-        def get(rule_name, security_group, resource_group = armrest_configuration.resource_group)
-          super(combine(security_group, rule_name), resource_group)
-        end
-
-        # List available security rules on +security_group+ for the given +resource_group+.
-        #
-        def list(security_group, resource_group = armrest_configuration.resource_group)
-          raise ArgumentError, "must specify resource group" unless resource_group
-          raise ArgumentError, "must specify name of the resource" unless security_group
-
-          url = build_url(resource_group, security_group, 'securityRules')
-          response = rest_get(url)
-          JSON.parse(response)['value'].map{ |hash| model_class.new(hash) }
-        end
-
-        alias list_all list
-
-        private
-
-        def combine(virtual_network, subnet)
-          File.join(virtual_network, 'securityRules', subnet)
+      class NetworkSecurityRuleService < ResourceGroupBasedSubservice
+        def initialize(armrest_configuration, options = {})
+          super(armrest_configuration, 'networkSecurityGroups', 'securityRules', 'Microsoft.Network', options)
         end
       end
     end # Network

data/lib/azure/armrest/network/subnet_service.rb

@@ -2,54 +2,9 @@ module Azure
   module Armrest
     module Network
       # Base class for managing subnets
-      class SubnetService < VirtualNetworkService
-        # Creates a new +subnet_name+ on +virtual_network+ using the given
-        # +options+.  The +options+ argument is a hash that supports the
-        # following keys and subkeys.
-        #
-        # - :properties
-        #   - :addressPrefix
-        #   - :networkSecurityGroup
-        #     - :id
-        #   - :routeTable
-        #     - :id
-        #
-        def create(subnet_name, virtual_network, resource_group = armrest_configuration.resource_group, options = {})
-          super(combine(virtual_network, subnet_name), resource_group, options)
-        end
-
-        alias update create
-
-        # Deletes the given +subnet_name+ in +virtual_network+.
-        #
-        def delete(subnet_name, virtual_network, resource_group = armrest_configuration.resource_group)
-          super(combine(virtual_network, subnet_name), resource_group)
-        end
-
-        # Retrieves information for the provided +subnet_name+ in +virtual_network+ for
-        # the current subscription.
-        #
-        def get(subnet_name, virtual_network, resource_group = armrest_configuration.resource_group)
-          super(combine(virtual_network, subnet_name), resource_group)
-        end
-
-        # List available subnets on +virtual_network+ for the given +resource_group+.
-        #
-        def list(virtual_network, resource_group = armrest_configuration.resource_group)
-          raise ArgumentError, "must specify resource group" unless resource_group
-          raise ArgumentError, "must specify name of the resource" unless virtual_network
-
-          url = build_url(resource_group, virtual_network, 'subnets')
-          response = rest_get(url)
-          JSON.parse(response)['value'].map{ |hash| model_class.new(hash) }
-        end
-
-        alias list_all list
-
-        private
-
-        def combine(virtual_newtork, subnet)
-          File.join(virtual_newtork, 'subnets', subnet)
+      class SubnetService < ResourceGroupBasedSubservice
+        def initialize(armrest_configuration, options = {})
+          super(armrest_configuration, 'virtualNetworks', 'subnets', 'Microsoft.Network', options)
         end
       end
     end # Network

data/lib/azure/armrest/resource_group_based_service.rb

@@ -1,94 +1,99 @@
-module Azure::Armrest
-  # Base class for services that needs to run in a resource group
-  class ResourceGroupBasedService < ArmrestService
-    def create(name, rgroup = armrest_configuration.resource_group, options = {})
-      raise ArgumentError, "must specify resource group" unless rgroup
-      raise ArgumentError, "must specify name of the resource" unless name
-
-      url = build_url(rgroup, name)
-      url = yield(url) || url if block_given?
-      response = rest_put(build_url(rgroup, name), options.to_json)
-      model_class.new(response) unless response.empty?
-    end
+module Azure
+  module Armrest
+    # Base class for services that need to run in a resource group
+    class ResourceGroupBasedService < ArmrestService
+      def create(name, rgroup = armrest_configuration.resource_group, options = {})
+        validate_resource_group(rgroup)
+        validate_resource(name)
+
+        url = build_url(rgroup, name)
+        url = yield(url) || url if block_given?
+        response = rest_put(url, options.to_json)
+        model_class.new(response) unless response.empty?
+      end
 
-    alias update create
+      alias update create
 
-    def list(rgroup = armrest_configuration.resource_group)
-      raise ArgumentError, "must specify resource group" unless rgroup
+      def list(rgroup = armrest_configuration.resource_group)
+        validate_resource_group(rgroup)
 
-      url = build_url(rgroup)
-      url = yield(url) || url if block_given?
-      response = rest_get(url)
-      JSON.parse(response)['value'].map{ |hash| model_class.new(hash) }
-    end
+        url = build_url(rgroup)
+        url = yield(url) || url if block_given?
+        response = rest_get(url)
+        JSON.parse(response)['value'].map { |hash| model_class.new(hash) }
+      end
 
-    def list_all
-      url = build_url
-      url = yield(url) || url if block_given?
-      response = rest_get(url)
-      JSON.parse(response)['value'].map{ |hash| model_class.new(hash) }
-    end
+      def list_all
+        url = build_url
+        url = yield(url) || url if block_given?
+        response = rest_get(url)
+        JSON.parse(response)['value'].map { |hash| model_class.new(hash) }
+      end
 
-    def get(name, rgroup = armrest_configuration.resource_group)
-      raise ArgumentError, "must specify resource group" unless rgroup
-      raise ArgumentError, "must specify name of the resource" unless name
+      def get(name, rgroup = armrest_configuration.resource_group)
+        validate_resource_group(rgroup)
+        validate_resource(name)
 
-      url = build_url(rgroup, name)
-      url = yield(url) || url if block_given?
-      response = rest_get(url)
-      model_class.new(response)
-    end
+        url = build_url(rgroup, name)
+        url = yield(url) || url if block_given?
+        response = rest_get(url)
+        model_class.new(response)
+      end
 
-    def delete(name, rgroup= armrest_configuration.resource_group)
-      raise ArgumentError, "must specify resource group" unless rgroup
-      raise ArgumentError, "must specify name of the resource" unless name
+      def delete(name, rgroup = armrest_configuration.resource_group)
+        validate_resource_group(rgroup)
+        validate_resource(name)
 
-      url = build_url(rgroup, name)
-      url = yield(url) || url if block_given?
-      rest_delete(url)
-      nil
-    end
+        url = build_url(rgroup, name)
+        url = yield(url) || url if block_given?
+        rest_delete(url)
+        nil
+      end
 
-    private
-
-    # Builds a URL based on subscription_id an resource_group and any other
-    # arguments provided, and appends it with the api_version.
-    #
-    def build_url(resource_group = nil, *args)
-      url = File.join(Azure::Armrest::COMMON_URI, armrest_configuration.subscription_id)
-      url = File.join(url, 'resourceGroups', resource_group) if resource_group
-      url = File.join(url, 'providers', @provider, @service_name)
-      url = File.join(url, *args) unless args.empty?
-      url << "?api-version=#{@api_version}"
-    end
+      private
 
-    def model_class
-      @model_class ||= Object.const_get(self.class.to_s.sub(/Service$/, ''))
-    end
+      def validate_resource_group(name)
+        raise ArgumentError, "must specify resource group" unless name
+      end
 
-    # Aggregate resources from each group
-    # To be used in the case that API does not support list_all with one call
-    def list_in_all_groups
-      array = []
-      threads = []
-      mutex = Mutex.new
+      def validate_resource(name)
+        raise ArgumentError, "must specify #{@service_name.singularize.underscore.humanize}" unless name
+      end
 
-      resource_groups.each do |rg|
-        threads << Thread.new(rg['name']) do |group|
-          url = build_url(group)
-          response = rest_get(url)
+      # Builds a URL based on subscription_id an resource_group and any other
+      # arguments provided, and appends it with the api_version.
+      #
+      def build_url(resource_group = nil, *args)
+        url = File.join(Azure::Armrest::COMMON_URI, armrest_configuration.subscription_id)
+        url = File.join(url, 'resourceGroups', resource_group) if resource_group
+        url = File.join(url, 'providers', @provider, @service_name)
+        url = File.join(url, *args) unless args.empty?
+        url << "?api-version=#{@api_version}"
+      end
 
-          results = JSON.parse(response)['value'].map { |hash| model_class.new(hash) }
+      def model_class
+        @model_class ||= Object.const_get(self.class.to_s.sub(/Service$/, ''))
+      end
 
-          if results && !results.empty?
-            mutex.synchronize{ array << results }
+      # Aggregate resources from each group
+      # To be used in the case that API does not support list_all with one call
+      def list_in_all_groups
+        array = []
+        threads = []
+        mutex = Mutex.new
+
+        resource_groups.each do |rg|
+          threads << Thread.new(rg['name']) do |group|
+            response = rest_get(build_url(group))
+            results = JSON.parse(response)['value'].map { |hash| model_class.new(hash) }
+            mutex.synchronize { array << results } unless results.blank?
           end
         end
-      end
 
-      threads.each(&:join)
+        threads.each(&:join)
 
-      array.flatten
+        array.flatten
+      end
     end
   end
 end

data/lib/azure/armrest/resource_group_based_subservice.rb

@@ -0,0 +1,60 @@
+module Azure
+  module Armrest
+    # Base class for services that have two levels in the path and need to run in a resource group
+    class ResourceGroupBasedSubservice < ResourceGroupBasedService
+      # Do not instantiate directly. This is an abstract base class from which
+      # all other service classes should subclass, and call super within their
+      # own constructors.
+      #
+      def initialize(armrest_configuration, service_name, subservice_name, default_provider, options)
+        @subservice_name = subservice_name
+        super(armrest_configuration, service_name, default_provider, options)
+      end
+
+      def create(resource, subresource, rgroup = armrest_configuration.resource_group, options = {})
+        validate_resource_group(rgroup)
+        validate_resource(resource)
+        validate_subresource(subresource)
+        super(combine(resource, subresource), rgroup, options)
+      end
+
+      alias update create
+
+      def list(resource, rgroup = armrest_configuration.resource_group)
+        validate_resource_group(rgroup)
+        validate_resource(resource)
+
+        url = build_url(rgroup, resource, @subservice_name)
+        url = yield(url) || url if block_given?
+        response = rest_get(url)
+        JSON.parse(response)['value'].map { |hash| model_class.new(hash) }
+      end
+
+      alias list_all list
+
+      def get(resource, subresource, rgroup = armrest_configuration.resource_group)
+        validate_resource_group(rgroup)
+        validate_resource(resource)
+        validate_subresource(subresource)
+        super(combine(resource, subresource), rgroup)
+      end
+
+      def delete(resource, subresource, rgroup = armrest_configuration.resource_group)
+        validate_resource_group(rgroup)
+        validate_resource(resource)
+        validate_subresource(subresource)
+        super(combine(resource, subresource), rgroup)
+      end
+
+      private
+
+      def validate_subresource(name)
+        raise ArgumentError, "must specify #{@subservice_name.singularize.underscore.humanize}" unless name
+      end
+
+      def combine(resource, subresource)
+        File.join(resource, @subservice_name, subresource)
+      end
+    end
+  end
+end

data/lib/azure/armrest/sql/sql_database_service.rb

@@ -0,0 +1,11 @@
+module Azure
+  module Armrest
+    module Sql
+      class SqlDatabaseService < ResourceGroupBasedSubservice
+        def initialize(armrest_configuration, options = {})
+          super(armrest_configuration, 'servers', 'databases', 'Microsoft.Sql', options)
+        end
+      end
+    end
+  end
+end

data/lib/azure/armrest/sql/sql_server_service.rb

@@ -0,0 +1,11 @@
+module Azure
+  module Armrest
+    module Sql
+      class SqlServerService < ResourceGroupBasedService
+        def initialize(armrest_configuration, options = {})
+          super(armrest_configuration, 'servers', 'Microsoft.Sql', options)
+        end
+      end
+    end
+  end
+end

data/lib/azure/armrest/storage_account_service.rb

@@ -71,7 +71,7 @@ module Azure
       # storage account as a hash.
       #
       def list_account_keys(account_name, group = armrest_configuration.resource_group)
-        raise ArgumentError, "must specify resource group" unless group
+        validate_resource_group(group)
 
         url = build_url(group, account_name, 'listKeys')
         response = rest_post(url)
@@ -87,7 +87,7 @@ module Azure
       #   }
       #
       def regenerate_storage_account_keys(account_name, group = armrest_configuration.resource_group, options)
-        raise ArgumentError, "must specify resource group" unless group
+        validate_resource_group(group)
 
         url = build_url(group, account_name, 'regenerateKey')
         response = rest_post(url, options.to_json)

data/lib/azure/armrest/template_deployment_service.rb

@@ -1,42 +1,44 @@
-module Azure::Armrest
-  # Base class for managing templates and deployments
-  class TemplateDeploymentService < ResourceGroupBasedService
+module Azure
+  module Armrest
+    # Base class for managing templates and deployments
+    class TemplateDeploymentService < ResourceGroupBasedService
 
-    def initialize(armrest_configuration, options = {})
-      # Has to be hard coded for now
-      options = {'api_version' => '2014-04-01-preview'}.merge(options)
-      super(armrest_configuration, 'deployments', 'Microsoft.Resources', options)
-    end
+      def initialize(armrest_configuration, options = {})
+        # Has to be hard coded for now
+        options = {'api_version' => '2014-04-01-preview'}.merge(options)
+        super(armrest_configuration, 'deployments', 'Microsoft.Resources', options)
+      end
 
-    # Get names of all deployments in a resource group
-    def list_names(resource_group = armrest_configuration.resource_group)
-      list(resource_group).map(&:name)
-    end
+      # Get names of all deployments in a resource group
+      def list_names(resource_group = armrest_configuration.resource_group)
+        list(resource_group).map(&:name)
+      end
 
-    # Get all deployments for the current subscription
-    def list_all
-      list_in_all_groups
-    end
+      # Get all deployments for the current subscription
+      def list_all
+        list_in_all_groups
+      end
 
-    # Get all operations of a deployment in a resource group
-    def list_deployment_operations(deploy_name, resource_group = armrest_configuration.resource_group)
-      raise ArgumentError, "must specify resource group" unless resource_group
-      raise ArgumentError, "must specify name of the resource" unless deploy_name
+      # Get all operations of a deployment in a resource group
+      def list_deployment_operations(deploy_name, resource_group = armrest_configuration.resource_group)
+        validate_resource_group(resource_group)
+        validate_resource(deploy_name)
 
-      url = build_url(resource_group, deploy_name, 'operations')
-      response = rest_get(url)
-      JSON.parse(response)['value'].map{ |hash| TemplateDeploymentOperation.new(hash) }
-    end
+        url = build_url(resource_group, deploy_name, 'operations')
+        response = rest_get(url)
+        JSON.parse(response)['value'].map { |hash| TemplateDeploymentOperation.new(hash) }
+      end
 
-    # Get the operation of a deployment in a resource group
-    def get_deployment_operation(op_id, deploy_name, resource_group = armrest_configuration.resource_group)
-      raise ArgumentError, "must specify resource group" unless resource_group
-      raise ArgumentError, "must specify name of the resource" unless deploy_name
-      raise ArgumentError, "must specify operation id" unless op_id
+      # Get the operation of a deployment in a resource group
+      def get_deployment_operation(op_id, deploy_name, resource_group = armrest_configuration.resource_group)
+        validate_resource_group(resource_group)
+        validate_resource(deploy_name)
+        raise ArgumentError, "must specify operation id" unless op_id
 
-      url = build_url(resource_group, deploy_name, 'operations', op_id)
-      response = rest_get(url)
-      TemplateDeploymentOperation.new(response)
+        url = build_url(resource_group, deploy_name, 'operations', op_id)
+        response = rest_get(url)
+        TemplateDeploymentOperation.new(response)
+      end
     end
   end
 end

data/lib/azure/armrest/version.rb

@@ -1,5 +1,5 @@
 module Azure
   module Armrest
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: azure-armrest
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Daniel J. Berger
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-26 00:00:00.000000000 Z
+date: 2016-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -205,11 +205,14 @@ files:
 - lib/azure/armrest/network/subnet_service.rb
 - lib/azure/armrest/network/virtual_network_service.rb
 - lib/azure/armrest/resource_group_based_service.rb
+- lib/azure/armrest/resource_group_based_subservice.rb
 - lib/azure/armrest/resource_group_service.rb
 - lib/azure/armrest/resource_provider_service.rb
 - lib/azure/armrest/resource_service.rb
 - lib/azure/armrest/role/assignment_service.rb
 - lib/azure/armrest/role/definition_service.rb
+- lib/azure/armrest/sql/sql_database_service.rb
+- lib/azure/armrest/sql/sql_server_service.rb
 - lib/azure/armrest/storage_account_service.rb
 - lib/azure/armrest/template_deployment_service.rb
 - lib/azure/armrest/version.rb