azure-fix 0.7.0.pre3

data/lib/azure/service_bus/true_filter.rb

@@ -0,0 +1,38 @@
+#-------------------------------------------------------------------------
+# # 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.
+#--------------------------------------------------------------------------
+require 'azure/service_bus/sql_filter'
+
+module Azure
+  module ServiceBus
+    class TrueFilter < SqlFilter
+      # Public: Initialize the SQL True Filter.
+      #
+      # ==== Attributes
+      #
+      # * +hash+   - The resource options Hash
+      #
+      # ==== Options
+      #
+      # Accepted key/value pairs in options parameter are:
+      # * +:sql_expression+                                  - The SQL expression.
+      #
+      def initialize(hash=nil)
+        hash = {} unless hash
+        hash[:sql_expression] = "1 = 1" unless hash[:sql_expression]
+        super(hash)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+#-------------------------------------------------------------------------
+# 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/sql_database_management/sql_server'
+require 'azure/sql_database_management/firewall_rule'
+
+module Azure
+  module SqlDatabaseManagement
+    module Serialization
+      extend Azure::Core::Utility
+
+      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.AdministratorLogin login
+            xml.AdministratorLoginPassword password
+            xml.Location location
+            xml.Version version
+          }
+        end
+        builder.doc.to_xml
+      end
+
+      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
+      end
+
+      def self.server_name_from_xml(response_xml, login, location, version)
+        server_name = xml_content(response_xml, 'ServerName')
+        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/'})
+        end
+        builder.doc.to_xml
+      end
+
+      # 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.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)
+        service_resources = response_xml.css(
+            'ServiceResources ServiceResource'
+        )
+        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
+      end
+    end
+  end
+end

data/lib/azure/sql_database_management/sql_database_management_service.rb

