fog-azure-rm 0.0.9 → 0.1.0

data/lib/fog/azurerm/models/storage/data_disk.rb

@@ -9,6 +9,7 @@ module Fog
         attribute :vhd_uri
         attribute :caching
         attribute :create_option
+        attribute :file_path
 
         def self.parse(disk)
           hash = {}

data/lib/fog/azurerm/models/storage/directories.rb

@@ -1,12 +1,9 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/storage/directory'
-
 module Fog
   module Storage
     class AzureRM
       # This class is giving implementation of listing containers.
       class Directories < Fog::Collection
-        model Fog::Storage::AzureRM::Directory
+        model Directory
 
         def all(options = { metadata: true })
           containers = []

data/lib/fog/azurerm/models/storage/files.rb

@@ -1,12 +1,9 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/storage/file'
-
 module Fog
   module Storage
     class AzureRM
       # This class is giving implementation of listing blobs.
       class Files < Fog::Collection
-        model Fog::Storage::AzureRM::File
+        model File
         attribute :directory
 
         def all(options = { metadata: true })

data/lib/fog/azurerm/models/storage/recovery_vault.rb

@@ -0,0 +1,50 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for Recovery Vault.
+      class RecoveryVault < Fog::Model
+        attribute :id
+        identity :name
+        attribute :resource_group
+        attribute :location
+        attribute :type
+        attribute :sku_name
+
+        def self.parse(recovery_vault)
+          {
+            id: recovery_vault['id'],
+            name: recovery_vault['name'],
+            resource_group: get_resource_group_from_id(recovery_vault['id']),
+            location: recovery_vault['location'],
+            type: recovery_vault['type'],
+            sku_name: recovery_vault['sku']['name']
+          }
+        end
+
+        def save
+          requires :name, :location, :resource_group
+          recovery_vault = service.create_or_update_recovery_vault(resource_group, location, name)
+          merge_attributes(RecoveryVault.parse(recovery_vault))
+        end
+
+        def enable_backup_protection(vm_name, vm_resource_group)
+          requires :name, :resource_group
+          service.enable_backup_protection(name, resource_group, vm_name, vm_resource_group)
+        end
+
+        def start_backup(vm_name, vm_resource_group)
+          service.start_backup(resource_group, name, vm_name, vm_resource_group)
+        end
+
+        def disable_backup_protection(vm_name, vm_resource_group)
+          service.disable_backup_protection(name, resource_group, vm_name, vm_resource_group)
+        end
+
+        def destroy
+          service.delete_recovery_vault(resource_group, name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/storage/recovery_vaults.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of all/get for Recovery Vaults
+      class RecoveryVaults < Fog::Collection
+        model RecoveryVault
+        attribute :resource_group
+        attribute :name
+
+        def all
+          requires :resource_group
+          recovery_vaults = []
+          service.list_recovery_vaults(resource_group).each do |recovery_vault|
+            recovery_vaults << RecoveryVault.parse(recovery_vault)
+          end
+          load(recovery_vaults)
+        end
+
+        def get(resource_group, name)
+          recovery_vault = service.get_recovery_vault(resource_group, name)
+          recovery_vault_obj = RecoveryVault.new(service: service)
+          recovery_vault_obj.merge_attributes(RecoveryVault.parse(recovery_vault))
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/storage/storage_account.rb

@@ -5,10 +5,12 @@ module Fog
       # delete/destroy for storage account.
       class StorageAccount < Fog::Model
         identity  :name
+        attribute :id
         attribute :location
         attribute :resource_group
         attribute :sku_name
         attribute :replication
+        attribute :encryption
 
         def self.parse(storage_account)
           hash = {}
@@ -18,6 +20,7 @@ module Fog
           hash['resource_group'] = get_resource_group_from_id(storage_account.id)
           hash['sku_name'] = storage_account.sku.name.split('_').first
           hash['replication'] = storage_account.sku.name.split('_').last
+          hash['encryption'] = storage_account.encryption.services.blob.enabled unless storage_account.encryption.nil?
           hash
         end
 
@@ -29,9 +32,8 @@ module Fog
           self.sku_name = STANDARD_STORAGE if sku_name.nil?
           self.replication = ALLOWED_STANDARD_REPLICATION.first if replication.nil?
           validate_sku_name!
-          storage_account_arguments = get_storage_account_arguments
-          storage_account = service.create_storage_account(storage_account_arguments)
-          merge_attributes(Fog::Storage::AzureRM::StorageAccount.parse(storage_account))
+          storage_account = service.create_storage_account(get_storage_account_arguments)
+          merge_attributes(StorageAccount.parse(storage_account))
         end
 
         def get_storage_account_arguments
@@ -40,10 +42,19 @@ module Fog
             name: name,
             sku_name: sku_name,
             location: location,
-            replication: replication
+            replication: replication,
+            encryption: encryption
           }
         end
 
