fog-azure-rm 0.2.7 → 0.3.0

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

@@ -0,0 +1,43 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class is giving implementation of all/list, get and
+      # check existence for managed disk.
+      class ManagedDisks < Fog::Collection
+        model Fog::Compute::AzureRM::ManagedDisk
+        attribute :resource_group
+        def all
+          if !resource_group.nil?
+            requires :resource_group
+            disks = service.list_managed_disks_by_rg(resource_group)
+          else
+            disks = service.list_managed_disks_in_subscription
+          end
+          managed_disks = disks.map { |disk| Fog::Compute::AzureRM::ManagedDisk.parse(disk) }
+
+          load(managed_disks)
+        end
+
+        def get(resource_group_name, disk_name)
+          disk = service.get_managed_disk(resource_group_name, disk_name)
+          managed_disk_fog = Fog::Compute::AzureRM::ManagedDisk.new(service: service)
+          managed_disk_fog.merge_attributes(Fog::Compute::AzureRM::ManagedDisk.parse(disk))
+        end
+
+        def check_managed_disk_exists(resource_group, disk_name)
+          service.check_managed_disk_exists(resource_group, disk_name)
+        end
+
+        def grant_access(resource_group_name, disk_name, access_type, duration_in_sec)
+          service.grant_access_to_managed_disk(resource_group_name, disk_name, access_type, duration_in_sec)
+        end
+
+        def revoke_access(resource_group_name, disk_name)
+          response = service.revoke_access_to_managed_disk(resource_group_name, disk_name)
+          operation_status_response = Fog::Compute::AzureRM::OperationStatusResponse.new(service: service)
+          operation_status_response.merge_attributes(Fog::Compute::AzureRM::OperationStatusResponse.parse(response))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Fog
+  module Compute
+    class AzureRM
+      # OperationStatusResponse model for Compute Service
+      class OperationStatusResponse < Fog::Model
+        attribute :name
+        attribute :status
+        attribute :start_time
+        attribute :end_time
+        attribute :error
+
+        def self.parse(operation_status_response)
+          get_hash_from_object(operation_status_response)
+        end
+      end
+    end
+  end
+end

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

@@ -26,7 +26,7 @@ module Fog
         attribute :platform
         attribute :provision_vm_agent
         attribute :enable_automatic_updates
-        attribute :network_interface_card_id
+        attribute :network_interface_card_ids
         attribute :availability_set_id
         attribute :custom_data
         attribute :vhd_path
@@ -67,15 +67,15 @@ module Fog
             hash['provision_vm_agent'] = vm.os_profile.windows_configuration.provision_vmagent
             hash['enable_automatic_updates'] = vm.os_profile.windows_configuration.enable_automatic_updates
           end
-          hash['network_interface_card_id'] = vm.network_profile.network_interfaces[0].id
+          hash['network_interface_card_ids'] = vm.network_profile.network_interfaces.map(&:id)
           hash['availability_set_id'] = vm.availability_set.id unless vm.availability_set.nil?
 
           hash
         end
 
-        def save
+        def save(async = false)
           requires :name, :location, :resource_group, :vm_size, :storage_account_name,
-                   :username, :network_interface_card_id
+                   :username, :network_interface_card_ids
           requires :publisher, :offer, :sku, :version if vhd_path.nil?
 
           if platform_is_linux?(platform)
@@ -85,8 +85,13 @@ module Fog
           end
 
           ssh_key_path = "/home/#{username}/.ssh/authorized_keys" unless ssh_key_data.nil?
-          vm = service.create_virtual_machine(virtual_machine_params(ssh_key_path))
-          merge_attributes(Server.parse(vm))
+
+          if async
+            service.create_virtual_machine(virtual_machine_params(ssh_key_path), true)
+          else
+            vm = service.create_virtual_machine(virtual_machine_params(ssh_key_path))
+            merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
+          end
         end
 
         def destroy
@@ -153,7 +158,7 @@ module Fog
             disable_password_authentication: disable_password_authentication,
             ssh_key_path: ssh_key_path,
             ssh_key_data: ssh_key_data,
-            network_interface_card_id: network_interface_card_id,
+            network_interface_card_ids: network_interface_card_ids,
             availability_set_id: availability_set_id,
             publisher: publisher,
             offer: offer,

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

@@ -16,6 +16,12 @@ module Fog
           load(virtual_machines)
         end
 