@@ -0,0 +1,211 @@
+#-------------------------------------------------------------------------
+# 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 'socket'
+require 'azure/sql_database_management/sql_server'
+require 'azure/sql_database_management/firewall_rule'
+require 'azure/sql_database_management/serialization'
+require 'azure/sql_database_management/errors'
+
+module Azure
+  module SqlDatabaseManagement
+    # Service for managing SQL Azure servers and databases
+    class SqlDatabaseManagementService < BaseManagement::BaseManagementService
+
+      # Gets a list of database servers available under the current subscription.
+      #
+      # @see http://msdn.microsoft.com/en-us/library/azure/gg715269.aspx
+      #
+      # @return Array<Azure::SqlDatabaseManagement::SqlServer>
+      def list_servers
+        response = client.sql_management_request(:get, servers_path).call
+        Serialization.servers_from_xml(response)
+      end
+
+      # Create a new sql server in Microsoft Azure.
+      #
+      # @param login      [String] The administrator login name.
+      # @param password   [String] The administrator login password.
+      # @param location   [String] The location where the database server will be created.
+      # @param version    [String|Integer] The version of the SQL server (default 12.0)
+      #
+      # @see https://msdn.microsoft.com/en-us/library/azure/dn505699.aspx
+      #
+      # @return [Azure::SqlDatabaseManagement::SqlServer]
+      def create_server(login, password, location, version = 12.0)
+        body = Serialization.server_to_xml(login, password, location, version)
+        server_names = list_servers.map(&:name)
+        created_server = nil
+
+        begin
+          response = client.sql_management_request(:post, servers_path, body: body, warn: true).call
+          created_server = Serialization.server_name_from_xml(response, login, location, version)
+        rescue RuntimeError => ex
+          if ex.message =~ /Please retry the request/
+            created_server = list_servers.reject{|server| server_names.include?(server.name)}.first
+            # sometimes the service returns 500, but it doesn't really mean it.
+            #
+            # If the operation returns success, the operation is complete and the server is created immediately. If the
+            # operation fails because of a user error, a server is not created. If there is a communication error or
+            # internal server error, you should check the status of the operation using List Servers.
+            #
+            raise unless created_server
+          else
+            raise
+          end
+        end
+        Azure::Loggerx.info "SQL database server #{created_server.name} is created." if created_server
+        created_server
+      end
+
+      # Deletes the specified database server of given subscription id from Microsoft Azure.
+      #
+      # @param name     [String] SqlServer name.
+      #
+      # @see http://msdn.microsoft.com/en-us/library/azure/gg715285.aspx
+      #
+      # @return  [void]
+      def delete_server(name)
+        ensure_server_exists!(name)
+        client.sql_management_request(:delete, servers_path(name)).call
+        Azure::Loggerx.info "Deleted database server #{name}."
+      end
+
+      # Sets the administrative password of a SQL Database server for a subscription. Will raise
+      # Azure::SqlManagement::Error if server does not exist.
+      #
+      # @param name       [String] SqlServer name.
+      # @param password   [String] SqlServer new password.
+      #
+      # @see http://msdn.microsoft.com/en-us/library/azure/gg715272.aspx
+      #
+      # @return [void]
+      def reset_password(name, password)
+        ensure_server_exists!(name)
+        body = Serialization.reset_password_to_xml(password)
+        request_path = servers_path + "#{name}?op=ResetPassword"
+        request = client.sql_management_request(:post, request_path, body)
+        request.call
+        Azure::Loggerx.info "Password for server #{name} changed successfully."
+      end
+
+      # Adds a new server-level firewall or updates an existing server-level firewall rule for a SQL Database server.
+      #
+      # @param server_name    [String] SqlServer server name.
+      # @param rule_name      [String] Firewall rule name.
+      # @param start_ip       [String] The lowest IP address in the range of the server-level firewall setting.
+      #                                IP addresses equal to or greater than this can attempt to connect to the server.
+      #                                The lowest possible IP address is 0.0.0.0. (default: first local public ip)
+      # @param end_ip         [String] The highest IP address in the range of the server-level firewall setting. IP
+      #                                addresses equal to or less than this can attempt to connect to the server. The
+      #                                highest possible IP address is 255.255.255.255. (default: first local public ip)
+      #
+      # @see http://msdn.microsoft.com/en-us/library/azure/gg715280.aspx
+      #
+      # @return  [void]
+      def set_sql_server_firewall_rule(server_name, rule_name, start_ip = public_ipv4, end_ip = public_ipv4)
+
+        if [server_name, rule_name, start_ip, end_ip].any? { |arg| arg.nil? || arg.empty? || !arg.kind_of?(String) }
+          raise ArgumentError.new('Missing or empty parameter server_name, rule_name, start_ip or end_ip')
+        end
+
+        fw_rule = FirewallRule.new do |rule|
+          rule.name = rule_name
+          rule.start_ip_address = start_ip
+          rule.end_ip_address = end_ip
+        end
+
+        body = Serialization.firewall_rule_to_xml(fw_rule)
+        method = if list_sql_server_firewall_rules(server_name).any? { |rule| rule.name == rule_name }
+                   # the rule exists, so we need to update the rule
+                   :put
+                 else
+                   # the rule doesn't exist, so we need to create the rule
+                   :post
+                 end
+        request_path = servers_path "#{server_name}/firewallrules/#{method == :put ? rule_name : ''}"
+        client.sql_management_request(method, request_path, body).call
+        Azure::Loggerx.info "Modified server-level firewall rule #{rule_name}."
+      end
+
+      # Gets a list of server-level firewall rules set for SQL database servers. Will raise
+      # Azure::SqlManagement::Error if server does not exist.
+      #
+      # @param server_name   [String] Database server name.
+      #
+      # @see http://msdn.microsoft.com/en-us/library/azure/gg715278.aspx
+      #
+      # @return [Array<Azure::SqlDatabaseManagement::FirewallRule>]
+      def list_sql_server_firewall_rules(server_name)
+        ensure_server_exists!(server_name)
+        response = client.sql_management_request(:get, servers_path("#{server_name}/firewallrules")).call
+        Serialization.database_firewall_from_xml(response)
+      end
+
+      # Deletes a server-level firewall rule from a SQL Database server. Will raise
+      # Azure::SqlManagement::Error if server does not exist.
+      #
+      # @param server_name  [String] SQL database server name.
+      # @param rule_name    [String] SQL database server firewall rule name.
+      #
+      # @see http://msdn.microsoft.com/en-us/library/azure/gg715277.aspx
+      #
+      # @return  [void]
+      def delete_sql_server_firewall_rule(server_name, rule_name)
+        ensure_server_exists!(server_name)
+        if list_sql_server_firewall_rules(server_name).any? { |rule| rule.name == rule_name }
+          request_path = servers_path "#{server_name}/firewallrules/#{rule_name}"
+          client.sql_management_request(:delete, request_path).call
+          Azure::Loggerx.info "Deleted server-level firewall rule #{rule_name}."
+        else
+          raise RuleDoesNotExist.new("Firewall rule named #{rule_name} does not exist for server named #{server_name}")
+        end
+      end
+
+      private
+
+      def servers_path(end_path = '')
+        '/servers' + if end_path.start_with?('/')
+                       end_path
+                     elsif end_path.empty?
+                       ''
+                     else
+                       "/#{end_path}"
+                     end
+      end
+
+      # Ensures the a database server of a given name exists and raises Azure::SqlManagement::ServerDoesNotExist if it
+      # does not exist
+      #
+      # @param server_name [String] The name of the Azure SQL Server
+      # @return [void] Returns true if the server exists
+      def ensure_server_exists!(server_name)
+        raise ServerDoesNotExist.new("Server named #{server_name} does not exist.") unless server_exists?(server_name)
+      end
+
+      def server_exists?(server_name)
+        ArgumentError.new('Servername cannot be empty or null.') if server_name.empty?
+        list_servers.any? { |server| server.name == server_name }
+      end
+
+      def public_ipv4
+        @public_ip ||= `curl -s whatismyip.akamai.com`
+      end
+
+    end
+  end
+end
+
+Azure::SqlDatabaseManagementService = Azure::SqlDatabaseManagement::SqlDatabaseManagementService

