fog-azure-rm 0.3.3 → 0.3.4

data/lib/fog/azurerm/models/sql/sql_database.rb

@@ -23,13 +23,12 @@ module Fog
         attribute :requested_service_objective_name, aliases: %w(requestedServiceObjectiveName)
         attribute :service_level_objective, aliases: %w(serviceLevelObjective)
         attribute :source_database_id, aliases: %w(sourceDatabaseId)
+        attribute :tags
 
         def self.parse(database)
           database_hash = get_hash_from_object(database)
-
           database_hash['resource_group'] = get_resource_group_from_id(database.id)
           database_hash['server_name'] = get_resource_from_resource_id(database.id, 8)
-
           database_hash
         end
 
@@ -58,7 +57,8 @@ module Fog
             max_size_bytes: max_size_bytes,
             requested_service_objective_name: requested_service_objective_name,
             elastic_pool_name: elastic_pool_name,
-            requested_service_objective_id: requested_service_objective_id
+            requested_service_objective_id: requested_service_objective_id,
+            tags: tags
           }
         end
       end

data/lib/fog/azurerm/models/sql/sql_server.rb

@@ -13,11 +13,11 @@ module Fog
         attribute :administrator_login
         attribute :administrator_login_password
         attribute :fully_qualified_domain_name, aliases: %w(fullyQualifiedDomainName)
+        attribute :tags
 
         def self.parse(server)
           sql_server_hash = get_hash_from_object(server)
           sql_server_hash['resource_group'] = get_resource_group_from_id(server.id)
-
           sql_server_hash
         end
 
@@ -40,7 +40,8 @@ module Fog
             version: version,
             location: location,
             administrator_login: administrator_login,
-            administrator_login_password: administrator_login_password
+            administrator_login_password: administrator_login_password,
+            tags: tags
           }
         end
       end

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

@@ -11,6 +11,7 @@ module Fog
         attribute :sku_name
         attribute :replication
         attribute :encryption
+        attribute :tags
 
         def self.parse(storage_account)
           hash = {}
@@ -21,6 +22,7 @@ module Fog
           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['tags'] = storage_account.tags
           hash
         end
 
@@ -43,7 +45,8 @@ module Fog
             sku_name: sku_name,
             location: location,
             replication: replication,
-            encryption: encryption
+            encryption: encryption,
+            tags: tags
           }
         end
 

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

@@ -17,6 +17,7 @@ module Fog
         attribute :port
         attribute :path
         attribute :endpoints
+        attribute :tags
 
         def self.parse(profile)
           traffic_manager_profile = get_hash_from_object(profile)
@@ -79,7 +80,8 @@ module Fog
             protocol: protocol,
             port: port,
             path: path,
-            endpoints: endpoints
+            endpoints: endpoints,
+            tags: tags
           }
         end
       end

data/lib/fog/azurerm/requests/application_gateway/create_or_update_application_gateway.rb

@@ -33,6 +33,7 @@ module Fog
           application_gateway.http_listeners = define_http_listeners(gateway_params[:http_listeners]) if gateway_params[:http_listeners]
           application_gateway.url_path_maps = define_url_path_maps(gateway_params[:url_path_maps]) if gateway_params[:url_path_maps]
           application_gateway.request_routing_rules = define_request_routing_rules(gateway_params[:request_routing_rules]) if gateway_params[:request_routing_rules]
+          application_gateway.tags = gateway_params[:tags]
 
           gateway_sku = Azure::ARM::Network::Models::ApplicationGatewaySku.new
           gateway_sku.name = gateway_params[:sku_name]

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

@@ -10,10 +10,11 @@ module Fog
           fault_domain_count = availability_set_params[:platform_fault_domain_count]
           update_domain_count = availability_set_params[:platform_update_domain_count]
           use_managed_disk = availability_set_params[:use_managed_disk].nil? ? false : availability_set_params[:use_managed_disk]
+          tags = availability_set_params[:tags]
 
           msg = "Creating Availability Set '#{name}' in #{location} region."
           Fog::Logger.debug msg
