azure-fix 0.7.0.pre3

data/lib/azure/base_management/location.rb

@@ -0,0 +1,27 @@
+#-------------------------------------------------------------------------
+# Copyright 2013 Microsoft Open Technologies, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require "azure/base_management/serialization"
+
+module Azure
+  module BaseManagement
+    class Location
+      attr_accessor :name, :available_services, :role_sizes
+
+      def initialize
+        yield self if block_given?
+      end
+    end
+  end
+end

data/lib/azure/base_management/management_http_request.rb

@@ -0,0 +1,172 @@
+#-------------------------------------------------------------------------
+# Copyright 2013 Microsoft Open Technologies, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require 'azure/core/http/http_response'
+require 'azure/core/http/http_request'
+
+# Represents an HTTP request that can perform synchronous queries to
+# an HTTP server, returning a HttpResponse
+module Azure
+  module BaseManagement
+    class ManagementHttpRequest < Azure::Core::Http::HttpRequest
+      include Azure::Core::Utility
+      attr_accessor :warn
+
+      # Creates the ManagementHttpRequest
+      #
+      # @param method           [Symbol] The HTTP method to use (:get, :post, :put, :del, etc...)
+      # @param path             [URI] The URI of the HTTP endpoint to query
+      # @param options_or_body  [Hash|IO|String] The request options including {:client, :body} or raw body only
+      def initialize(method, path, options_or_body = {})
+        options ||= unless options_or_body.is_a?(Hash)
+                    {body: options_or_body}
+                  end || options_or_body || {}
+        options[:client] ||= Azure
+        super(method, self.class.request_uri(path, options[:client]), options)
+        @warn = options.fetch(:warn, false)
+        content_length = body ? body.bytesize.to_s : '0'
+        headers.update({
+                            'x-ms-version' => '2015-04-01',
+                            'Content-Type' => 'application/xml',
+                            'Content-Length' => content_length
+                        })
+      end
+
+      # Public: Sends a request to HTTP server and returns a HttpResponse
+      #
+      # Returns a Nokogiri::XML instance of HttpResponse body
+      def call
+        conn = http_setup
+        res = conn.run_request(method.to_sym, uri, nil, nil) do  |req|
+          req.body = body if body
+          req.headers = headers if headers
+        end
+        response = wait_for_completion(Azure::Core::Http::HttpResponse.new(res))
+        Nokogiri::XML response.body unless response.nil?
+      end
+
+      def apply_body_headers
+        super
+      end
+
+      # Public: Wait for HTTP request completion.
+      #
+      # ==== Attributes
+      #
+      # * +response+       - Azure::Core::Http::HttpResponse. HttpResponse Response
+      #
+      # Print Error or Success of HttpRequest
+      def wait_for_completion(response)
+        ret_val = Nokogiri::XML response.body
+        if ret_val.at_css('Error Code') && ret_val.at_css('Error Code').content == 'AuthenticationFailed'
+          Azure::Loggerx.error_with_exit ret_val.at_css('Error Code').content + ' : ' + ret_val.at_css('Error Message').content
+        end
+        if response.status_code.to_i == 200 || response.status_code.to_i == 201
+          response
+        elsif redirected? response
+          rebuild_request response
+        elsif response.status_code.to_i > 201 && response.status_code.to_i <= 299
+          check_completion(response.headers['x-ms-request-id'])
+        elsif warn && !response.success?
+          response
+        elsif response.body
+          if ret_val.at_css('Error Code') && ret_val.at_css('Error Message')
+            Azure::Loggerx.error_with_exit ret_val.at_css('Error Code').content + ' : ' + ret_val.at_css('Error Message').content
+          else
+            Azure::Loggerx.exception_message "http error: #{response.status_code}"
+          end
+        else
+          Azure::Loggerx.exception_message "http error: #{response.status_code}"
+        end
+      end
+
+      def http_setup
+        http = super
+        http.ssl[:client_cert] = @client.http_certificate_key if @client.http_certificate_key
+        http.ssl[:client_key] = @client.http_private_key if @client.http_private_key
+        http
+      end
+
+      # Public: Gets the status of the specified operation and determines whether
+      # the operation has succeeded, failed, or is still in progress.
+      #
+      # ==== Attributes
+      #
+      # * +request_id+       - String.  x-ms-request-id response header of request
+      #
+      # See: http://msdn.microsoft.com/en-us/library/azure/ee460783.aspx
+      #
+      # Print Error or Success of Operation.
+      def check_completion(request_id)
+        request_path = "/#{client.subscription_id}/operations/#{request_id}"
+        conn = http_setup
+        headers['Content-Length'] = '0'
+        @method = :get
+        done = false
+        until done
+          Azure::Loggerx.info('# ')
+          res = conn.run_request(method.to_sym, URI(request_path), nil, nil) do  |req|
+            req.body = body if body
+            req.headers = headers if headers
+          end
+          response = Azure::Core::Http::HttpResponse.new(res)
+          ret_val = Nokogiri::XML response.body
+          status = xml_content(ret_val, 'Operation Status')
+          status_code = response.status_code.to_i
+          if status != 'InProgress'
+            done = true
+          end
+          if redirected? response
+            @uri = self.class.request_uri(response.headers['location'], client)
+            conn = http_setup
+            done = false
+          end
+          if done
+            if status.downcase != 'succeeded'
+              error_code = xml_content(ret_val, 'Operation Error Code')
+              error_msg = xml_content(ret_val, 'Operation Error Message')
+              Azure::Loggerx.exception_message "#{error_code}: #{error_msg}"
+            else
+              Azure::Loggerx.success "#{status.downcase} (#{status_code})"
+            end
+            return
+          else
+            sleep(5)
+          end
+        end
+      end
+
+      def rebuild_request(response)
+        host_uri = URI.parse(response.headers['location'])
+        conn = http_setup
+        res = conn.run_request(method.to_sym, host_uri, nil, nil) do  |req|
+          req.body = body if body
+          req.headers = headers if headers
+        end
+        wait_for_completion(HttpResponse.new(res))
+      end
+
+      def redirected?(response)
+        (response.status_code.to_i == 307)
+      end
+
+      private
+
+      def self.request_uri(path, client)
+        relative_path = path =~ /^\// ? path[1..-1] : path # remove the starting slash in the relative path if exists
+        URI.join(client.management_endpoint, '/' + client.subscription_id + '/', relative_path)
+      end
+    end
+  end
+end

