azure 0.7.0.pre → 0.7.0.pre2

data/lib/azure/queue/queue.rb

@@ -22,7 +22,6 @@ module Azure
       end
 
       attr_accessor :name
-      attr_accessor :url
       attr_accessor :metadata
     end
   end

data/lib/azure/queue/queue_service.rb

@@ -19,9 +19,9 @@ module Azure
   module Queue
     class QueueService < Service::StorageService
 
-      def initialize
-        super()
-        @host = Azure.config.storage_queue_host
+      def initialize(options = {})
+        super(nil, nil, options)
+        @host = @client.storage_queue_host
       end
 
       # Public: Get a list of Queues from the server
@@ -565,4 +565,6 @@ module Azure
       end
     end
   end
-end
+end
+
+Azure::QueueService = Azure::Queue::QueueService

data/lib/azure/queue/serialization.rb

@@ -96,7 +96,6 @@ module Azure
 
         queue = Queue.new
         queue.name = xml.Name.text if (xml > "Name").any?
-        queue.url = xml.Url.text if (xml > "Url").any?
         queue.metadata = metadata_from_xml(xml.Metadata) if (xml > "Metadata").any?
 
         queue

data/lib/azure/service/storage_service.rb

@@ -20,10 +20,12 @@ module Azure
     class StorageService < Azure::Core::SignedService
       # Create a new instance of the StorageService
       #
-      # signer        - Azure::Core::Auth::Signer. An implementation of Signer used for signing requests. (optional, Default=Azure::Core::Auth::SharedKey.new)
-      # account_name  - String. The account name (optional, Default=Azure.config.storage_account_name)  
-      def initialize(signer=Core::Auth::SharedKey.new, account_name=Azure.config.storage_account_name)
-        super(signer, account_name)
+      # @param signer         [Azure::Core::Auth::Signer] An implementation of Signer used for signing requests.
+      # (optional, Default=Azure::Core::Auth::SharedKey.new)
+      # @param account_name   [String] The account name (optional, Default=Azure.config.storage_account_name)
+      # @param options        [Azure::Configurable] the client configuration context
+      def initialize(signer=Core::Auth::SharedKey.new, account_name=nil, options = {})
+        super(signer, account_name, options)
       end
 
 
@@ -62,7 +64,7 @@ module Azure
       # Returns a URI.
       def service_properties_uri(query={})
         query.update(restype: 'service', comp: 'properties')
-        generate_uri("", query)
+        generate_uri('', query)
       end
 
       # Adds metadata properties to header hash with required prefix
@@ -76,8 +78,9 @@ module Azure
       end
 
       def service_properties_headers
-        {"x-ms-version" => "2013-08-15"}
+        {'x-ms-version' => '2014-02-14'}
       end
+
     end
   end
 end

data/lib/azure/service_bus/auth/shared_access_signer.rb

@@ -0,0 +1,44 @@
+require 'cgi'
+
+module Azure
+  module ServiceBus
+    module Auth
+      class SharedAccessSigner < Azure::Core::Auth::Signer
+
+        # The number of seconds from the time of signature that the SAS token will expire
+        attr_accessor :expiry_offset, :key_name
+
+        # Public: Initialize the Signer.
+        #
+        # @param key_name [String] The service bus SAS key name. Defaults to the one in the global configuration.
+        # @param key      [String] The service bus SAS key encoded in Base64. Defaults to the one in the global configuration.
+        # @param expiry_offset [Integer] The number of seconds from the time of signature that the SAS token will expire. Defaults to 30 minutes.
+        def initialize(key_name=Azure.sb_sas_key_name, key=Azure.sb_sas_key, expiry_offset = 60*5)
+          super(key)
+          @key_name, @expiry_offset = key_name, expiry_offset
+        end
+
+        def name
+          'SharedAccessSignature'
+        end
+
+        def token(uri)
+          url_encoded_resource = CGI.escape(uri.to_s.downcase).gsub('+', '%20').downcase
+          expiry = Time.now.to_i + expiry_offset
+          sig = CGI.escape(signature(url_encoded_resource, expiry)).gsub('+', '%20')
+          "#{name} sig=#{sig}&se=#{expiry}&skn=#{key_name}&sr=#{url_encoded_resource}"
+        end
+
+        def sign_request(req)
+          req.headers['Authorization'] = token(req.uri)
+        end
+
+        private
+
+        def signature(url_encoded_resource, expiry)
+          sign([url_encoded_resource, expiry].join("\n"))
+        end
+      end
+    end
+  end
+end

data/lib/azure/service_bus/auth/wrap_service.rb

@@ -20,10 +20,11 @@ module Azure
     module Auth
       class WrapService < Azure::Core::FilteredService
 