-          avail_set_params = get_availability_set_properties(location, fault_domain_count, update_domain_count, use_managed_disk)
+          avail_set_params = get_availability_set_properties(location, fault_domain_count, update_domain_count, use_managed_disk, tags)
 
           begin
             availability_set = @compute_mgmt_client.availability_sets.create_or_update(resource_group, name, avail_set_params)
@@ -25,12 +26,13 @@ module Fog
         end
 
         # create the properties object for creating availability sets
-        def get_availability_set_properties(location, fault_domain_count, update_domain_count, use_managed_disk)
+        def get_availability_set_properties(location, fault_domain_count, update_domain_count, use_managed_disk, tags)
           avail_set = Azure::ARM::Compute::Models::AvailabilitySet.new
           avail_set.location = location
           avail_set.sku = create_availability_set_sku(use_managed_disk)
           avail_set.platform_fault_domain_count = fault_domain_count.nil? ? FAULT_DOMAIN_COUNT : fault_domain_count
           avail_set.platform_update_domain_count = update_domain_count.nil? ? UPDATE_DOMAIN_COUNT : update_domain_count
+          avail_set.tags = tags
           avail_set
         end
 

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

@@ -6,61 +6,63 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def create_virtual_machine(vm_hash, async = false)
-          msg = "Creating Virtual Machine #{vm_hash[:name]} in Resource Group #{vm_hash[:resource_group]}."
+        def create_virtual_machine(vm_config, async = false)
+          msg = "Creating Virtual Machine #{vm_config[:name]} in Resource Group #{vm_config[:resource_group]}."
           Fog::Logger.debug msg
           virtual_machine = Azure::ARM::Compute::Models::VirtualMachine.new
 
-          unless vm_hash[:availability_set_id].nil?
+          unless vm_config[:availability_set_id].nil?
             sub_resource = MsRestAzure::SubResource.new
-            sub_resource.id = vm_hash[:availability_set_id]
+            sub_resource.id = vm_config[:availability_set_id]
             virtual_machine.availability_set = sub_resource
           end
 
-          string_data = vm_hash[:custom_data]
+          string_data = vm_config[:custom_data]
           string_data = WHITE_SPACE if string_data.nil?
           encoded_data = Base64.strict_encode64(string_data)
-          virtual_machine.hardware_profile = define_hardware_profile(vm_hash[:vm_size])
-          virtual_machine.storage_profile = define_storage_profile(vm_hash[:name],
-                                                                   vm_hash[:storage_account_name],
-                                                                   vm_hash[:publisher],
-                                                                   vm_hash[:offer],
-                                                                   vm_hash[:sku],
-                                                                   vm_hash[:version],
-                                                                   vm_hash[:vhd_path],
-                                                                   vm_hash[:os_disk_caching],
-                                                                   vm_hash[:platform],
-                                                                   vm_hash[:resource_group],
-                                                                   vm_hash[:managed_disk_storage_type])
+          virtual_machine.hardware_profile = define_hardware_profile(vm_config[:vm_size])
+          virtual_machine.storage_profile = define_storage_profile(vm_config[:name],
+                                                                   vm_config[:storage_account_name],
+                                                                   vm_config[:publisher],
+                                                                   vm_config[:offer],
+                                                                   vm_config[:sku],
+                                                                   vm_config[:version],
+                                                                   vm_config[:vhd_path],
+                                                                   vm_config[:os_disk_caching],
+                                                                   vm_config[:platform],
+                                                                   vm_config[:resource_group],
+                                                                   vm_config[:managed_disk_storage_type],
+                                                                   vm_config[:os_disk_size])
 