+        def create_async(attributes = {})
+          server = new(attributes)
+          async_response = server.save(true)
+          Fog::AzureRM::AsyncResponse.new(server, async_response)
+        end
+
         def get(resource_group_name, virtual_machine_name)
           virtual_machine = service.get_virtual_machine(resource_group_name, virtual_machine_name)
           virtual_machine_fog = Fog::Compute::AzureRM::Server.new(service: service)

data/lib/fog/azurerm/models/traffic_manager/traffic_manager_profile.rb

@@ -55,6 +55,7 @@ module Fog
 
         def update(profile_params)
           validate_input(profile_params)
+          profile_params[:endpoints] = endpoints.map { |endpoint| get_hash_from_object(endpoint)['attributes'] }
           merge_attributes(profile_params)
           profile = service.create_or_update_traffic_manager_profile(traffic_manager_profile_hash)
           merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(profile))

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

@@ -0,0 +1,33 @@
+module Fog
+  module Compute
+    class AzureRM
+      # Real class for Compute Request
+      class Real
+        def check_managed_disk_exists(resource_group_name, disk_name)
+          msg = "Checking if Managed Disk: #{disk_name} exists"
+          Fog::Logger.debug msg
+          begin
+            @compute_mgmt_client.disks.get(resource_group_name, disk_name)
+            Fog::Logger.debug "Managed Disk #{disk_name} exist."
+            true
+          rescue MsRestAzure::AzureOperationError => e
+            if e.error_code == 'ResourceNotFound'
+              Fog::Logger.debug "Managed Disk #{disk_name} doesn't exist."
+              false
+            else
+              raise_azure_exception(e, msg)
+            end
+          end
+        end
+      end
+
+      # Mock class for Compute Request
+      class Mock
+        def check_managed_disk_exists(*)
+          Fog::Logger.debug 'Managed Disk test-disk from Resource group fog-rg is available.'
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+module Fog
+  module Compute
+    class AzureRM
+      # Real class for Compute Request
+      class Real
+        def create_or_update_managed_disk(managed_disk_params)
+          msg = "Creating/Updating Managed Disk: #{managed_disk_params[:name]}"
+          Fog::Logger.debug msg
+          disk = get_managed_disk_object(managed_disk_params)
+          begin
+            managed_disk = @compute_mgmt_client.disks.create_or_update(managed_disk_params[:resource_group_name], managed_disk_params[:name], disk)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Managed Disk #{managed_disk_params[:name]} created/updated successfully."
+          managed_disk
+        end
+
+        private
+
+        def get_managed_disk_object(managed_disk_params)
+          managed_disk = Azure::ARM::Compute::Models::Disk.new
+          managed_disk.name = managed_disk_params[:name]
+          managed_disk.type = DISK_PREFIX
+          managed_disk.location = managed_disk_params[:location]
+          managed_disk.account_type = managed_disk_params[:account_type]
+          managed_disk.os_type = managed_disk_params[:os_type]
+          managed_disk.disk_size_gb = managed_disk_params[:disk_size_gb]
+          managed_disk.tags = managed_disk_params[:tags] if managed_disk.tags.nil?
+
+          creation_data = managed_disk_params[:creation_data]
+          managed_disk.creation_data = get_creation_data_object(creation_data) unless creation_data.nil?
+
+          encryption_settings = managed_disk_params[:encryption_settings]
+          managed_disk.encryption_settings = get_encryption_settings_object(encryption_settings) unless encryption_settings.nil?
+
+          managed_disk
+        end
+
+        def get_creation_data_object(data)
+          creation_data = Azure::ARM::Compute::Models::CreationData.new
+          creation_data.create_option = data[:create_option]
+          creation_data.storage_account_id = data[:storage_account_id]
+          creation_data.source_uri = data[:source_uri]
+          creation_data.source_resource_id = data[:source_resource_id]
+
+          image_reference = data[:image_reference]
+          unless image_reference.nil?
+            image_disk_reference = Azure::ARM::Compute::Models::ImageDiskReference.new
+            image_disk_reference.id = image_reference[:id]
+            image_disk_reference.lun = image_reference[:lun]
+
+            creation_data.image_reference = image_disk_reference
+          end
+          creation_data
+        end
+
+        def get_encryption_settings_object(settings)
+          encryption_settings = Azure::ARM::Compute::Models::EncryptionSettings.new
+          disk_encryption_key = Azure::ARM::Compute::Models::KeyVaultAndSecretReference.new
+          disk_encryption_key.secret_url = settings[:secret_url]
+          disk_encryption_key.source_vault.id = settings[:disk_source_vault_id]
+          encryption_settings.disk_encryption_key = disk_encryption_key
+
+          encryption_settings.enabled = settings[:enabled]
+
+          key_encryption_key = Azure::ARM::Compute::Models::KeyVaultAndKeyReference.new
+          key_encryption_key.key_url = settings[:key_uri]
+          key_encryption_key.source_vault = settings[:key_source_vault_id]
+          encryption_settings.key_encryption_key = key_encryption_key
+
+          encryption_settings
+        end
+      end
+
+      # Mock class for Compute Request
+      class Mock
+        def create_or_update_managed_disk(*)
+          disk = {
+            'accountType' => 'Standard_LRS',
+            'properties' => {
+              'osType' => 'Windows',
+              'creationData' => {
+                'createOption' => 'Empty'
+              },
+              'diskSizeGB' => 10,
+              'encryptionSettings' => {
+                'enabled' => true,
+                'diskEncryptionKey' => {
+                  'sourceVault' => {
+                    'id' => '/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.KeyVault/vaults/myVMVault'
+                  },
+                  'secretUrl' => 'https://myvmvault.vault-int.azure-int.net/secrets/{secret}'
+                },
+                'keyEncryptionKey' => {
+                  'sourceVault' => {
+                    'id' => '/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.KeyVault/vaults/myVMVault'
+                  },
+                  'keyUrl' => 'https://myvmvault.vault-int.azure-int.net/keys/{key}'
+                }
+              },
+              'timeCreated' => '2016-12-28T02:46:21.3322041+00:00',
+              'provisioningState' => 'Succeeded',
+              'diskState' => 'Unattached'
+            },
+            'type' => 'Microsoft.Compute/disks',
+            'location' => 'westus',
+            'tags' => {
+              'department' => 'Development',
+              'project' => 'ManagedDisks'
+            },
+            'id' => '/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk1',
+            'name' => 'myManagedDisk1'
+          }
+          disk_mapper = Azure::ARM::Compute::Models::Disk.mapper
+          @compute_mgmt_client.deserialize(disk_mapper, disk, 'result.body')
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def create_virtual_machine(vm_hash)
+        def create_virtual_machine(vm_hash, async = false)
           msg = "Creating Virtual Machine #{vm_hash[:name]} in Resource Group #{vm_hash[:resource_group]}."
           Fog::Logger.debug msg
           virtual_machine = Azure::ARM::Compute::Models::VirtualMachine.new
