juliusl-azure-sdk-for-ruby 0.7.0

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/serialization.rb

@@ -0,0 +1,112 @@
+#-------------------------------------------------------------------------
+# 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_database'
+
+module Azure
+  module SqlDatabaseManagement
+    module Serialization
+      extend Azure::Core::Utility
+
+      def self.database_to_xml(login, password, location)
+        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
+          }
+        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
+        end
+        databases.compact
+      end
+
+      def self.server_name_from_xml(response_xml, login, location)
+        server_name = xml_content(response_xml, 'ServerName')
+        SqlDatabase.new do |db|
+          db.name = server_name
+          db.location = location
+          db.administrator_login = login
+        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
+
+      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
+        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]
+          }
+        end
+        builder.doc.to_xml
+      end
+
+      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(
+            '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
+          end
+        end
+        firewalls.compact
+      end
+
+    end
+  end
+end

data/lib/azure/sql_database_management/sql_database.rb

@@ -0,0 +1,31 @@
+#-------------------------------------------------------------------------
+# 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 SqlDatabase
+
+      def initialize
+        yield self if block_given?
+      end
+
+      attr_accessor :name
+      attr_accessor :administrator_login
+      attr_accessor :location
+      attr_accessor :feature_name
+      attr_accessor :feature_value
+
+    end
+  end
+end

data/lib/azure/sql_database_management/sql_database_management_service.rb

@@ -0,0 +1,200 @@
+#-------------------------------------------------------------------------
+# 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/serialization'
+
+module Azure
+  module SqlDatabaseManagement
+    class SqlDatabaseManagementService < BaseManagement::BaseManagementService
+
+      def initialize
+        super()
+      end
+
+      # Public: Gets a list of database servers available under the
+      # current subscription.
+      #
+      # See http://msdn.microsoft.com/en-us/library/azure/gg715269.aspx
+      #
+      # Returns an array of Azure::SqlDatabaseManagement::SqlDatabase objects
+      def list_servers
+        request_path = '/servers'
+        request = BaseManagement::SqlManagementHttpRequest.new(:get, request_path, nil)
+        response = request.call
+        Serialization.databases_from_xml(response)
+      end
+
+      # Public: Create a new database server in Microsoft Azure.
+      #
+      # ==== Attributes
+      #
+      # * +login+          - String. The administrator login name.
+      # * +password+       - String. The administrator login password.
+      # * +:location+      - String. The location where the database server will be created.
+      #
+      # See http://msdn.microsoft.com/en-us/library/azure/gg715274.aspx
+      #
+      # Returns Azure::SqlDatabaseManagement::SqlDatabase object
+      def create_server(login, password, location)
+        body = Serialization.database_to_xml(login, password, location)
+        request_path = '/servers'
+        request = BaseManagement::SqlManagementHttpRequest.new(:post, request_path, body)
+        response = request.call
+        sql_server = Serialization.server_name_from_xml(response, login, location)
+        Azure::Loggerx.info "SQL database server #{sql_server.name} is created." if sql_server
+        sql_server
+      end
+
+      # Public: Deletes the specified database server of given
+      # subscription id from Microsoft Azure.
+      #
+      # ==== Attributes
+      #
+      # * +name+       - String. Database server name.
+      #
+      # See http://msdn.microsoft.com/en-us/library/azure/gg715285.aspx
+      #
+      # Returns:  None
+      def delete_server(name)
+        if get_sql_server(name)
+          request_path = "/servers/#{name}"
+          request = BaseManagement::SqlManagementHttpRequest.new(:delete, request_path)
+          request.call
+          Azure::Loggerx.info "Deleted database server #{name}."
+        end
+      end
+
+      # Public: Sets the administrative password of a SQL Database server
+      # for a subscription.
+      #
+      # ==== Attributes
+      #
+      # * +name+           - String. Database server name.
+      # * +password+       - String. Database server new password.
+      #
+      # See http://msdn.microsoft.com/en-us/library/azure/gg715272.aspx
+      #
+      # Returns:  None
+      def reset_password(name, password)
+        if get_sql_server(name)
+          body = Serialization.reset_password_to_xml(password)
+          request_path = "/servers/#{name}?op=ResetPassword"
+          request = BaseManagement::SqlManagementHttpRequest.new(:post, request_path, body)
+          request.call
+          Azure::Loggerx.info "Password for server #{name} changed successfully."
+        end
+      end
+
+      # Public: The Set Server Firewall Rule operation for the given
+      # subscription adds a new server-level firewall or updates an
+      # existing server-level firewall rule for a SQL Database server.
+      #
+      # ==== Attributes
+      #
+      # * +server_name+    - String. Database server name.
+      # * +rule_name+      - String. Database server new password.
+      #
+      #  ==== Options
+      #
+      # Accepted key/value pairs are:
+      # * +:start_ip_address+     - String. Start of the IP Range
+      # * +:end_ip_address+       - String. End of the IP Range
+      # 
+      # See http://msdn.microsoft.com/en-us/library/azure/gg715280.aspx
+      #
+      # Returns:  None
+      def set_sql_server_firewall_rule(server_name, rule_name, options = {})
+        unless server_name.class == String && rule_name.class == String
+          raise "Missing parameter server_name or rule_name."
+        end
+        if get_sql_server(server_name)
+          if options[:start_ip_address] || options[:end_ip_address]
+            body = Serialization.firewall_rule_to_xml(options)
+            request_path = "/servers/#{server_name}/firewallrules/#{rule_name}"
+            method = :put
+          else
+            request_path = "/servers/#{server_name}/firewallrules/#{rule_name}?op=AutoDetectClientIP"
+            method = :post
+          end
+          request = BaseManagement::SqlManagementHttpRequest.new(method, request_path, body)
+          request.headers['x-ms-version'] = '1.0'
+          request.uri = URI.parse(Azure.config.sql_database_management_endpoint + Azure.config.subscription_id + request_path)
+          # Management certificate authentication Endpoint throws errors for this operation. Need to re-visit
+          # this once the Azure API is working.
+
+          request.call
+          Azure::Loggerx.info "Added server-level firewall rule #{rule_name}."
+        end
+      end
+
+      # Public: Gets a list of server-level firewall rules set for
+      # SQL database server.
+      #
+      # ==== Attributes
+      #
+      # * +server_name+    - String. Database server name.
+      #
+      # See http://msdn.microsoft.com/en-us/library/azure/gg715278.aspx
+      #
+      # Returns an array of firewall
+      def list_sql_server_firewall_rules(server_name)
+        if get_sql_server(server_name)
+          request_path = "/servers/#{server_name}/firewallrules"
+          request = BaseManagement::SqlManagementHttpRequest.new(:get, request_path)
+          response = request.call
+          Serialization.database_firewall_from_xml(response)
+        end
+      end
+
+      # Public: Deletes a server-level firewall rule from a SQL Database server.
+      #
+      # ==== Attributes
+      #
+      # * +name+            - String. SQL database server name.
+      # * +rule_name+       - String. SQL database server firewall rule name.
+      #
+      # See http://msdn.microsoft.com/en-us/library/azure/gg715277.aspx
+      #
+      # Returns:  None
+      def delete_sql_server_firewall_rule(server_name, rule_name)
+        if !list_sql_server_firewall_rules(server_name).collect{|x| x[:rule]}.include?(rule_name)
+          error = "The specified firewall rule #{rule_name} does not exist."
+          raise error
+        elsif get_sql_server(server_name)
+          request_path = "/servers/#{server_name}/firewallrules/#{rule_name}"
+          request = BaseManagement::SqlManagementHttpRequest.new(:delete, request_path)
+          request.call
+          Azure::Loggerx.info "Deleted server-level firewall rule #{rule_name}."
+        end
+      end
+
+      private
+
+      def get_sql_server(server_name)
+        if server_name.empty?
+          error = Azure::Error::Error.new("DatabaseServerNotFound", 40645,  "Servername cannot be empty or null.")
+        else
+          sql_server = list_servers.collect(&:name).include?(server_name)
+          if sql_server
+            return sql_server
+          else
+            error = Azure::Error::Error.new("DatabaseServerNotFound", 40647,  "Subscription #{Azure.config.subscription_id} does not have server #{server_name}.")
+          end
+        end
+        raise error if error
+      end
+
+    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