azure-armrest 0.0.3 → 0.0.4

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

@@ -7,23 +7,24 @@ module Azure
     # a corresponding class that wraps the JSON it collects, and each of
     # them should subclass this base class.
     class BaseModel < Delegator
-
-      # Declare that a method should return a plain hash instead of an
-      # OpenStruct instance.
-      #--
-      # TODO: Handle nested properties.
-      def self.hash_properties(method)
-        define_method(method){ @ostruct[method].to_h }
+      def self.excl_list
+        # initially inherit the exclusion list from parent class or create an empty Set
+        @excl_list ||= superclass.respond_to?(:excl_list, true) ? superclass.send(:excl_list) : Set.new
       end
+      private_class_method :excl_list
 
-      hash_properties :tags
+      def self.attr_hash(*attrs)
+        # merge the declared exclusive attributes to the existing list
+        @excl_list = excl_list | Set.new(attrs.map(&:to_s))
+      end
+      private_class_method :attr_hash
 
-      # Access the json instance variable directly.
-      attr_accessor :json
+      attr_hash :tags
 
       # Constructs and returns a new JSON wrapper class. Pass in a plain
       # JSON string and it will automatically give you accessor methods
-      # that make it behave like a typical Ruby object.
+      # that make it behave like a typical Ruby object. You may also pass
+      # in a hash.
       #
       # Example:
       #   class Person < Azure::ArmRest::BaseModel; end
@@ -40,42 +41,55 @@ module Azure
       #   person.address.zipcode  # => '01013'
       #
       #   # Or you can get back the original JSON if necessary.
-      #   person.json # => Returns original JSON
+      #   person.to_json # => Returns original JSON
       #
       def initialize(json)
-        @json = json
-        @resource_group = nil
-        @ostruct = JSON.parse(json, object_class: OpenStruct)
-        __setobj__(@ostruct)
+        # Find the exclusion list for the model of next level (@embedModel)
+        # '#' is the separator between levels. Remove attributes
+        # before the first separator.
+        child_excl_list = self.class.send(:excl_list).map do |e|
+          e.index('#') ? e[e.index('#') + 1 .. -1] : ''
+        end
+        @embedModel = Class.new(BaseModel) do
+          attr_hash *child_excl_list
+        end
+
+        if json.is_a?(Hash)
+          hash = json
+          @json = json.to_json
+        else
+          hash = JSON.parse(json)
+          @json = json
+        end
+
+        @ostruct = OpenStruct.new(hash)
+        super(@ostruct)
       end
 