@@ -48,15 +48,19 @@ module Fog
                                                                  vm_hash[:ssh_key_data],
                                                                  encoded_data)
                                        end
-          virtual_machine.network_profile = define_network_profile(vm_hash[:network_interface_card_id])
+          virtual_machine.network_profile = define_network_profile(vm_hash[:network_interface_card_ids])
           virtual_machine.location = vm_hash[:location]
           begin
-            vm = @compute_mgmt_client.virtual_machines.create_or_update(vm_hash[:resource_group], vm_hash[:name], virtual_machine)
+            response = if async
+                         @compute_mgmt_client.virtual_machines.create_or_update_async(vm_hash[:resource_group], vm_hash[:name], virtual_machine)
+                       else
+                         @compute_mgmt_client.virtual_machines.create_or_update(vm_hash[:resource_group], vm_hash[:name], virtual_machine)
+                       end
           rescue MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Virtual Machine #{vm_hash[:name]} Created Successfully."
-          vm
+          Fog::Logger.debug "Virtual Machine #{vm_hash[:name]} Created Successfully." unless async
+          response
         end
 
         private
@@ -119,14 +123,17 @@ module Fog
           os_disk.name = "#{vm_name}_os_disk"
           os_disk.vhd = vhd
           os_disk.create_option = Azure::ARM::Compute::Models::DiskCreateOptionTypes::FromImage
-          os_disk.caching = case os_disk_caching
+          os_disk.caching = unless os_disk_caching.nil?
+                              case os_disk_caching
                               when 'None'
                                 Azure::ARM::Compute::Models::CachingTypes::None
                               when 'ReadOnly'
                                 Azure::ARM::Compute::Models::CachingTypes::ReadOnly
                               when 'ReadWrite'
                                 Azure::ARM::Compute::Models::CachingTypes::ReadWrite