-        def initialize(host=Azure.config.acs_host, issuer=Azure.config.sb_issuer, access_key=Azure.config.sb_access_key)
-          super(host)
-          @issuer = issuer
-          @access_key = access_key
+        def initialize(host=nil, issuer=nil, access_key=nil, options={})
+          host = host || (options[:client] || Azure).acs_host
+          super(host, options)
+          @issuer = issuer || client.sb_issuer
+          @access_key = access_key || client.sb_access_key
         end
 
         # Gets a WRAP access token with specified parameters.

data/lib/azure/service_bus/auth/wrap_signer.rb

@@ -12,28 +12,36 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #--------------------------------------------------------------------------
-require "uri"
+require 'uri'
 
-require "azure/core/auth/signer"
-require "azure/service_bus/auth/wrap_service"
+require 'azure/core/auth/signer'
+require 'azure/service_bus/auth/wrap_service'
 
 module Azure
   module ServiceBus
     module Auth
       class WrapSigner < Azure::Core::Auth::Signer
 
-        def initialize
+        def initialize(host = nil, options={})
+          client = (options[:client] || Azure)
+          host = host || client.acs_host
           @tokens = {}
-          @wrap_service = Azure::ServiceBus::Auth::WrapService.new
+          @wrap_service = Azure::ServiceBus::Auth::WrapService.new(host, nil, nil, options)
         end
 
         attr_accessor :tokens
 
         def name
-          "WRAP"
+          'WRAP'
         end
 
         public
+
+        def sign_request(req)
+          signature = sign(req.method, req.uri, req.headers)
+          req.headers['Authorization'] = "#{name} #{signature}"
+        end
+
         def sign(method, uri, headers)
           access_token = get_access_token(create_scope_uri(uri))
           'access_token="%s"' % access_token

data/lib/azure/service_bus/service_bus_service.rb

@@ -14,6 +14,7 @@
 #--------------------------------------------------------------------------
 require 'azure/core/signed_service'
 require 'azure/service_bus/auth/wrap_signer'
+require 'azure/service_bus/auth/shared_access_signer'
 require 'azure/service_bus/serialization'
 
 require 'azure/service_bus/brokered_message_serializer'
@@ -25,18 +26,20 @@ module Azure
 
       DEFAULT_TIMEOUT = 60
 
-      def initialize(host=Azure.config.service_bus_host)
-        super(Azure::ServiceBus::Auth::WrapSigner.new)
-          @host = host
-          
-          with_filter do |req, res| 
-            req.headers.delete "x-ms-date"
-            req.headers.delete "x-ms-version"
-            req.headers.delete "DataServiceVersion"
-            req.headers.delete "MaxDataServiceVersion"
-            req.headers["X-Process-At"] = "servicebus"
-            res.call
-          end
+      def initialize(host=nil, options = {})
+        client_config = options[:client] || Azure
+        signer = options[:signer] || Auth::WrapSigner.new(client_config.acs_host, client: client_config)
+        super(signer, nil, options)
+        @host = host || @client.config.service_bus_host
+
+        with_filter do |req, res|
+          req.headers.delete 'x-ms-date'
+          req.headers.delete 'x-ms-version'
+          req.headers.delete 'DataServiceVersion'
+          req.headers.delete 'MaxDataServiceVersion'
+          req.headers['X-Process-At'] = 'servicebus'
+          res.call
+        end
       end
 
       # Creates a new relay endpoint. Once created, this relay endpoint resource manifest is immutable. 
@@ -140,7 +143,7 @@ module Azure
       def get_queue(queue)
         resource_entry(:queue, _name_for(queue))
       end
-      
+
       # Enumerates the queues in the service namespace.
       #
       # ==== Attributes
@@ -159,7 +162,7 @@ module Azure
 
         resource_list(:queue, query)
       end
-      
+
       # Creates a new topic. Once created, this topic resource manifest is immutable. 
       # 
       # ==== Attributes
@@ -295,7 +298,7 @@ module Azure
         query["$top"] = options[:top].to_i.to_s if options[:top]
 
         results = resource_list(:rule, topic_name, subscription_name, query)
-        results.each{|r| r.topic = topic_name; r.subscription=subscription_name}
+        results.each { |r| r.topic = topic_name; r.subscription=subscription_name }
 
         return results
       end
@@ -349,7 +352,7 @@ module Azure
       # such as Azure::ServiceBus::Subscription instance.
       def get_subscription(*p)
         topic_name, subscription_name = _subscription_args(*p)
-        
+
         result = resource_entry(:subscription, topic_name, subscription_name)
         result.topic = topic_name
         result
@@ -378,7 +381,7 @@ module Azure
 
         return results
       end
-      
+
       # Enqueues a message into the specified topic. The limit to the number of messages 
       # which may be present in the topic is governed by the message size in MaxTopicSizeInBytes. 
       # If this message causes the topic to exceed its quota, a quota exceeded error is 