+        def update(storage_account_params)
+          validate_input(storage_account_params)
+          storage_account_params = merge_attributes(storage_account_params).all_attributes
+
+          storage_account = service.update_storage_account(storage_account_params)
+          merge_attributes(StorageAccount.parse(storage_account))
+        end
+
         def validate_sku_name!
           case sku_name
           when STANDARD_STORAGE
@@ -63,6 +74,14 @@ module Fog
           service.delete_storage_account(resource_group, name)
         end
 
+        private
+
+        def validate_input(attr_hash)
+          invalid_attr = [:resource_group, :name, :location, :id]
+          result = invalid_attr & attr_hash.keys
+          raise 'Cannot modify the given attribute' unless result.empty?
+        end
+
         private :get_storage_account_arguments, :validate_sku_name!
       end
     end

data/lib/fog/azurerm/models/storage/storage_accounts.rb

@@ -1,14 +1,12 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/storage/storage_account'
-
 module Fog
   module Storage
     class AzureRM
       # This class is giving implementation of all/list, get and
       # check name availability for storage account.
       class StorageAccounts < Fog::Collection
-        model Fog::Storage::AzureRM::StorageAccount
+        model StorageAccount
         attribute :resource_group
+
         def all
           accounts = []
           if !resource_group.nil?
@@ -18,15 +16,15 @@ module Fog
             hash_of_storage_accounts = service.list_storage_accounts
           end
           hash_of_storage_accounts.each do |account|
-            accounts << Fog::Storage::AzureRM::StorageAccount.parse(account)
+            accounts << StorageAccount.parse(account)
           end
           load(accounts)
         end
 
         def get(resource_group_name, storage_account_name)
           storage_account = service.get_storage_account(resource_group_name, storage_account_name)
-          storage_account_object = Fog::Storage::AzureRM::StorageAccount.new(service: service)
-          storage_account_object.merge_attributes(Fog::Storage::AzureRM::StorageAccount.parse(storage_account))
+          storage_account_object = StorageAccount.new(service: service)
+          storage_account_object.merge_attributes(StorageAccount.parse(storage_account))
         end
 
         def check_name_availability(name)

data/lib/fog/azurerm/requests/sql/create_or_update_database.rb

@@ -7,7 +7,7 @@ module Fog
           msg = "Creating SQL Database: #{database_hash[:name]}."
           Fog::Logger.debug msg
           resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{database_hash[:resource_group]}/providers/Microsoft.Sql/servers/#{database_hash[:server_name]}/databases/#{database_hash[:name]}?api-version=2014-04-01-preview"
-          request_parameters = format_database_parameters(database_hash[:location], database_hash[:create_mode], database_hash[:edition], database_hash[:source_database_id], database_hash[:collation], database_hash[:max_size_bytes], database_hash[:requested_service_objective_name], database_hash[:restore_point_in_time], database_hash[:source_database_deletion_date], database_hash[:elastic_pool_name], database_hash[:requested_service_objective_id])
+          request_parameters = get_database_parameters(database_hash[:location], database_hash[:create_mode], database_hash[:edition], database_hash[:source_database_id], database_hash[:collation], database_hash[:max_size_bytes], database_hash[:requested_service_objective_name], database_hash[:restore_point_in_time], database_hash[:source_database_deletion_date], database_hash[:elastic_pool_name], database_hash[:requested_service_objective_id])
           begin
             token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
             response = RestClient.put(
@@ -17,8 +17,8 @@ module Fog
               content_type: :json,
               authorization: token
             )
