fog-azure-rm 0.0.9 → 0.1.0

data/lib/fog/azurerm/requests/sql/get_sql_server.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 Server fetched successfully in Resource Group: #{resource_group}"
           JSON.parse(response)

data/lib/fog/azurerm/requests/sql/list_databases.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 Databases listed successfully in Resource Group: #{resource_group}"
           JSON.parse(response)['value']

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

@@ -0,0 +1,55 @@
+module Fog
+  module Sql
+    class AzureRM
+      # Real class for Sql Server Firewall Rule Request
+      class Real
+        def list_firewall_rules(resource_group, server_name)
+          msg = "Listing Sql Server Firewall rules on 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/?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 Rules listed successfully on server: #{server_name} in Resource Group: #{resource_group}"
+          JSON.parse(response)['value']
+        end
+      end
+
+      # Mock class for Sql Server Firewall Rule Request
+      class Mock
+        def list_firewall_rules(*)
+          [
+            {
+              'id' => '{uri-of-firewall-rule}',
+              'name' => '{rule-name}',
+              'type' => '{rule-type}',
+              'location' => '{server-location}',
+              'properties' => {
+                'startIpAddress' => '{start-ip-address}',
+                'endIpAddress' => '{end-ip-address}'
+              }
+            },
+            {
+              '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

data/lib/fog/azurerm/requests/sql/list_sql_servers.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 Servers listed successfully in Resource Group: #{resource_group}"
           JSON.parse(response)['value']

data/lib/fog/azurerm/requests/storage/create_disk.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class provides the actual implemention for service calls.
+      class Real
+        def create_disk(blob_name, options = {})
+          msg = "Creating disk(blob) #{blob_name}"
+          Fog::Logger.debug msg
+          ::File.open('out.txt', 'w') { |f| f.write('Sample File') }
+          path = ::File.expand_path(::File.dirname('out.txt')) + '/' + 'out.txt'
+          begin
+            disk = upload_block_blob_from_file('vhds', "#{blob_name}.vhd", path.to_s, options)
+          rescue Azure::Core::Http::HTTPError => e
+            raise_azure_exception(e, msg)
+          end
+          disk
+        end
+      end
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def create_disk(*)
+          Fog::Logger.debug 'Disk(Blob) created successfully.'
+          {
+            'name' => 'test_blob',
+            'properties' =>
+              {
+                'last_modified' => 'Thu, 28 Jul 2016 06:53:05 GMT',
+                'etag' => '0x8D3B6B3D353FFCA',
+                'content_md5' => 'tXAohIyxuu/t94Lp/ujeRw=='
+              }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/storage/create_or_update_recovery_vault.rb

@@ -0,0 +1,54 @@
+module Fog
+  module Storage
+    class AzureRM
+      # Real class for Recovery Vault request
+      class Real
+        def create_or_update_recovery_vault(resource_group, location, name)
+          msg = "Creating/Updating Recovery Vault #{name} in Resource Group #{resource_group}"
+          Fog::Logger.debug msg
+
+          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{resource_group}/providers/Microsoft.RecoveryServices/vaults/#{name}?api-version=2016-05-01"
+          body = {
+            location: location,
+            tags: {},
+            sku: { name: 'standard' },
+            properties: {}
+          }
+          begin
+            token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
+            response = RestClient.put(
+              resource_url,
+              body.to_json,
+              accept: 'application/json',
+              content_type: 'application/json',
+              authorization: token
+            )
+          rescue RestClient::Exception => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Recovery Vault #{name} created/updated successfully"
+          JSON.parse(response)
+        end
+      end
+
+      # Mock class for Recovery Vault request
+      class Mock
+        def create_or_update_recovery_vault(*)
+          recovery_vault = '{
+            "location": "westus",
+            "name": "fog-test-vault",
+            "properties": {
+              "provisioningState": "Succeeded"
+            },
+            "id": "/subscriptions/########-####-####-####-############/resourceGroups/fog-test-rg/providers/Microsoft.RecoveryServices/vaults/fog-test-vault",
+            "type": "Microsoft.RecoveryServices/vaults",
+            "sku": {
+              "name": "standard"
+            }
+          }'
+          JSON.parse(recovery_vault)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/storage/create_storage_account.rb

@@ -8,7 +8,8 @@ module Fog
           Fog::Logger.debug msg
           storage_account_params = get_storage_account_params(storage_account_hash[:sku_name],
                                                               storage_account_hash[:location],
-                                                              storage_account_hash[:replication])
+                                                              storage_account_hash[:replication],
+                                                              storage_account_hash[:encryption])
           begin
             storage_account = @storage_mgmt_client.storage_accounts.create(storage_account_hash[:resource_group],
                                                                            storage_account_hash[:name],
@@ -22,13 +23,23 @@ module Fog
 
         private
 
-        def get_storage_account_params(sku_name, location, replication)
+        def get_storage_account_params(sku_name, location, replication, encryption_enabled)
           params = Azure::ARM::Storage::Models::StorageAccountCreateParameters.new
           sku = Azure::ARM::Storage::Models::Sku.new
           sku.name = "#{sku_name}_#{replication}"
           params.sku = sku
           params.kind = Azure::ARM::Storage::Models::Kind::Storage
           params.location = location
+          unless encryption_enabled.nil?
+            encryption = Azure::ARM::Storage::Models::Encryption.new
+            encryption_services = Azure::ARM::Storage::Models::EncryptionServices.new
+            encryption_service = Azure::ARM::Storage::Models::EncryptionService.new
+            encryption_service.enabled = encryption_enabled
+            encryption_service.last_enabled_time = Time.new if encryption_service.enabled
+            encryption_services.blob = encryption_service
+            encryption.services = encryption_services
+            params.encryption = encryption
+          end
           params
         end
       end

data/lib/fog/azurerm/requests/storage/delete_disk.rb

@@ -3,15 +3,11 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def delete_disk(resource_group, storage_account_name, blob_name)
+        def delete_disk(blob_name)
           msg = "Deleting Disk: #{blob_name}."
           Fog::Logger.debug msg
-          keys = get_storage_access_keys(resource_group, storage_account_name)
-          access_key = keys[1].value
-          client = Azure::Storage::Client.new(storage_account_name: storage_account_name, storage_access_key: access_key)
-          blob_service = Azure::Storage::Blob::BlobService.new(client: client)
           begin
-            result = blob_service.delete_blob('vhds', "#{blob_name}.vhd")
+            result = delete_blob('vhds', "#{blob_name}.vhd")
           rescue Azure::Core::Http::HTTPError => e
             raise_azure_exception(e, msg)
           end
@@ -26,9 +22,9 @@ module Fog
       end
       # This class provides the mock implementation for unit tests.
       class Mock
-        def delete_disk(_resource_group, _storage_account_name, blob_name)
-          Fog::Logger.debug "Deleting Disk: #{blob_name}."
-          Fog::Logger.debug "Successfully deleted Disk: #{blob_name}."
+        def delete_disk(*)
+          Fog::Logger.debug 'Deleting Disk: test_blob.'
+          Fog::Logger.debug 'Successfully deleted Disk: test_blob.'
           true
         end
       end

data/lib/fog/azurerm/requests/storage/delete_recovery_vault.rb

@@ -0,0 +1,35 @@
+module Fog
+  module Storage
+    class AzureRM
+      # Real class for Recovery Vault request
+      class Real
+        def delete_recovery_vault(resource_group, name)
+          msg = "Deleting Recovery Vault #{name} from Resource Group #{resource_group}"
+          Fog::Logger.debug msg
+          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{resource_group}/providers/Microsoft.RecoveryServices/vaults/#{name}?api-version=2016-05-01"
+          begin
+            token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
+            RestClient.delete(
+              resource_url,
+              accept: 'application/json',
+              content_type: 'application/json',
+              authorization: token
+            )
+          rescue RestClient::Exception => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Recovery Vault #{name} in Resource Group #{resource_group} deleted successfully"
+          true
+        end
+      end
+
+      # Mock class for Recovery Vault request
+      class Mock
+        def delete_recovery_vault(*)
+          Fog::Logger.debug 'Recovery Vault TestVault in Resource Group TestRG deleted successfully'
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/storage/disable_backup_protection.rb

@@ -0,0 +1,60 @@
+PROTECTION_STOPPED = 'ProtectionStopped'.freeze
+
+module Fog
+  module Storage
+    class AzureRM
+      # Real class for Recovery Vault request
+      class Real
+        def disable_backup_protection(rv_name, rv_resource_group, vm_name, vm_resource_group)
+          msg = "Disabling protection for VM #{vm_name} in Recovery Vault #{rv_name}"
+          Fog::Logger.debug msg
+
+          set_recovery_vault_context(rv_resource_group, rv_name)
+          vm_id = get_virtual_machine_id(vm_resource_group, vm_name)
+
+          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{rv_resource_group}/providers/Microsoft.RecoveryServices/vaults/#{rv_name}/backupFabrics/Azure/protectionContainers/iaasvmcontainer;iaasvmcontainerv2;#{vm_resource_group.downcase};#{vm_name.downcase}/protectedItems/vm;iaasvmcontainerv2;#{vm_resource_group.downcase};#{vm_name.downcase}?api-version=2016-05-01"
+          body = {
+            properties: {
+              protectedItemType: 'Microsoft.Compute/virtualMachines',
+              policyId: '',
+              sourceResourceId: vm_id,
+              protectionState: PROTECTION_STOPPED
+            },
+            tags: {}
+          }
+
+          begin
+            token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
+            RestClient.put(
+              resource_url,
+              body.to_json,
+              accept: 'application/json',
+              content_type: 'application/json',
+              authorization: token
+            )
+          rescue RestClient::Exception => e
+            raise_azure_exception(e, msg)
+          end
+
+          Fog::Logger.debug "Successfully disabled protection for VM #{vm_name} in Recovery Vault #{rv_name}"
+          true
+        end
+
+        private
+        
+        def get_virtual_machine_id(vm_resource_group, vm_name)
+          compute_service = Fog::Compute::AzureRM.new(tenant_id: @tenant_id, client_id: @client_id, client_secret: @client_secret, subscription_id: @subscription_id)
+          compute_service.get_virtual_machine(vm_resource_group, vm_name).id
+        end
+      end
+
+      # Mock class for Recovery Vault request
+      class Mock
+        def disable_backup_protection(*)
+          Fog::Logger.debug 'Successfully disabled protection for VM {vm_name} in Recovery Vault {rv_name}'
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/storage/enable_backup_protection.rb

@@ -0,0 +1,61 @@
+CONFIGURE_BACKUP = 'ConfigureBackup'.freeze
+
+module Fog
+  module Storage
+    class AzureRM
+      # Real class for Recovery Vault request
+      class Real
+        def enable_backup_protection(rv_name, rv_resource_group, vm_name, vm_resource_group)
+          msg = "Enabling backup protection for VM #{vm_name} in Resource Group #{vm_resource_group}"
+          Fog::Logger.debug msg
+
+          set_recovery_vault_context(rv_resource_group, rv_name)
+          backup_protection_policy = get_backup_protection_policy(rv_resource_group, rv_name)
+          policy = backup_protection_policy.select { |item| item['name'].eql? 'DefaultPolicy' }[0]
+          vm_id = get_virtual_machine_id(vm_resource_group, vm_name)
+
+          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{rv_resource_group}/providers/Microsoft.RecoveryServices/vaults/#{rv_name}/backupFabrics/Azure/protectionContainers/iaasvmcontainer;iaasvmcontainerv2;#{vm_resource_group.downcase};#{vm_name.downcase}/protectedItems/vm;iaasvmcontainerv2;#{vm_resource_group.downcase};#{vm_name.downcase}?api-version=2016-05-01"
+          body = {
+            properties: {
+              protectedItemType: 'Microsoft.Compute/virtualMachines',
+              policyId: policy['id'],
+              sourceResourceId: vm_id
+            },
+            tags: {}
+          }
+
+          begin
+            token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
+            RestClient.put(
+              resource_url,
+              body.to_json,
+              accept: 'application/json',
+              content_type: 'application/json',
+              authorization: token
+            )
+          rescue RestClient::Exception => e
+            raise_azure_exception(e, msg)
+          end
+
+          @job = get_backup_job_for_vm(rv_name, rv_resource_group, vm_name, vm_resource_group, CONFIGURE_BACKUP)
+
+          until @job.nil?
+            sleep 10
+            @job = get_backup_job_for_vm(rv_name, rv_resource_group, vm_name, vm_resource_group, CONFIGURE_BACKUP)
+          end
+
+          Fog::Logger.debug "Successfully enabled backup protection for VM #{vm_name} in Resource Group #{vm_resource_group}"
+          true
+        end
+      end
+
+      # Mock class for Recovery Vault request
+      class Mock
+        def enable_backup_protection(*)
+          Fog::Logger.debug 'Successfully enabled backup protection for VM {vm_name} in Resource Group {vm_resource_group}'
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/storage/get_all_backup_jobs.rb

@@ -0,0 +1,56 @@
+module Fog
+  module Storage
+    class AzureRM
+      # Real class for Recovery Vault request
+      class Real
+        def get_all_backup_jobs(rv_name, rv_resource_group)
+          msg = "Getting all backup jobs for Recovery Vault #{rv_name}"
+          Fog::Logger.debug msg
+
+          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{rv_resource_group}/providers/Microsoft.RecoveryServices/vaults/#{rv_name}/backupJobs?api-version=2016-05-01&$filter=status eq 'InProgress'"
+          begin
+            token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
+            response = RestClient.get(
+              resource_url,
+              accept: 'application/json',
+              content_type: 'application/json',
+              authorization: token
+            )
+          rescue RestClient::Exception => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Successfully retrieved backup jobs for Recovery Vault #{rv_name}"
+          JSON.parse(response)['value']
+        end
+      end
+
+      # Mock class for Recovery Vault request
+      class Mock
+        def get_all_backup_jobs(*)
+          body = '{
+            "value": [{
+              "id": "/subscriptions/########-####-####-####-############/resourceGroups/fog-test-rg/providers/Microsoft.RecoveryServices/vaults/fog-test-vault/backupJobs/########-####-####-####-############",
+              "name": "########-####-####-####-############",
+              "type": "Microsoft.RecoveryServices/vaults/backupJobs",
+              "properties": {
+                "jobType": "AzureIaaSVMJob",
+                "duration": "XX:XX:XX.XXXXXXX",
+                "actionsInfo": [
+                  1
+                ],
+                "virtualMachineVersion": "Compute",
+                "entityFriendlyName": "fog-test-vm",
+                "backupManagementType": "AzureIaasVM",
+                "operation": "Backup",
+                "status": "InProgress",
+                "startTime": "2016-10-19T07:49:31.1466534Z",
+                "activityId": "########-####-####-####-############"
+              }
+            }]
+          }'
+          JSON.parse(body)['value']
+        end
+      end
+    end
+  end
+end