-                            end unless os_disk_caching.nil?
+                              end
+                            end
+
           storage_profile.os_disk = os_disk
           storage_profile
         end
@@ -167,11 +174,17 @@ module Fog
           os_profile
         end
 
-        def define_network_profile(network_interface_card_id)
+        def define_network_profile(network_interface_card_ids)
+          network_interface_cards = []
+          network_interface_card_ids.each_with_index do |id, index|
+            nic = Azure::ARM::Compute::Models::NetworkInterfaceReference .new
+            nic.id = id
+            nic.primary = index == PRIMARY_NIC_INDEX ? true : false
+            network_interface_cards << nic
+          end
+
           network_profile = Azure::ARM::Compute::Models::NetworkProfile.new
-          nic = Azure::ARM::Compute::Models::NetworkInterfaceReference .new
-          nic.id = network_interface_card_id
-          network_profile.network_interfaces = [nic]
+          network_profile.network_interfaces = network_interface_cards
           network_profile
         end
       end

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

@@ -0,0 +1,29 @@
+
+module Fog
+  module Compute
+    class AzureRM
+      # Real class for Compute Request
+      class Real
+        def delete_managed_disk(resource_group_name, disk_name)
+          msg = "Deleting Managed Disk: #{disk_name}"
+          Fog::Logger.debug msg
+          begin
+            @compute_mgmt_client.disks.delete(resource_group_name, disk_name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Managed Disk #{disk_name} deleted successfully."
+          true
+        end
+      end
+
+      # Mock class for Compute Request
+      class Mock
+        def delete_managed_disk(*)
+          Fog::Logger.debug 'Managed Disk test-disk from Resource group fog-test-rg deleted successfully.'
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ module Fog
           Fog::Logger.debug msg
           begin
             @compute_mgmt_client.virtual_machines.delete(resource_group, name)
-          rescue  MsRestAzure::AzureOperationError => e
+          rescue MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
           Fog::Logger.debug "Virtual Machine #{name} Deleted Successfully."

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

@@ -0,0 +1,64 @@
+module Fog
+  module Compute
+    class AzureRM
+      # Real class for Compute Request
+      class Real
+        def get_managed_disk(resource_group_name, disk_name)
+          msg = "Getting Managed Disk: #{disk_name}"
+          Fog::Logger.debug msg
+          begin
+            managed_disk = @compute_mgmt_client.disks.get(resource_group_name, disk_name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Managed Disk #{disk_name} returned successfully."
+          managed_disk
+        end
+      end
+
+      # Mock class for Compute Request
+      class Mock
+        def get_managed_disk(*)
+          disk = {
+            'accountType' => 'Standard_LRS',
+            'properties' => {
+              'osType' => 'Windows',
+              'creationData' => {
+                'createOption' => 'Empty'
+              },
+              'diskSizeGB' => 10,
+              'encryptionSettings' => {
+                'enabled' => true,
+                'diskEncryptionKey' => {
+                  'sourceVault' => {
+                    'id' => '/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.KeyVault/vaults/myVMVault'
+                  },
+                  'secretUrl' => 'https://myvmvault.vault-int.azure-int.net/secrets/{secret}'
+                },
+                'keyEncryptionKey' => {
+                  'sourceVault' => {
+                    'id' => '/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.KeyVault/vaults/myVMVault'
+                  },
+                  'keyUrl' => 'https://myvmvault.vault-int.azure-int.net/keys/{key}'
+                }
+              },
+              'timeCreated' => '2016-12-28T02:46:21.3322041+00:00',
+              'provisioningState' => 'Succeeded',
+              'diskState' => 'Unattached'
+            },
+            'type' => 'Microsoft.Compute/disks',
+            'location' => 'westus',
+            'tags' => {
+              'department' => 'Development',
+              'project' => 'ManagedDisks'
+            },
+            'id' => '/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk1',
+            'name' => 'myManagedDisk1'
+          }
+          disk_mapper = Azure::ARM::Compute::Models::Disk.mapper
+          @compute_mgmt_client.deserialize(disk_mapper, disk, 'result.body')
+        end
+      end
+    end
+  end
+end