@@ -612,12 +615,11 @@ module Azure
       end
 
       def _modify_message(method, message)
-        uri = nil
-        if (message.respond_to? :location)
-          uri = message.location
-        else
-          uri = message
-        end
+        uri = if (message.respond_to? :location)
+                message.location
+              else
+                message
+              end
 
         call(method, uri)
         nil
@@ -633,10 +635,10 @@ module Azure
         content_type = message.content_type || 'text/plain'
 
         headers = {
-          'BrokerProperties'=> broker_properties
+            'BrokerProperties' => broker_properties
         }
 
-        message_properties.each do |k,v|
+        message_properties.each do |k, v|
           headers[k.to_s.encode("UTF-8")] = v.encode("UTF-8")
         end
 
@@ -655,7 +657,7 @@ module Azure
       end
 
       def _retrieve_message(method, path, timeout=DEFAULT_TIMEOUT)
-        uri = messages_head_uri(path, { "timeout"=> timeout.to_s })
+        uri = messages_head_uri(path, {"timeout" => timeout.to_s})
 
         response = call(method, uri)
         (response.status_code == 204) ? nil : BrokeredMessageSerializer.get_from_http_response(response)
@@ -665,7 +667,7 @@ module Azure
         rule = nil
 
         if p.length == 3 or p.length == 4
-          rule = Azure::ServiceBus::Rule.new(p[2]) do |r| 
+          rule = Azure::ServiceBus::Rule.new(p[2]) do |r|
             r.topic = p[0]
             r.subscription = p[1]
             r.description = p[3] if p.length == 4
@@ -699,11 +701,11 @@ module Azure
         subscription = nil
 
         if p.length == 3
-          subscription = Azure::ServiceBus::Subscription.new(p[1], p[2]) do |sub| 
+          subscription = Azure::ServiceBus::Subscription.new(p[1], p[2]) do |sub|
             sub.topic = p[0]
           end
         elsif p.length == 2
-          subscription = Azure::ServiceBus::Subscription.new(p[1]) do |sub| 
+          subscription = Azure::ServiceBus::Subscription.new(p[1]) do |sub|
             sub.topic = p[0]
           end
         elsif p.length == 1 and p[0].respond_to? :name and p[0].respond_to? :topic and p[0].respond_to? :description
@@ -892,4 +894,6 @@ module Azure
       end
     end
   end
-end
+end
+
+Azure::ServiceBusService = Azure::ServiceBus::ServiceBusService

data/lib/azure/sql_database_management/errors.rb

@@ -0,0 +1,11 @@
+
+module Azure
+  module SqlDatabaseManagement
+    # Generic error for SQL Management activities
+    class Error < Azure::Core::Error;end
+    # Server does not exist error for SQL Management activities
+    class ServerDoesNotExist < Azure::Core::Error;end
+    # Firewall Rule does not exist error for SQL Management activities
+    class RuleDoesNotExist < Azure::Core::Error;end
+  end
+end

data/lib/azure/sql_database_management/firewall_rule.rb

@@ -0,0 +1,30 @@
+#-------------------------------------------------------------------------
+# Copyright 2015 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 SqlDatabaseManagement
+    class FirewallRule
+
+      def initialize
+        yield self if block_given?
+      end
+
+      attr_accessor :name
+      attr_accessor :type
+      attr_accessor :start_ip_address
+      attr_accessor :end_ip_address
+
+    end
+  end
+end

data/lib/azure/sql_database_management/serialization.rb

@@ -12,101 +12,88 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #--------------------------------------------------------------------------
-require 'azure/sql_database_management/sql_database'
+require 'azure/sql_database_management/sql_server'
+require 'azure/sql_database_management/firewall_rule'
 
 module Azure
   module SqlDatabaseManagement
     module Serialization
       extend Azure::Core::Utility
 
-      def self.database_to_xml(login, password, location)
+      def self.server_to_xml(login, password, location, version = 12.0)
         builder = Nokogiri::XML::Builder.new do |xml|