-          rescue MsRestAzure::AzureOperationError => e
-            raise_azure_exception(e, JSON.parse(e.response)['message'])
+          rescue RestClient::Exception => e
+            raise JSON.parse(e.response)['message']
           end
           Fog::Logger.debug "SQL Database: #{database_hash[:name]} created successfully."
           JSON.parse(response)
@@ -26,7 +26,7 @@ module Fog
 
         private
 
-        def format_database_parameters(location, create_mode, edition, source_database_id, collation, max_size_bytes, requested_service_objective_name, restore_point_in_time, source_database_deletion_date, elastic_pool_name, requested_service_objective_id)
+        def get_database_parameters(location, create_mode, edition, source_database_id, collation, max_size_bytes, requested_service_objective_name, restore_point_in_time, source_database_deletion_date, elastic_pool_name, requested_service_objective_id)
           parameters = {}
           properties = {}
 

data/lib/fog/azurerm/requests/sql/create_or_update_firewall_rule.rb

@@ -0,0 +1,56 @@
+module Fog
+  module Sql
+    class AzureRM
+      # Real class for Firewall Rule Request
+      class Real
+        def create_or_update_firewall_rule(firewall_hash)
+          msg = "Creating SQL Firewall Rule : #{firewall_hash[:name]}."
+          Fog::Logger.debug msg
+
+          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{firewall_hash[:resource_group]}/providers/Microsoft.Sql/servers/#{firewall_hash[:server_name]}/firewallRules/#{firewall_hash[:name]}?api-version=2014-04-01-preview"
+          request_parameters = get_server_firewall_parameters(firewall_hash[:start_ip], firewall_hash[:end_ip])
+          begin
+            token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
+            response = RestClient.put(
+              resource_url,
+              request_parameters.to_json,
+              accept: :json,
+              content_type: :json,
+              authorization: token
+            )
+          rescue RestClient::Exception => e
+            raise JSON.parse(e.response)['message']
+          end
+          Fog::Logger.debug "SQL Firewall Rule : #{firewall_hash[:name]} created successfully."
+          JSON.parse(response)
+        end
+
+        private
+
+        def get_server_firewall_parameters(start_ip, end_ip)
+          parameters = {}
+          properties = {}
+
+          properties['startIpAddress'] = start_ip
+          properties['endIpAddress'] = end_ip
+
+          parameters['properties'] = properties
+
+          parameters
+        end
+      end
+
+      # Mock class for Sql Firewall Rule Request
+      class Mock
+        def create_or_update_firewall_rule(*)
+          {
+            'properties' => {
+              'startIpAddress' => '{start-ip-address}',
+              'endIpAddress' => '{end-ip-address}'
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/sql/create_or_update_sql_server.rb

@@ -7,7 +7,7 @@ module Fog
           msg = "Creating SQL Server: #{server_hash[:name]}."
           Fog::Logger.debug msg
           resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{server_hash[:resource_group]}/providers/Microsoft.Sql/servers/#{server_hash[:name]}?api-version=2014-04-01-preview"
-          request_parameters = format_server_parameters(server_hash[:location], server_hash[:version], server_hash[:administrator_login], server_hash[:administrator_login_password])
+          request_parameters = get_server_parameters(server_hash[:location], server_hash[:version], server_hash[:administrator_login], server_hash[:administrator_login_password])
           begin
             token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
             response = RestClient.put(
@@ -17,9 +17,8 @@ module Fog
               content_type: :json,
               authorization: token
             )
-
-          rescue MsRestAzure::AzureOperationError => e
-            raise_azure_exception(e, JSON.parse(e.response)['message'])
+          rescue RestClient::Exception => e
+            raise JSON.parse(e.response)['message']
           end
           Fog::Logger.debug "SQL Server: #{server_hash[:name]} created successfully."
           JSON.parse(response)
@@ -27,7 +26,7 @@ module Fog
 
         private
 
-        def format_server_parameters(location, version, admin_login, admin_password)
+        def get_server_parameters(location, version, admin_login, admin_password)
           parameters = {}
           properties = {}
 

data/lib/fog/azurerm/requests/sql/delete_database.rb

@@ -15,11 +15,11 @@ module Fog
               content_type: :json,
               authorization: token
             )
-            Fog::Logger.debug "SQL Database: #{name} deleted successfully."
-            true
-          rescue MsRestAzure::AzureOperationError => e
-            raise_azure_exception(e, JSON.parse(e.response)['message'])
+          rescue RestClient::Exception => e
+            raise JSON.parse(e.response)['message']
           end
+          Fog::Logger.debug "SQL Database: #{name} deleted successfully."
+          true
         end
       end
 

data/lib/fog/azurerm/requests/sql/delete_firewall_rule.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Sql
+    class AzureRM
+      # Real class for Sql Firewall Rule Request
+      class Real
+        def delete_firewall_rule(resource_group, server_name, rule_name)
+          msg = "Deleting SQL Firewall Rule: #{rule_name}."
+          Fog::Logger.debug msg
+
+          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{resource_group}/providers/Microsoft.Sql/servers/#{server_name}/firewallRules/#{rule_name}?api-version=2014-04-01-preview"
+          begin
+            token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
+            RestClient.delete(
+              resource_url,
+              accept: :json,
+              content_type: :json,
+              authorization: token
+            )
+            Fog::Logger.debug "SQL Firewall Rule: #{rule_name} deleted successfully."
+            true
+          rescue RestClient::Exception => e
+            raise JSON.parse(e.response)['message']
+          end
+        end
+      end
+
+      # Mock class for Sql Firewall Rule Request
+      class Mock
+        def delete_firewall_rule(*)
+          Fog::Logger.debug 'SQL Firewall Rule {name} from SQL Server {server_name}, Resource group {resource_group} deleted successfully.'
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/sql/delete_sql_server.rb

@@ -17,8 +17,8 @@ module Fog
             )
             Fog::Logger.debug "SQL Server: #{name} deleted successfully."
             true
