fog-azure-rm-temp 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ddafc1d170ef4e73a60717a3b4316616f21b9bf1
-  data.tar.gz: 338b0d9155871c2849bdde8587b6317a930ffc4b
+  metadata.gz: 3289ed97aa95d2ba48f1753d19326183d1a6958b
+  data.tar.gz: 678a07be7e5409dc09659899a6565afef836c402
 SHA512:
-  metadata.gz: 8d1be01e59a72b7ccf3e322b0208fc8a07f5d4884574833c8bdcd5c8a139c607660fa8e47b8ce76acb87d609ebf9ebcb65a8caacdb08481479e7b74f899070cc
-  data.tar.gz: 87db374741759151abc13a4d074254db384ac96fe1848fe817c73bcdbc9548daedb792a447572fb8ef00fae4e9de34414fb856ba113c40bf7fab36b3b2c4f876
+  metadata.gz: b603a55dad7948963ef74e730e74caa5780332f90876ec4dae070f8cf2d97c8d818293e64a0dd89b593f6f479c6e7e11acc2a08817df1430f830eeeb0d680f1a
+  data.tar.gz: 286cc87a71d1d82b723706cde2f73fbf4f05f7275adee37dda60613e0c59d94f19bf9ceb6197c47220bc6ac53c9e56ae593824cc22605f7efe2c8e602aef8572

data/CHANGELOG.md

@@ -1,8 +1,3 @@
-## 0.3.4 (Upcoming)
-
-**Removed:**
-- Recovery Vault Support
-
 ## 0.3.3
 
 **Added:**

data/fog-azure-rm.gemspec

@@ -32,6 +32,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'azure_mgmt_traffic_manager', '~> 0.9.0'
   spec.add_dependency 'azure_mgmt_sql', '~> 0.9.0'
   spec.add_dependency 'azure_mgmt_key_vault', '~> 0.9.0'
-  spec.add_dependency 'azure-storage', '>= 0.11.5.preview', '< 1.0'
+  spec.add_dependency 'azure-storage', '= 0.11.5.preview'
   spec.add_dependency 'vhd', '0.0.4'
 end

data/lib/fog/azurerm/compute.rb

@@ -42,6 +42,7 @@ module Fog
       request :revoke_access_to_managed_disk
       request :grant_access_to_managed_disk
 
+
       model_path 'fog/azurerm/models/compute'
       model :availability_set
       collection :availability_sets
@@ -51,6 +52,7 @@ module Fog
       collection :virtual_machine_extensions
       model :managed_disk
       collection :managed_disks
+      model :data_disk
       model :creation_data
       model :disk_create_option
       model :encryption_settings

data/lib/fog/azurerm/docs/storage.md