data/lib/azure/base_management/serialization.rb

@@ -0,0 +1,135 @@
+#-------------------------------------------------------------------------
+# Copyright 2013 Microsoft Open Technologies, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+
+module Azure
+  module BaseManagement
+    module Serialization
+      extend Azure::Core::Utility
+      def self.locations_from_xml(locationXML)
+        location_objs = []
+        xml = locationXML.css('Locations Location')
+        xml.each do |meta_node|
+          loc = Location.new
+          loc.name = xml_content(meta_node, 'Name')
+          available_services = meta_node.css('AvailableServices').children
+          loc.available_services = available_services.to_ary.join(', ')
+          role_sizes = []
+          meta_node.css('VirtualMachinesRoleSizes RoleSize').each do | role_size_node |
+            role_sizes << role_size_node.text
+          end
+          loc.role_sizes = role_sizes
+          location_objs << loc
+        end
+        location_objs
+      end
+
+      def self.affinity_group_to_xml(name, location, label, options = {})
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.CreateAffinityGroup(
+            'xmlns' => 'http://schemas.microsoft.com/windowsazure'
+          ) do
+            xml.Name name
+            xml.Label Base64.encode64(label).strip
+            xml.Description options[:description]
+            xml.Location location
+          end
+        end
+        builder.doc.to_xml
+      end
+
+      def self.affinity_groups_from_xml(affinity_xml)
+        affinity_groups = []
+        affinity_group_services_xml = affinity_xml.css(
+          'AffinityGroups  AffinityGroup'
+        )
+
+        affinity_group_services_xml.each do |ag_xml|
+          affinity_group = AffinityGroup.new
+          affinity_group.name = xml_content(ag_xml, 'Name')
+          affinity_group.label = Base64.decode64(xml_content(ag_xml, 'Label'))
+          affinity_group.description = xml_content(ag_xml, 'Description')
+          affinity_group.location = xml_content(ag_xml, 'Location')
+
+          capabilities = ag_xml.css('Capabilities Capability')
+          affinity_group.capability = capabilities.map { |x|  x.content }
+          affinity_groups << affinity_group
+        end
+        affinity_groups.compact
+      end
+
+      def self.affinity_group_from_xml(affinity_xml)
+        hosted_services_xml = affinity_xml.css(
+          'AffinityGroup HostedServices HostedService'
+        )
+
+        storage_services_xml = affinity_xml.css(
+          'AffinityGroup StorageServices StorageService'
+        )
+
+        capability_xml = affinity_xml.css(
+          'AffinityGroup Capabilities Capability'
+        )
+
+        AffinityGroup.new do |affinity_group|
+          affinity_group.name = xml_content(
+            affinity_xml,
+            'AffinityGroup Name'
+          )
+          affinity_group.label = Base64.decode64(
+            xml_content(
+              affinity_xml,
+              'AffinityGroup Label'
+            )
+          )
+          affinity_group.description = xml_content(
+            affinity_xml,
+            'AffinityGroup Description'
+          )
+          affinity_group.location = xml_content(
+            affinity_xml,
+            'AffinityGroup Location'
+          )
+          affinity_group.hosted_services = []
+          hosted_services_xml.each do |hosted_service_xml|
+            affinity_group.hosted_services << {
+              url: xml_content(hosted_service_xml, 'Url'),
+              service_name: xml_content(hosted_service_xml, 'ServiceName')
+            }
+          end
+          affinity_group.storage_services = []
+          storage_services_xml.each do |storage_service_xml|
+            affinity_group.storage_services << {
+              url: xml_content(storage_service_xml, 'Url'),
+              service_name: xml_content(storage_service_xml, 'ServiceName')
+            }
+          end
+          affinity_group.capability = capability_xml.map { |x| x.content }
+        end
+      end
+
+      def self.resource_to_xml(label, options = {})
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.UpdateAffinityGroup(
+            'xmlns' => 'http://schemas.microsoft.com/windowsazure'
+          ) do
+            xml.Label Base64.encode64(label).strip
+            xml.Description options[:description] if options[:description]
+          end
+        end
+        builder.doc.to_xml
+      end
+    end
+  end
+end