-      # Return the resource group for the current object.
       def resource_group
         @resource_group ||= id[/resourceGroups\/(.+?)\//i, 1] rescue nil
       end
 
-      # Returns the original JSON string passed to the constructor.
+      def resource_group=(rg)
+        @resource_group = rg
+      end
+
       def to_json
         @json
       end
 
-      # Explicitly convert the object to the original JSON string.
       def to_s
         @json
       end
 
-      # Implicitly convert the object to the original JSON string.
       def to_str
         @json
       end
 
-      # Custom inspect method that shows the current class and methods.
-      #--
-      # TODO: Make this recursive.
       def inspect
         string = "<#{self.class} "
         method_list = methods(false).select{ |m| !m.to_s.include?('=') }
-        string << method_list.map{ |m| "#{m}=#{send(m)}" }.join(" ")
+        string << method_list.map{ |m| "#{m}=#{send(m).inspect}" }.join(", ")
         string << ">"
       end
 
@@ -90,20 +104,22 @@ module Azure
       # A custom Delegator interface method that creates snake_case
       # versions of the camelCase delegate methods.
       def __setobj__(obj)
+        excl_list = self.class.send(:excl_list)
         obj.methods(false).each{ |m|
-          if m.to_s[-1] != '=' # Must deal with nested ostruct's
+          if m.to_s[-1] != '=' && !excl_list.include?(m.to_s) # Must deal with nested models
             res = obj.send(m)
-            if res.respond_to?(:each)
-              res.each{ |o| __setobj__(o) if o.is_a?(OpenStruct) }
-            else
-              __setobj__(res) if res.is_a?(OpenStruct)
+            if res.is_a?(Array)
+              newval = res.map { |elem| elem.is_a?(Hash) ? @embedModel.new(elem) : elem }
+              obj.send("#{m}=", newval)
+            elsif res.is_a?(Hash)
+              obj.send("#{m}=", @embedModel.new(res))
             end
           end
 
           snake = m.to_s.gsub(/(.)([A-Z])/,'\1_\2').downcase.to_sym
 
           begin
-            obj.instance_eval("alias #{snake} #{m}") unless snake == m
+            obj.instance_eval("alias #{snake} #{m}; undef :#{m}") unless snake == m
           rescue SyntaxError
             next
           end
@@ -119,8 +135,13 @@ module Azure
     class ResourceGroup < BaseModel; end
     class ResourceProvider < BaseModel; end
     class StorageAccount < BaseModel; end
-    class TemplateDeployment < BaseModel; end
+    class Subscription < BaseModel; end
+    class Tag < BaseModel; end
+    class TemplateDeployment < BaseModel
+      attr_hash 'properties#parameters'
+    end
     class TemplateDeploymentOperation < TemplateDeployment; end
+    class Tenant < BaseModel; end
     class VirtualMachine < BaseModel; end
     class VirtualMachineInstance < VirtualMachine; end
     class VirtualMachineModel < VirtualMachine; end
@@ -136,3 +157,5 @@ module Azure
     end
   end
 end
+
+require_relative 'storage_account' 

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

@@ -0,0 +1,140 @@
+require 'azure-signature'
+require 'active_support/core_ext/hash/conversions'
+require 'nokogiri'
+
+module Azure
+  module Armrest
+    class StorageAccount < BaseModel
+      # Classes used to wrap container and blob information.
+      class Container < BaseModel; end
+      class Blob < BaseModel; end
+      class BlobServiceProperty < BaseModel; end
+      class BlobServiceStat < BaseModel; end
+      class BlobMetadata < BaseModel; end
+
+      # The version string used in headers sent as part any internal http
+      # request. The default is 2015-02-21.
+      attr_accessor :storage_api_version
+
+      def initialize(json)
+        super
+        @storage_api_version = '2015-02-21'
+      end
+
+      # Return a list of container names for the given storage account +key+.
+      # If no key is provided, it is assumed that the StorageAccount object
+      # includes the key1 property.
+      #
+      def containers(key = nil)
+        key ||= properties.key1
+
+        response = blob_response(key, "comp=list")
+
+        Nokogiri::XML(response.body).xpath('//Containers/Container').map do |element|
+          Container.new(Hash.from_xml(element.to_s)['Container'])
+        end
+      end
+
+      # 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)
+        key ||= properties.key1
+
+        url = File.join(properties.primary_endpoints.blob, container)
+        url += "?restype=container&comp=list"
+
+        headers = build_headers(url, key)
+        response = RestClient.get(url, headers)
+        doc = Nokogiri::XML(response.body)
+
+        doc.xpath('//Blobs/Blob').map do |node|
+          Blob.new(Hash.from_xml(node.to_s)['Blob'])
+        end
+      end
+
+      # Returns an array of all blobs for all containers.
+      #
+      def all_blobs(key = nil)
+        key ||= properties.key1
+        array = []
+        threads = []
+
+        containers.each do |container|
+          threads << Thread.new(container, key){ |c,k| array << blobs(c.name, k) }
+        end
+
+        threads.each(&:join)
+
+        array.flatten
+      end
+
+      # Returns the blob service properties for the current storage account.
+      #
+      def blob_properties(key = nil)
+        key ||= properties.key1
+
+        response = blob_response(key, "restype=service&comp=properties")
+        toplevel = 'StorageServiceProperties'
+
+        doc = Nokogiri::XML(response.body).xpath("//#{toplevel}")
+        BlobServiceProperty.new(Hash.from_xml(doc.to_s)[toplevel])
+      end
+
+      # Return metadata for the given +blob+ within +container+. You may
+      # specify a +date+ to retrieve metadata for a specific snapshot.
+      #
+      def blob_metadata(container, blob, date = nil, key = nil)
+        key ||= properties.key1
+
+        query = "comp=metadata"
+        query << "&snapshot=#{date}" if date
+
+        response = blob_response(key, query, container, blob)
+
+        BlobMetadata.new(response.headers)
+      end
+
+      # Retrieves statistics related to replication for the Blob service. Only
+      # available on the secondary location endpoint when read-access
+      # geo-redundant replication is enabled for the storage account.
+      #
+      def blob_service_stats(key = nil)
+        key ||= properties.key1
+
+        response = blob_response(key, "restype=service&comp=stats")
+        toplevel = 'StorageServiceStats'
+
+        doc = Nokogiri::XML(response.body).xpath("//#{toplevel}")
+        BlobServiceStat.new(Hash.from_xml(doc.to_s)[toplevel])
+      end
+
+      private
+
+      # Using the blob primary endpoint as a base, join any arguments to the
+      # the url and submit an http request.
+      #
+      def blob_response(key, query, *args)
+        url = File.join(properties.primary_endpoints.blob, *args) + "?#{query}"
+        headers = build_headers(url, key)
+        RestClient.get(url, headers)
+      end
+
+      # Set the headers needed, including the Authorization header.
+      #
+      def build_headers(url, key)
+        sig = Signature.new(url, key)
+
+        headers = {
+          'x-ms-date'     => Time.now.httpdate,
+          'x-ms-version'  => @storage_api_version,
+          :auth_string    => true
+        }
+
+        headers['Authorization'] = sig.blob_signature(headers)
+
+        headers
+      end
+    end
+  end
+end

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

@@ -2,102 +2,25 @@ module Azure
   module Armrest
     module Network
       # Class for managing public IP addresss.
-      class IpAddressService < ArmrestService
+      class IpAddressService < ResourceGroupBasedService
 
         # Creates and returns a new IpAddressService instance.
         #
         def initialize(_armrest_configuration, options = {})
           super
           @provider = options[:provider] || 'Microsoft.Network'
-          set_service_api_version(options, 'publicIPAddresses')
-        end
-
-        # Return information for the given IP address name for the
-        # provided +resource_group+. If no group is specified, it will use
-        # the resource group set in the constructor.
-        #
-        # Example:
-        #
-        #   # Where 'your_ip_name' likely corresponds to a VM name.
-        #   ip.get('your_ip_name', 'your_resource_group')
-        #
-        def get(ip_name, resource_group = armrest_configuration.resource_group)
-          raise ArgumentError, "must specify resource group" unless resource_group
-          url = build_url(resource_group, ip_name)
-          JSON.parse(rest_get(url))
+          @service_name = 'publicIPAddresses'
+          set_service_api_version(options, @service_name)
         end
 
         # Shortcut method that returns just the IP address for the given public
         # IP address name.
         #
         def get_ip(ip_name, resource_group = armrest_configuration.resource_group)
-          get(ip_name, resource_group)['properties']['ipAddress']
-        end
-
-        # Returns a list of available IP addresss for the given subscription
-        # for the provided +group+, or for all resource groups if no group is specified.
-        #
-        def list(group = nil)
-          if group
-            url = build_url(group)
-            JSON.parse(rest_get(url))['value']
-          else
-            array = []
-            threads = []
-            mutex = Mutex.new
-
-            resource_groups.each do |rg|
-              threads << Thread.new(rg['name']) do |group|
-                url = build_url(group)
-                response = rest_get(url)
-                results = JSON.parse(response)['value']
-                if results && !results.empty?
-                  mutex.synchronize{
-                    results.each{ |hash| hash['resourceGroup'] = group }
-                    array << results
-                  }
-                end
-              end
-            end
-
-            threads.each(&:join)
-
-            array.flatten
-          end
-        end
-
-        # List all IP addresss for the current subscription.
-        #
-        def list_all_for_subscription
-          sub_id = armrest_configuration.subscription_id
-          url = File.join(
-            Azure::Armrest::COMMON_URI, sub_id, 'providers',
-            @provider, 'publicIPAddresses'
-          )
-          url << "?api-version=#{@api_version}"
-          JSON.parse(rest_get(url))['value']
+          get(ip_name, resource_group).properties.ipAddress
         end
 
-        alias list_all list_all_for_subscription
-
-        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, *args)
-          url = File.join(
-            Azure::Armrest::COMMON_URI,
-            armrest_configuration.subscription_id,
-            'resourceGroups',
-            resource_group,
-            'providers',
-            @provider,
-            'publicIPAddresses',
-          )
-
-          url = File.join(url, *args) unless args.empty?
-          url << "?api-version=#{@api_version}"
-        end
+        alias get_ip_address get_ip
       end
     end # Network
   end # Armrest

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

@@ -2,121 +2,14 @@ module Azure
   module Armrest
     module Network
       # Class for managing network interfaces.
-      class NetworkInterfaceService < ArmrestService
+      class NetworkInterfaceService < ResourceGroupBasedService
         # Creates and returns a new NetworkInterfaceService instance.
         #
         def initialize(_armrest_configuration, options = {})
           super
           @provider = options[:provider] || 'Microsoft.Network'
-          set_service_api_version(options, 'networkInterfaces')
-        end
-
-        # Return information for the given network interface card for the
-        # provided +resource_group+. If no group is specified, it will use the
-        # resource group set in the constructor.
-        #
-        # Example:
-        #
-        #   nsg.get('your_interface', 'your_resource_group')
-        #
-        def get(interface, resource_group = armrest_configuration.resource_group)
-          raise ArgumentError, "must specify resource group" unless resource_group
-          url = build_url(resource_group, interface)
-          JSON.parse(rest_get(url))
-        end
-
-        # Returns a list of available network interfaces in the current subscription
-        # for the provided +resource_group+.
-        #
-        def list(resource_group = armrest_configuration.resource_group)
-          raise ArgumentError, "no resource group provided" unless resource_group
-          url = build_url(resource_group)
-          JSON.parse(rest_get(url))['value']
-        end
-
-        # List all network interfaces for the current subscription.
-        #
-        def list_all_for_subscription
-          sub_id = armrest_configuration.subscription_id
-          url = File.join(Azure::Armrest::COMMON_URI, sub_id, 'providers', @provider, 'networkInterfaces')
-          url << "?api-version=#{@api_version}"
-          JSON.parse(rest_get(url))['value']
-        end
-
-        alias list_all list_all_for_subscription
-
-        # Delete the given network interface in +resource_group+.
-        #
-        def delete(interface, resource_group = armrest_configuration.resource_group)
-          raise ArgumentError, "must specify resource group" unless resource_group
-
-          url = build_url(resource_group, interface)
-          response = rest_delete(url)
-          response.return!
-        end
-
-        # Create a new network interface, or update an existing network interface if it
-        # already exists. The first argument is a hash of options.
-        #
-        # - :name # Mandatory
-        # - :location # Mandatory
-        # - :tags
-        # - :properties
-        #   - :networkSecurityGroup
-        #     - :id
-        #   - :ipConfigurations
-        #   [
-        #     - :name # Mandatory
-        #     - :properties
-        #       - :subnet
-        #         - :id # Mandatory
-        #       - :privateIPAddress
-        #       - :privateIPAllocationMethod # Mandatory
-        #       - :publicIPAddress
-        #         - :id
-        #       - :loadBalancerBackendAddressPools
-        #         - :id
-        #       - :loadBalancerInboundNatRules
-        #         - :id
-        #   ]
-        #
-        #   - :dnsSettings
-        #     - :dnsServers[ <ip1>, <ip2>, ... ]
-        #
-        # For convenience, you may also pass the :resource_group as a hash option.
-        #
-        def create(name, options, resource_group = armrest_configuration.resource_group)
-          resource_group = options.delete(:resource_group) || resource_group
-
-          raise ArgumentError, "no resource group specified" unless resource_group
-
-          body = options.to_json
-
-          url = build_url(resource_group, name)
-
-          response = rest_put(url, body)
-          response.return!
-        end
-
-        alias update create
-
-        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, *args)
-          url = File.join(
-            Azure::Armrest::COMMON_URI,
-            armrest_configuration.subscription_id,
-            'resourceGroups',
-            resource_group,
-            'providers',
-            @provider,
-            'networkInterfaces',
-          )
-
-          url = File.join(url, *args) unless args.empty?
-          url << "?api-version=#{@api_version}"
+          @service_name = 'networkInterfaces'
+          set_service_api_version(options, @service_name)
         end
       end
     end # Network