@@ -389,6 +389,72 @@ directory.metadata = {
 directory.save(is_create: false)
 ```
 
+### Create Recovery Vault
+
+Create a new Recovery Vault object
+
+```ruby
+azure_storage_service.recovery_vaults.create(
+  name: '<vault_name>',
+  location: '<location>',
+  resource_group: '<resource_group_name>'
+```
+
+### Get Recovery Vault
+
+Retrieves a Recovery Vault object
+
+```ruby
+recovery_vault = azure_storage_service.recovery_vaults.get(
+  'Vault Name',
+  'Vault Resource Group'
+)
+```
+
+### List Recovery Vaults
+
+List the Recovery Vaults in a resource group
+
+```ruby
+azure_storage_service.recovery_vaults('Resource Group Name').each do |recovery_vault|
+  puts recovery_vault.inspect
+end
+```
+
+### Enable Backup Protection
+
+Enables backup protection for a virtual machine in the recovery vault. Backup protection for a virtual machine must be enabled before running backup.
+
+```ruby
+recovery_vault.enable_backup_protection('Virtual Machine Name', 'Virtual Machine Resource Group')
+```
+
+### Disable Backup Protection
+
+Disables backup protection for a virtual machine in the recovery vault.
+
+```ruby
+recovery_vault.disable_backup_protection('Virtual Machine Name', 'Virtual Machine Resource Group')
+```
+
+### Start Backup
+
+Starts the backup process for a given virtual machine
+
+```ruby
+recovery_vault.start_backup('Virtual Machine Name', 'Virtual Machine Resource Group')
+```
+
+### Destroy Recovery Vault
+
+Destroys the Recovery Vault
+
+```ruby
+recovery_vault.destroy
+```
+
+Note that a Recovery Vault must not contain any backup protectable items or tasks running in order for you to delete it. If any item is present, it must be deleted from the portal first before running this command.
+
 ## Support and Feedback
 Your feedback is appreciated! If you have specific issues with the fog ARM, you should file an issue via Github.
 

data/lib/fog/azurerm/models/compute/creation_data.rb

@@ -11,8 +11,10 @@ module Fog
 
         def self.parse(creation_data)
           data = get_hash_from_object(creation_data)
-          image_reference = Fog::Compute::AzureRM::ImageDiskReference.new
-          data['image_reference'] = image_reference.merge_attributes(Fog::Compute::AzureRM::ImageDiskReference.parse(creation_data.image_reference))
+          unless creation_data.image_reference.nil?
+            image_reference = Fog::Compute::AzureRM::ImageDiskReference.new
+            data['image_reference'] = image_reference.merge_attributes(Fog::Compute::AzureRM::ImageDiskReference.parse(creation_data.image_reference))
+          end
           data
         end
       end

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

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class AzureRM
+      # DataDisk Model for Compute Service
+      class DataDisk < Fog::Model
+        identity  :name
+        attribute :disk_size_gb
+        attribute :lun
+        attribute :caching
+        attribute :create_option
+        # For these composite objects we ONLY need one field
+        attribute :vhd_uri
+        attribute :image_uri
+        attribute :managed_disk_id
+
+        def self.parse(disk)
+          disk_hash = get_hash_from_object(disk)
+          disk_hash['vhd_uri'] = disk.vhd.uri if disk.vhd
+          disk_hash['image_uri'] = disk.image.uri if disk.image
+          disk_hash['managed_disk_id'] = disk.managed_disk.id if disk.managed_disk
+          disk_hash
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/compute/managed_disk.rb

@@ -6,17 +6,18 @@ module Fog
       class ManagedDisk < Fog::Model
         attribute :id
         identity  :name
-        attribute :resource_group_name
         attribute :type
         attribute :location
+        attribute :resource_group_name
         attribute :account_type
-        attribute :time_created
-        attribute :os_type
         attribute :disk_size_gb
         attribute :owner_id
         attribute :provisioning_state
         attribute :tags
+        attribute :time_created
         attribute :creation_data
+        
+        attribute :os_type
         attribute :encryption_settings
 
         def self.parse(managed_disk)
@@ -39,7 +40,7 @@ module Fog
 
         def save
           requires :name, :location, :resource_group_name, :creation_data
-          requires :disk_size_gb if creation_data[:create_option] == 'Empty'
+          requires :disk_size_gb, :account_type
           validate_creation_data_params(creation_data)
 
           disk = service.create_or_update_managed_disk(managed_disk_params)

data/lib/fog/azurerm/models/compute/server.rb

@@ -63,8 +63,8 @@ module Fog
 
           unless vm.storage_profile.data_disks.nil?
             vm.storage_profile.data_disks.each do |disk|
-              data_disk = Fog::Storage::AzureRM::DataDisk.new
-              hash['data_disks'] << data_disk.merge_attributes(Fog::Storage::AzureRM::DataDisk.parse(disk))
+              data_disk = Fog::Compute::AzureRM::DataDisk.new
+              hash['data_disks'] << data_disk.merge_attributes(Fog::Compute::AzureRM::DataDisk.parse(disk))
             end
           end
 
@@ -146,7 +146,7 @@ module Fog
         end
 
         def attach_data_disk(disk_name, disk_size, storage_account_name, async = false)
-          response = service.attach_data_disk_to_vm(resource_group, name, disk_name, disk_size, storage_account_name, async)
+          response = service.attach_data_disk_to_vm(data_disk_params(disk_name, disk_size, storage_account_name), async)
           async ? create_fog_async_response(response) : merge_attributes(Fog::Compute::AzureRM::Server.parse(response))
         end
 
@@ -155,6 +155,16 @@ module Fog
           async ? create_fog_async_response(response) : merge_attributes(Fog::Compute::AzureRM::Server.parse(response))
         end
 
+        def attach_managed_disk(disk_name, disk_resource_group, async=false)
+          response = service.attach_data_disk_to_vm(data_disk_params(disk_name, nil, nil, disk_resource_group), async)
+          async ? create_fog_async_response(response) : merge_attributes(Fog::Compute::AzureRM::Server.parse(response))
+        end
+
+        def detach_managed_disk(disk_name, async=false)
+          response = service.detach_data_disk_from_vm(resource_group, name, disk_name, async)
+          async ? create_fog_async_response(response) : merge_attributes(Fog::Compute::AzureRM::Server.parse(response))
+        end
+
         private
 
         def platform_is_linux?(platform)
@@ -193,6 +203,17 @@ module Fog
             managed_disk_storage_type: managed_disk_storage_type
           }
         end
+        
+        def data_disk_params(disk_name, disk_size=nil, storage_account=nil, disk_resource_group=nil)
+          {
+            vm_name: name,
+            vm_resource_group: resource_group,
+            disk_name: disk_name,
+            disk_size_gb: disk_size,
+            storage_account_name: storage_account,
+            disk_resource_group: disk_resource_group
+          }
+        end
       end
     end
   end

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(Fog::Storage::AzureRM::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 Fog::Storage::AzureRM::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 << Fog::Storage::AzureRM::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_fog = Fog::Storage::AzureRM::RecoveryVault.new(service: service)
+          recovery_vault_fog.merge_attributes(Fog::Storage::AzureRM::RecoveryVault.parse(recovery_vault))
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb

@@ -3,20 +3,35 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def attach_data_disk_to_vm(resource_group, vm_name, disk_name, disk_size, storage_account_name, async)
-          msg = "Attaching Data Disk #{disk_name} to Virtual Machine #{vm_name} in Resource Group #{resource_group}"
+        def attach_data_disk_to_vm(disk_params, async)
+          # Variable un-packing for easy access
+          vm_name = disk_params[:vm_name]
+          vm_resource_group = disk_params[:vm_resource_group]
+          disk_name = disk_params[:disk_name]
+          disk_resource_group = disk_params[:disk_resource_group]
+          disk_size = disk_params[:disk_size_gb]
+          storage_account_name = disk_params[:storage_account_name]
+
+          msg = "Attaching Data Disk #{disk_name} to Virtual Machine #{vm_name} in Resource Group #{vm_resource_group}"
           Fog::Logger.debug msg
-          vm = get_virtual_machine_instance(resource_group, vm_name, @compute_mgmt_client)
+          vm = get_virtual_machine_instance(vm_resource_group, vm_name)
           lun = get_logical_unit_number(vm.storage_profile.data_disks)
-          access_key = get_storage_access_key(resource_group, storage_account_name, @storage_mgmt_client)
-          data_disk = get_data_disk_object(disk_name, disk_size, lun, storage_account_name, access_key)
+
+          # Attach data disk to VM
+          if storage_account_name
+            # Un-managed data disk
+            access_key = get_storage_access_key(vm_resource_group, storage_account_name)
+            data_disk = get_unmanaged_disk_object(disk_name, disk_size, lun, storage_account_name, access_key)
+          elsif disk_resource_group
+            # Managed data disk
+            data_disk = get_data_disk_object(disk_resource_group, disk_name, lun)
+          end
           vm.storage_profile.data_disks.push(data_disk)
-          vm.resources = nil
           begin
             if async
-              response = @compute_mgmt_client.virtual_machines.create_or_update_async(resource_group, vm_name, vm)
+              response = @compute_mgmt_client.virtual_machines.create_or_update_async(vm_resource_group, vm_name, vm)
             else
-              virtual_machine = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, vm_name, vm)
+              virtual_machine = @compute_mgmt_client.virtual_machines.create_or_update(vm_resource_group, vm_name, vm)
             end
           rescue MsRestAzure::AzureOperationError => e
             if e.body.to_s =~ /InvalidParameter/ && e.body.to_s =~ /already exists/
@@ -35,11 +50,11 @@ module Fog
 
         private
 
-        def get_virtual_machine_instance(resource_group, vm_name, client)
+        def get_virtual_machine_instance(resource_group, vm_name)
           msg = "Getting Virtual Machine #{vm_name} from Resource Group #{resource_group}"
           Fog::Logger.debug msg
           begin
-            virtual_machine = client.virtual_machines.get(resource_group, vm_name)
+            virtual_machine = @compute_mgmt_client.virtual_machines.get(resource_group, vm_name)
           rescue MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
@@ -60,11 +75,32 @@ module Fog
           lun_range_list[0]
         end
 
-        def get_storage_access_key(resource_group, storage_account_name, storage_client)
+        def get_data_disk_object(disk_resource_group, disk_name, lun)
+          msg = "Getting Managed Disk #{disk_name} from Resource Group #{disk_resource_group}"
+          begin
+            disk = @compute_mgmt_client.disks.get(disk_resource_group, disk_name)
+          rescue MsRestAzure::AzureOperationError => e
+            Fog::Logger.debug msg
+            raise_azure_exception(e, msg)
+          end
+          managed_disk = Azure::ARM::Compute::Models::DataDisk.new
+          managed_disk.name = disk_name
+          managed_disk.lun = lun
+          managed_disk.create_option = Azure::ARM::Compute::Models::DiskCreateOptionTypes::Attach
+          
+          # Managed disk parameter
+          managed_disk_params = Azure::ARM::Compute::Models::ManagedDiskParameters.new
+          managed_disk_params.id = disk.id
+          managed_disk.managed_disk = managed_disk_params
+          
+          managed_disk
+        end
+
+        def get_storage_access_key(resource_group, storage_account_name)
           msg = "Getting Storage Access Keys from Resource Group #{resource_group}"
           Fog::Logger.debug msg
           begin
-            storage_account_keys = storage_client.storage_accounts.list_keys(resource_group, storage_account_name)
+            storage_account_keys = @storage_mgmt_client.storage_accounts.list_keys(resource_group, storage_account_name)
           rescue MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
@@ -72,7 +108,7 @@ module Fog
           storage_account_keys.keys[0].value
         end
 
-        def get_data_disk_object(disk_name, disk_size, lun, storage_account_name, access_key)
+        def get_unmanaged_disk_object(disk_name, disk_size, lun, storage_account_name, access_key)
           data_disk = Azure::ARM::Compute::Models::DataDisk.new
           data_disk.name = disk_name
           data_disk.lun = lun

data/lib/fog/azurerm/requests/compute/detach_data_disk_from_vm.rb

@@ -6,13 +6,12 @@ module Fog
         def detach_data_disk_from_vm(resource_group, vm_name, disk_name, async)
           msg = "Detaching Data Disk #{disk_name} from Virtual Machine #{vm_name} in Resource Group #{resource_group}."
           Fog::Logger.debug msg
-          vm = get_virtual_machine_instance(resource_group, vm_name, @compute_mgmt_client)
+          vm = get_virtual_machine_instance(resource_group, vm_name)
           vm.storage_profile.data_disks.each_with_index do |disk, index|
             if disk.name == disk_name
               vm.storage_profile.data_disks.delete_at(index)
             end
           end
-          vm.resources = nil
           begin
             if async
               response = @compute_mgmt_client.virtual_machines.create_or_update_async(resource_group, vm_name, vm)