data/lib/azure/sql_database_management/sql_server.rb

@@ -0,0 +1,32 @@
+#-------------------------------------------------------------------------
+# 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 SqlDatabaseManagement
+    class SqlServer
+
+      def initialize
+        yield self if block_given?
+      end
+
+      attr_accessor :name
+      attr_accessor :administrator_login
+      attr_accessor :location
+      attr_accessor :fully_qualified_domain_name
+      attr_accessor :version
+      attr_accessor :state
+
+    end
+  end
+end

data/lib/azure/storage_management/serialization.rb

@@ -0,0 +1,204 @@
+#-------------------------------------------------------------------------
+# 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 'base64'
+require 'azure/storage_management/storage_account'
+
+module Azure
+  module StorageManagement
+    # Storage management serialization module is responsible for converting
+    # the objects to XML and vice versa.
+    module Serialization
+      extend Azure::Core::Utility
+      def self.storage_services_to_xml(name, options = {})
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.CreateStorageServiceInput(
+            'xmlns' => 'http://schemas.microsoft.com/windowsazure'
+          ) do
+            xml.ServiceName(name)
+            label = options[:label] || name
+            xml.Label(Base64.encode64(label))
+            xml.Description options[:description]\
+              || 'Explicitly created storage service'
+            unless options[:affinity_group_name].nil?
+              xml.AffinityGroup options[:affinity_group_name]
+            else
+              xml.Location options[:location]
+            end
+            add_options_to_xml(xml, options)
+          end
+        end
+        builder.doc.to_xml
+      end
+
+      def self.storage_services_from_xml(storage_xml)
+        storage_accounts = []
+        storage_services_xml = storage_xml.css('StorageService')
+        storage_services_xml.each do |storage_service_xml|
+          storage_account = StorageAccount.new
+
+          storage_account.url = xml_content(storage_service_xml, 'Url')
+          storage_account.name = xml_content(
+            storage_service_xml, 'ServiceName'
+          )
+          storage_service_properties = storage_service_xml.css(
+            'StorageServiceProperties'
+          )
+          storage_account.description = xml_content(
+            storage_service_properties, 'Description'
+          )
+          storage_account.affinity_group = xml_content(
+            storage_service_properties, 'AffinityGroup'
+          )
+          storage_account.location = xml_content(
+            storage_service_properties, 'Location'
+          )
+          storage_account.label = Base64.decode64(
+            xml_content(storage_service_properties, 'Label')
+          )
+          storage_account.status = xml_content(
+            storage_service_properties, 'Status'
+          )
+          storage_account.endpoints = storage_service_properties.css(
+            'Endpoints Endpoint'
+          ).map { |endpoint| endpoint.content }
+          storage_account.geo_replication_enabled = xml_content(
+            storage_service_properties, 'GeoReplicationEnabled'
+          )
+          storage_account.account_type = xml_content(
+            storage_service_properties, 'AccountType'
+          )
+          storage_account.geo_primary_region = xml_content(
+            storage_service_properties, 'GeoPrimaryRegion'
+          )
+          storage_account.status_of_primary = xml_content(
+            storage_service_properties, 'StatusOfPrimary'
+          )
+          storage_account.last_geo_failover_time = xml_content(
+            storage_service_properties, 'LastGeoFailoverTime'
+          )
+          storage_account.geo_secondary_region = xml_content(
+            storage_service_properties, 'GeoSecondaryRegion'
+          )
+          storage_account.status_of_secondary = xml_content(
+            storage_service_properties, 'StatusOfSecondary'
+          )
+          storage_account.creation_time = xml_content(
+            storage_service_properties, 'CreationTime'
+          )
+          storage_account.extended_properties = storage_service_xml.css(
+            'ExtendedProperties ExtendedProperty'
+          ).map do |prop|
+            {
+              name: xml_content(prop, 'Name'),
+              value: xml_content(prop, 'Value')
+            }
+          end
+
+          storage_accounts << storage_account
+        end
+
+        storage_accounts.compact
+      end
+
+      def self.storage_update_to_xml(options)
+        # Cannot update if options is nil or empty
+        fail 'No options specified' if options.empty?
+
+        # Either one of Label, or Description is required.
+        if (options[:label].nil? || options[:label].empty?) &&
+            (options[:description].nil? || options[:description].empty?)
+          fail 'Either one of Label or Description'\
+            ' has to be provided. Both cannot be empty'
+        end
+
+        # The input param may not be nil or empty, but the values inside may
+        # be. Check if atleast one value exists before proceeding.
+        is_empty = true
+        options.each do |option, value|
+          case option
+          when :description, :label
+            is_empty = value.nil? || value.empty?
+          when :geo_replication_enabled
+            is_empty = !(value.is_a?(TrueClass) || value.is_a?(FalseClass))
+          when :extended_properties
+            value.each do |p, v|
+              is_empty = ((p.nil? || p.empty?) || (v.nil? || v.empty?))
+              break unless is_empty
+            end
+          end
+          break unless is_empty
+        end
+
+        # Raise a RuntimeError if no options were provided
+        fail 'No Options Specified' if is_empty
+
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.UpdateStorageServiceInput(
+            'xmlns' => 'http://schemas.microsoft.com/windowsazure'
+          ) do
+            # Check if label is nil. Use description only if label is nil
+            if options[:label].nil? || options[:label].empty?
+              desc = options[:description]
+              xml.Description(desc) unless desc.nil? || desc.empty?
+            else
+              label = Base64.encode64(options[:label])
+              xml.Label(label) unless label.nil? || label.empty?
+            end
+            add_options_to_xml(xml, options)
+          end
+        end
+        builder.to_xml
+      end
+
+      def self.add_options_to_xml(xml, options = {})
+        gre = options[:geo_replication_enabled]
+        xml.GeoReplicationEnabled(
+          gre
+        ) unless gre.nil? || !(gre.is_a?(TrueClass) || gre.is_a?(FalseClass))
+        xml.ExtendedProperties do
+          options[:extended_properties].each do |name, value|
+            xml.ExtendedProperty do
+              xml.Name name
+              xml.Value value
+            end unless (name.to_s.empty?) || (value.to_s.empty?)
+          end
+        end unless options[:extended_properties].to_s.empty?
+        xml.AccountType options[:account_type] if options[:account_type]
+      end
+
+      def self.storage_account_keys_from_xml(storage_xml)
+        storage_xml.css('StorageService')
+        storage_service_xml = storage_xml.css('StorageService').first
+        service_key_xml = storage_service_xml.css('StorageServiceKeys').first
+        storage_account_keys = StorageAccountKeys.new
+        storage_account_keys.url = xml_content(storage_service_xml, 'Url')
+        storage_account_keys.primary_key = xml_content(service_key_xml, 'Primary')
+        storage_account_keys.secondary_key = xml_content(service_key_xml, 'Secondary')
+        storage_account_keys
+      end
+
+      def self.regenerate_storage_account_keys_to_xml(key_type)
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.RegenerateKeys(
+            'xmlns' => 'http://schemas.microsoft.com/windowsazure'
+          ) do
+            xml.KeyType(key_type)
+          end
+        end
+        builder.doc.to_xml
+      end
+    end
+  end
+end