-          virtual_machine.os_profile = if vm_hash[:platform].casecmp(WINDOWS).zero?
-                                         define_windows_os_profile(vm_hash[:name],
-                                                                   vm_hash[:username],
-                                                                   vm_hash[:password],
-                                                                   vm_hash[:provision_vm_agent],
-                                                                   vm_hash[:enable_automatic_updates],
+          virtual_machine.os_profile = if vm_config[:platform].casecmp(WINDOWS).zero?
+                                         define_windows_os_profile(vm_config[:name],
+                                                                   vm_config[:username],
+                                                                   vm_config[:password],
+                                                                   vm_config[:provision_vm_agent],
+                                                                   vm_config[:enable_automatic_updates],
                                                                    encoded_data)
                                        else
-                                         define_linux_os_profile(vm_hash[:name],
-                                                                 vm_hash[:username],
-                                                                 vm_hash[:password],
-                                                                 vm_hash[:disable_password_authentication],
-                                                                 vm_hash[:ssh_key_path],
-                                                                 vm_hash[:ssh_key_data],
+                                         define_linux_os_profile(vm_config[:name],
+                                                                 vm_config[:username],
+                                                                 vm_config[:password],
+                                                                 vm_config[:disable_password_authentication],
+                                                                 vm_config[:ssh_key_path],
+                                                                 vm_config[:ssh_key_data],
                                                                  encoded_data)
                                        end
-          virtual_machine.network_profile = define_network_profile(vm_hash[:network_interface_card_ids])
-          virtual_machine.location = vm_hash[:location]
+          virtual_machine.network_profile = define_network_profile(vm_config[:network_interface_card_ids])
+          virtual_machine.location = vm_config[:location]
+          virtual_machine.tags = vm_config[:tags]
           begin
             response = if async
-                         @compute_mgmt_client.virtual_machines.create_or_update_async(vm_hash[:resource_group], vm_hash[:name], virtual_machine)
+                         @compute_mgmt_client.virtual_machines.create_or_update_async(vm_config[:resource_group], vm_config[:name], virtual_machine)
                        else
-                         @compute_mgmt_client.virtual_machines.create_or_update(vm_hash[:resource_group], vm_hash[:name], virtual_machine)
+                         @compute_mgmt_client.virtual_machines.create_or_update(vm_config[:resource_group], vm_config[:name], virtual_machine)
                        end
           rescue MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Virtual Machine #{vm_hash[:name]} Created Successfully." unless async
+          Fog::Logger.debug "Virtual Machine #{vm_config[:name]} Created Successfully." unless async
           response
         end
 
@@ -81,7 +83,7 @@ module Fog
           image_reference
         end
 
-        def define_storage_profile(vm_name, storage_account_name, publisher, offer, sku, version, vhd_path, os_disk_caching, platform, resource_group, managed_disk_storage_type)
+        def define_storage_profile(vm_name, storage_account_name, publisher, offer, sku, version, vhd_path, os_disk_caching, platform, resource_group, managed_disk_storage_type, os_disk_size)
           storage_profile = Azure::ARM::Compute::Models::StorageProfile.new
           storage_profile.image_reference = image_reference(publisher, offer, sku, version)
           os_disk = Azure::ARM::Compute::Models::OSDisk.new
@@ -129,7 +131,7 @@ module Fog
         
           os_disk.name = "#{vm_name}_os_disk"
           os_disk.os_type = platform
-          
+          os_disk.disk_size_gb = os_disk_size unless os_disk_size.nil?
           os_disk.create_option = Azure::ARM::Compute::Models::DiskCreateOptionTypes::FromImage
           os_disk.caching = unless os_disk_caching.nil?
                               case os_disk_caching

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)

data/lib/fog/azurerm/requests/dns/create_or_update_zone.rb

@@ -25,9 +25,8 @@ module Fog
           zone.type = zone_params[:type]
           zone.number_of_record_sets = zone_params[:number_of_record_sets]
           zone.max_number_of_record_sets = zone_params[:max_number_of_record_sets]
-          zone.tags = zone_params[:tags] if zone.tags.nil?
+          zone.tags = zone_params[:tags]
           zone.etag = zone_params[:etag]
-
           zone
         end
       end

data/lib/fog/azurerm/requests/key_vault/create_or_update_vault.rb

@@ -21,6 +21,7 @@ module Fog
         def get_vault_param_object(vault_hash)
           vault_param = Azure::ARM::KeyVault::Models::VaultCreateOrUpdateParameters.new
           vault_param.location = vault_hash[:location]
+          vault_param.tags = vault_hash[:tags]
           vault_param.properties = get_vault_properties_object(vault_hash)
           vault_param
         end

data/lib/fog/azurerm/requests/network/check_express_route_cir_auth_exists.rb

@@ -11,7 +11,7 @@ module Fog
             Fog::Logger.debug "Express Route Circuit Authorization #{authorization_name} exists."
             true
           rescue MsRestAzure::AzureOperationError => e
-            if e.body['error']['code'] == 'ResourceNotFound'
+            if e.body['error']['code'] == 'NotFound'
               Fog::Logger.debug "Express Route Circuit Authorization #{authorization_name} doesn't exist."
               false
             else

data/lib/fog/azurerm/requests/network/create_load_balancer.rb

@@ -3,10 +3,10 @@ module Fog
     class AzureRM
       # Real class for Load-Balancer Request
       class Real
-        def create_load_balancer(name, location, resource_group, frontend_ip_configurations, backend_address_pool_names, load_balancing_rules, probes, inbound_nat_rules, inbound_nat_pools)
+        def create_load_balancer(name, location, resource_group, frontend_ip_configurations, backend_address_pool_names, load_balancing_rules, probes, inbound_nat_rules, inbound_nat_pools, tags)
           msg = "Creating Load-Balancer: #{name}"
           Fog::Logger.debug msg
-          load_balancer = define_load_balancer(name, location, frontend_ip_configurations, backend_address_pool_names, load_balancing_rules, probes, inbound_nat_rules, inbound_nat_pools)
+          load_balancer = define_load_balancer(name, location, frontend_ip_configurations, backend_address_pool_names, load_balancing_rules, probes, inbound_nat_rules, inbound_nat_pools, tags)
           begin
             load_balancer = @network_client.load_balancers.create_or_update(resource_group, name, load_balancer)
           rescue MsRestAzure::AzureOperationError => e
@@ -18,11 +18,11 @@ module Fog
 
         private
 
-        def define_load_balancer(name, location, frontend_ip_configurations, backend_address_pool_names, load_balancing_rules, probes, inbound_nat_rules, inbound_nat_pools)
+        def define_load_balancer(name, location, frontend_ip_configurations, backend_address_pool_names, load_balancing_rules, probes, inbound_nat_rules, inbound_nat_pools, tags)
           load_balancer = Azure::ARM::Network::Models::LoadBalancer.new
           load_balancer.name = name
           load_balancer.location = location
-
+          load_balancer.tags = tags
           if frontend_ip_configurations
             frontend_ip_configuration_arr = define_lb_frontend_ip_configurations(frontend_ip_configurations)
             load_balancer.frontend_ipconfigurations = frontend_ip_configuration_arr

data/lib/fog/azurerm/requests/network/create_or_update_express_route_circuit.rb

@@ -47,7 +47,7 @@ module Fog
           express_route_circuit.name = circuit_name
           express_route_circuit.location = location
           express_route_circuit.sku = sku
-          express_route_circuit.tags = tags if express_route_circuit.tags.nil?
+          express_route_circuit.tags = tags
           express_route_circuit
         end
 

data/lib/fog/azurerm/requests/network/create_or_update_local_network_gateway.rb

@@ -25,13 +25,12 @@ module Fog
           local_network_gateway.local_network_address_space = get_local_network_address_space_object(local_network_gateway_params[:local_network_address_space_prefixes]) if local_network_gateway_params[:local_network_address_space_prefixes]
           local_network_gateway.gateway_ip_address = local_network_gateway_params[:gateway_ip_address] if local_network_gateway_params[:gateway_ip_address]
           local_network_gateway.bgp_settings = get_bgp_settings_object(local_network_gateway_params)
-
           local_network_gateway.name = local_network_gateway_params[:name]
           local_network_gateway.type = local_network_gateway_params[:type]
           local_network_gateway.location = local_network_gateway_params[:location]
           local_network_gateway.tags = local_network_gateway_params[:tags] if local_network_gateway.tags.nil?
           local_network_gateway.provisioning_state = local_network_gateway_params[:provisioning_state]
-
+          local_network_gateway.tags = local_network_gateway_params[:tags]
           local_network_gateway
         end