-          rescue MsRestAzure::AzureOperationError => e
-            raise_azure_exception(e, JSON.parse(e.response)['message'])
+          rescue RestClient::Exception => e
+            raise JSON.parse(e.response)['message']
           end
         end
       end

data/lib/fog/azurerm/requests/sql/get_database.rb

@@ -15,8 +15,8 @@ module Fog
               content_type: :json,
               authorization: token
             )
-          rescue MsRestAzure::AzureOperationError => e
-            raise_azure_exception(e, JSON.parse(e.response)['message'])
+          rescue RestClient::Exception => e
+            raise JSON.parse(e.response)['message']
           end
           Fog::Logger.debug "Sql Database fetched successfully in Resource Group: #{resource_group}"
           JSON.parse(response)

data/lib/fog/azurerm/requests/sql/get_firewall_rule.rb

@@ -0,0 +1,43 @@
+module Fog
+  module Sql
+    class AzureRM
+      # Real class for Sql Server Firewall Rule Request
+      class Real
+        def get_firewall_rule(resource_group, server_name, rule_name)
+          msg = "Getting Sql Server Firewall Rule: #{rule_name} from SQL Server: #{server_name} in Resource Group: #{resource_group}..."
+          Fog::Logger.debug msg
+          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{resource_group}/providers/Microsoft.Sql/servers/#{server_name}/firewallRules/#{rule_name}?api-version=2014-04-01-preview"
+          begin
+            token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
+            response = RestClient.get(
+              resource_url,
+              accept: :json,
+              content_type: :json,
+              authorization: token
+            )
+          rescue RestClient::Exception => e
+            raise JSON.parse(e.response)['message']
+          end
+          Fog::Logger.debug "Sql Server Firewall Rule fetched successfully from Server: #{server_name}, Resource Group: #{resource_group}"
+          JSON.parse(response)
+        end
+      end
+
+      # Mock class for Sql Server Firewall Rule Request
+      class Mock
+        def get_firewall_rule(*)
+          {
+            'id' => '{uri-of-firewall-rule}',
+            'name' => '{rule-name}',
+            'type' => '{rule-type}',
+            'location' => '{server-location}',
+            'properties' => {
+              'startIpAddress' => '{start-ip-address}',
+              'endIpAddress' => '{end-ip-address}'
+            }
+          }
+        end
+      end
+    end
+  end
+end