-          xml.Server('xmlns'=>'http://schemas.microsoft.com/sqlazure/2010/12/') {
+          xml.Server('xmlns' => 'http://schemas.microsoft.com/sqlazure/2010/12/') {
             xml.AdministratorLogin login
             xml.AdministratorLoginPassword password
             xml.Location location
+            xml.Version version
           }
         end
         builder.doc.to_xml
       end
 
-      def self.databases_from_xml(databasesXML)
-        databases = []
-        databases_servicesXML = databasesXML.css('Servers  Server')
-        databases_servicesXML.each do |database_xml|
-          database = SqlDatabase.new
-          database.name = xml_content(database_xml, 'Name')
-          database.administrator_login = xml_content(database_xml, 'AdministratorLogin')
-          database.location = xml_content(database_xml, 'Location')
-          database.feature_name = xml_content(database_xml, 'Features Feature Name')
-          database.feature_value = xml_content(database_xml, 'Features Feature Value')
-          databases << database
+      def self.servers_from_xml(wrapper_XML)
+        servers_XML = wrapper_XML.css('Servers  Server')
+        servers_XML.map do |server_xml|
+          server = SqlServer.new
+          server.name = xml_content(server_xml, 'Name')
+          server.administrator_login = xml_content(server_xml, 'AdministratorLogin')
+          server.location = xml_content(server_xml, 'Location')
+          server.version = xml_content(server_xml, 'Version')
+          server.state = xml_content(server_xml, 'State')
+          server.fully_qualified_domain_name = xml_content(server_xml, 'FullyQualifiedDomainName')
+          server
         end
-        databases.compact
       end
 
-      def self.server_name_from_xml(response_xml, login, location)
+      def self.server_name_from_xml(response_xml, login, location, version)
         server_name = xml_content(response_xml, 'ServerName')
-        SqlDatabase.new do |db|
+        SqlServer.new do |db|
           db.name = server_name
           db.location = location
           db.administrator_login = login
+          db.version = version
+          db.fully_qualified_domain_name = response_xml.css('ServerName').first['FullyQualifiedDomainName']
         end
       end
 
       def self.reset_password_to_xml(password)
         builder = Nokogiri::XML::Builder.new do |xml|
-          xml.AdministratorLoginPassword(password, {'xmlns'=>'http://schemas.microsoft.com/sqlazure/2010/12/'})
+          xml.AdministratorLoginPassword(password, {'xmlns' => 'http://schemas.microsoft.com/sqlazure/2010/12/'})
         end
         builder.doc.to_xml
       end
 
-      def self.firewall_rule_to_xml(options)
-        # Need to revisit and implement RDFE request XML.
-        # Currently Azure is throwing Internal Server Error when executing the
-        # API
+      # Serialize a firewall rule to xml
+      # @param rule [Azure::SqlDatabaseManagement::FirewallRule] The firewall rule to serialize
+      # @return [String] xml document contain the firewall rule
+      def self.firewall_rule_to_xml(rule)
         builder = Nokogiri::XML::Builder.new do |xml|
-          xml.FirewallRule('xmlns'=>'http://schemas.microsoft.com/sqlazure/2010/12/',
-            'xmlns:xsi'=>'http://www.w3.org/2001/XMLSchema-instance',
-            'xsi:schemaLocation'=>'http://schemas.microsoft.com/sqlazure/2010/12/ FirewallRule.xsd') {
-            xml.StartIpAddress options[:start_ip_address]
-            xml.EndIpAddress options[:end_ip_address]
+          xml.ServiceResource('xmlns' => 'http://schemas.microsoft.com/windowsazure') {
+            xml.Name rule.name
+            xml.StartIPAddress rule.start_ip_address
+            xml.EndIPAddress rule.end_ip_address
           }
         end
         builder.doc.to_xml
       end
 
+      # Create a list of firewall hashes from xml
+      # @param response_xml The xml containing the list of ServiceResources (firewall rules)
+      # @return [Array<Azure::SqlDatabaseManagement::FirewallRule>]
       def self.database_firewall_from_xml(response_xml)
-        firewalls = []
-        if Azure.config.sql_database_authentication_mode == :sql_server
-          database_firewallXML = response_xml.css('FirewallRules  FirewallRule')
-          database_firewallXML.each do |firewall_xml|
-            firewall = {
-              :rule => xml_content(firewall_xml, 'Name'),
-              :start_ip_address => xml_content(firewall_xml, 'StartIpAddress'),
-              :end_ip_address => xml_content(firewall_xml, 'EndIpAddress')
-            }
-            firewalls << firewall
-          end
-        else
-          service_resources = response_xml.css(
+        service_resources = response_xml.css(
             'ServiceResources ServiceResource'
-          )
-          service_resources.each do |resource|
-            type = xml_content(resource, 'Type')
-            if type == 'Microsoft.SqlAzure.FirewallRule'
-              firewall = {
-                rule: xml_content(resource, 'Name'),
-                start_ip_address: xml_content(resource, 'StartIPAddress'),
-                end_ip_address: xml_content(resource, 'EndIPAddress')
-              }
-              firewalls << firewall
-            end
+        )
+        service_resources.map do |resource|
+          FirewallRule.new do |rule|
+            rule.name = xml_content(resource, 'Name')
+            rule.type = xml_content(resource, 'Type')
+            rule.start_ip_address = xml_content(resource, 'StartIPAddress')
+            rule.end_ip_address = xml_content(resource, 'EndIPAddress')
           end
         end
-        firewalls.compact
       end
-
     end
   end
 end