data/lib/azure/base_management/sql_management_http_request.rb

@@ -0,0 +1,35 @@
+#-------------------------------------------------------------------------
+# Copyright 2013 Microsoft Open Technologies, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+# Represents an HTTP request that can perform synchronous queries to
+# an HTTP server, returning a HttpResponse
+module Azure
+  module BaseManagement
+    # This class is used for communicating with the Management certificate authentication API endpoint
+    class SqlManagementHttpRequest < ManagementHttpRequest
+
+      # Creates the SqlManagementHttpRequest
+      #
+      # @param method           [Symbol] The HTTP method to use (:get, :post, :put, :del, etc...)
+      # @param path             [URI] The URI of the HTTP endpoint to query
+      # @param options_or_body  [Hash|IO|String] The request options including {:client, :body} or raw body only
+      def initialize(method, path, options_or_body = {})
+        path = '/services/sqlservers' + (path.start_with?('/') ? path : '/' + path)
+        super(method, path, options_or_body)
+        headers['x-ms-version'] = '2012-03-01'
+        self.uri = URI.parse(Azure.config.sql_database_management_endpoint + Azure.config.subscription_id + path)
+      end
+    end
+  end
+end

data/lib/azure/blob/auth/shared_access_signature.rb

@@ -0,0 +1,147 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+
+# TODO: extract common SAS logic, add support for the other SAS types
+
+require 'azure/core/auth/signer'
+
+# This will break if used against API version prior to 2013-08-15 as the format
+# changed
+# @see https://msdn.microsoft.com/library/azure/dn140255.aspx for more information on construction
+module Azure
+  module Blob
+    module Auth
+      class SharedAccessSignature < Azure::Core::Auth::Signer
+        DEFAULTS = {
+            resource: 'b',
+            permissions: 'r',
+            version: '2014-02-14'
+        }
+
+        KEY_MAPPINGS = {
+            permissions:          :sp,
+            start:                :st,
+            expiry:               :se,
+            resource:             :sr,
+            identifier:           :si,
+            version:              :sv,
+            cache_control:        :rscc,
+            content_disposition:  :rscd,
+            content_encoding:     :rsce,
+            content_language:     :rscl,
+            content_type:         :rsct
+        }
+
+        OPTIONAL_QUERY_PARAMS = [:sp, :si, :rscc, :rscd, :rsce, :rscl, :rsct]
+
+        attr :account_name
+
+        # Public: Initialize the Signer.
+        #
+        # @param account_name [String] The account name. Defaults to the one in the global configuration.
+        # @param access_key [String]   The access_key encoded in Base64. Defaults to the one in the global configuration.
+        def initialize(account_name=Azure.storage_account_name, access_key=Azure.storage_access_key)
+          @account_name = account_name
+          super(access_key)
+        end
+
+        # Construct the plaintext to the spec required for signatures
+        # @return [String]
+        def signable_string(path, options)
+          # Order is significant
+          # The newlines from empty strings here are required
+          [
+              options[:permissions],
+              options[:start],
+              options[:expiry],
+              canonicalized_resource(path),
+              options[:identifier],
+
+              options[:version],
+
+              options[:cache_control],
+              options[:content_disposition],
+              options[:content_encoding],
+              options[:content_language],
+              options[:content_type]
+          ].join("\n")
+        end
+
+        # Return the cononicalized resource representation of the blob resource
+        # @return [String]
+        def canonicalized_resource(path)
+          "/#{account_name}#{path.start_with?('/') ? '' : '/'}#{path}"
+        end
+
+        # A customised URI reflecting options for the resource signed with the Shared Access Signature
+        # @param uri      [URI] uri to resource including query options
+        # @param options  [Hash]
+        #
+        # ==== Options
+        #
+        # * +:resource+     - String. Resource type, either 'b' (blob) or 'c' (container). Default 'b'
+        # * +:permissions+  - String. Combination of 'r','w','d','l' (container only) in this order. Default 'r'
+        # * +:start+        - String. UTC Date/Time in ISO8601 format. Optional.
+        # * +:expiry+       - String. UTC Date/Time in ISO8601 format. Optional. Default now + 30 minutes.
+        # * +:identifier+   - String. Identifier for stored access policy. Optional
+        # * +:version+      - String. API version. Default 2014-02-14
+        #
+        # * +:cache_control+       - String. Response header override. Optional.
+        # * +:content_disposition+ - String. Response header override. Optional.
+        # * +:content_encoding+    - String. Response header override. Optional.
+        # * +:content_language+    - String. Response header override. Optional.
+        # * +:content_type+        - String. Response header override. Optional.
+        def signed_uri(uri, options)
+          parsed_query = CGI::parse(uri.query || '').inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+          options[:expiry] ||= (Time.now + 60*30).utc.iso8601
+
+          if parsed_query.has_key?(:restype)
+            options[:resource] = parsed_query[:restype].first == 'container' ? 'c' : 'b'
+          end
+
+          options = DEFAULTS.merge(options)
+          sas_params = URI.encode_www_form(query_hash(uri.path, options))
+          URI.parse(uri.to_s + (uri.query.nil? ? '?' : '&') + sas_params)
+        end
+
+        def sign_request(req)
+          header_options = {}.tap do |opts|
+            opts[:version] = req.headers['x-ms-version'] if req.headers.has_key?('x-ms-version')
+          end
+
+          req.uri = signed_uri(req.uri, header_options)
+        end
+
+        private
+
+        def signature(path, options)
+          sign(signable_string(path, options))
+        end
+
+        def query_hash(path, options)
+          Hash[options.map { |k, v|
+                 [KEY_MAPPINGS[k], v]
+               }].reject { |k, v|
+            OPTIONAL_QUERY_PARAMS.include?(k) && v.to_s == ''
+          }.merge(
+              sig: signature(path, options)
+          )
+        end
+
+      end
+    end
+  end
+end