fog-azure-rm 0.0.6 → 0.0.8

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

@@ -0,0 +1,151 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for Blob.
+      class File < Fog::Model
+        identity  :key, aliases: %w(Name name)
+        attribute :accept_ranges
+        attribute :cache_control
+        attribute :committed_block_count
+        attribute :content_length
+        attribute :content_type
+        attribute :content_md5
+        attribute :content_encoding
+        attribute :content_language
+        attribute :content_disposition
+        attribute :copy_completion_time
+        attribute :copy_status
+        attribute :copy_status_description
+        attribute :copy_id
+        attribute :copy_progress
+        attribute :copy_source
+        attribute :directory
+        attribute :etag
+        attribute :file_path
+        attribute :last_modified
+        attribute :lease_duration
+        attribute :lease_state
+        attribute :lease_status
+        attribute :metadata
+        attribute :sequence_number
+        attribute :blob_type
+
+        def save(options = {})
+          requires :key
+          requires :directory
+          merge_attributes(File.parse(service.upload_block_blob_from_file(directory, key, file_path, options)))
+        end
+
+        alias create save
+
+        def destroy(options = {})
+          requires :key
+          requires :directory
+          service.delete_blob directory, key, options
+        end
+
+        def save_to_file(file_path, options = {})
+          requires :key
+          requires :directory
+          merge_attributes(file_path: file_path)
+          merge_attributes(File.parse(service.download_blob_to_file(directory, key, file_path, options)))
+        end
+
+        def get_properties(options = {})
+          requires :key
+          requires :directory
+          merge_attributes(File.parse(service.get_blob_properties(directory, key, options)))
+        end
+
+        def set_properties(properties = {})
+          requires :key
+          requires :directory
+          service.set_blob_properties(directory, key, properties)
+          merge_attributes(properties)
+        end
+
+        def get_metadata(options = {})
+          requires :key
+          requires :directory
+          merge_attributes(metadata: service.get_blob_metadata(directory, key, options))
+        end
+
+        def set_metadata(metadata, options = {})
+          requires :key
+          requires :directory
+          service.set_blob_metadata(directory, key, metadata, options)
+          merge_attributes(metadata: metadata)
+        end
+
+        def self.parse(blob)
+          if blob.is_a? Hash
+            parse_hash blob
+          else
+            parse_object blob
+          end
+        end
+
+        def self.parse_hash(blob)
+          hash = {}
+          hash['key'] = blob['name']
+          hash['metadata'] = blob['metadata']
+          return hash unless blob.key?('properties')
+
+          hash['last_modified'] = blob['properties']['last_modified']
+          hash['etag'] = blob['properties']['etag']
+          hash['lease_duration'] = blob['properties']['lease_duration']
+          hash['lease_status'] = blob['properties']['lease_status']
+          hash['lease_state'] = blob['properties']['lease_state']
+          hash['content_length'] = blob['properties']['content_length']
+          hash['content_type'] = blob['properties']['content_type']
+          hash['content_encoding'] = blob['properties']['content_encoding']
+          hash['content_language'] = blob['properties']['content_language']
+          hash['content_disposition'] = blob['properties']['content_disposition']
+          hash['content_md5'] = blob['properties']['content_md5']
+          hash['cache_control'] = blob['properties']['cache_control']
+          hash['sequence_number'] = blob['properties']['sequence_number']
+          hash['blob_type'] = blob['properties']['blob_type']
+          hash['copy_id'] = blob['properties']['copy_id']
+          hash['copy_status'] = blob['properties']['copy_status']
+          hash['copy_source'] = blob['properties']['copy_source']
+          hash['copy_progress'] = blob['properties']['copy_progress']
+          hash['copy_completion_time'] = blob['properties']['copy_completion_time']
+          hash['copy_status_description'] = blob['properties']['copy_status_description']
+          hash['accept_ranges'] = blob['properties']['accept_ranges']
+          hash
+        end
+
+        def self.parse_object(blob)
+          hash = {}
+          hash['key'] = blob.name
+          hash['metadata'] = blob.metadata
+          return hash unless blob.respond_to?('properties')
+
+          hash['last_modified'] = blob.properties[:last_modified]
+          hash['etag'] = blob.properties[:etag]
+          hash['lease_duration'] = blob.properties[:lease_duration]
+          hash['lease_status'] = blob.properties[:lease_status]
+          hash['lease_state'] = blob.properties[:lease_state]
+          hash['content_length'] = blob.properties[:content_length]
+          hash['content_type'] = blob.properties[:content_type]
+          hash['content_encoding'] = blob.properties[:content_encoding]
+          hash['content_language'] = blob.properties[:content_language]
+          hash['content_disposition'] = blob.properties[:content_disposition]
+          hash['content_md5'] = blob.properties[:content_md5]
+          hash['cache_control'] = blob.properties[:cache_control]
+          hash['sequence_number'] = blob.properties[:sequence_number]
+          hash['blob_type'] = blob.properties[:blob_type]
+          hash['copy_id'] = blob.properties[:copy_id]
+          hash['copy_status'] = blob.properties[:copy_status]
+          hash['copy_source'] = blob.properties[:copy_source]
+          hash['copy_progress'] = blob.properties[:copy_progress]
+          hash['copy_completion_time'] = blob.properties[:copy_completion_time]
+          hash['copy_status_description'] = blob.properties[:copy_status_description]
+          hash['accept_ranges'] = blob.properties[:accept_ranges]
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+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
+        attribute :directory
+
+        def all(options = { metadata: true })
+          files = []
+          service.list_blobs(directory, options).each do |blob|
+            hash = File.parse blob
+            hash['directory'] = directory
+            files << hash
+          end
+          load files
+        end
+
+        def get(directory, name)
+          file = File.new(service: service)
+          file.directory = directory
+          file.key = name
+          file
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/network.rb

@@ -31,6 +31,7 @@ module Fog
       request :detach_route_table_from_subnet
       request :list_subnets
       request :get_subnet
+      request :get_available_ipaddresses_count
       request :delete_subnet
       request :create_or_update_network_interface
       request :delete_network_interface
@@ -76,6 +77,10 @@ module Fog
       request :get_connection_shared_key
       request :reset_connection_shared_key
       request :set_connection_shared_key
+      request :create_or_update_network_security_rule
+      request :delete_network_security_rule
+      request :get_network_security_rule
+      request :list_network_security_rules
 
       model_path 'fog/azurerm/models/network'
       model :virtual_network
@@ -96,6 +101,7 @@ module Fog
       model :network_security_group
       collection :network_security_groups
       model :network_security_rule
+      collection :network_security_rules
       model :path_rule
       model :vpn_client_configuration
       model :vpn_client_revoked_certificates

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

@@ -0,0 +1,63 @@
+module Fog
+  module Compute
+    class AzureRM
+      # Real class for Compute Request
+      class Real
+        def create_or_update_vm_extension(vm_extension_params)
+          msg = "Creating/Updating Extension #{vm_extension_params[:name]} for Virtual Machine #{vm_extension_params[:vm_name]} in Resource Group #{vm_extension_params[:resource_group]}"
+          Fog::Logger.debug msg
+
+          vm_extension = create_virtual_machine_extension_object(vm_extension_params)
+          begin
+            vm_extension_obj = @compute_mgmt_client.virtual_machine_extensions.create_or_update(vm_extension_params[:resource_group], vm_extension_params[:vm_name], vm_extension_params[:name], vm_extension)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Extension #{vm_extension.name} for Virtual Machine #{vm_extension_params[:vm_name]} in Resource Group #{vm_extension_params[:resource_group]} created/updated successfully"
+          vm_extension_obj
+        end
+
+        private
+
+        def create_virtual_machine_extension_object(virtual_machine_extension)
+          vm_extension = Azure::ARM::Compute::Models::VirtualMachineExtension.new
+          vm_extension.name = virtual_machine_extension[:name]
+          vm_extension.location = virtual_machine_extension[:location]
+          vm_extension.virtual_machine_extension_type = virtual_machine_extension[:type]
+          vm_extension.publisher = virtual_machine_extension[:publisher]
+          vm_extension.type_handler_version = virtual_machine_extension[:type_handler_version]
+          vm_extension.auto_upgrade_minor_version = virtual_machine_extension[:auto_upgrade_minor_version]
+          vm_extension.settings = virtual_machine_extension[:settings]
+          vm_extension.protected_settings = virtual_machine_extension[:protected_settings]
+          vm_extension
+        end
+      end
+
+      # Mock class for Compute Request
+      class Mock
+        def add_or_update_vm_extension(*)
+          body = {
+            'id' => '/subscriptions/########-####-####-####-############/resourceGroups/TestRG/providers/Microsoft.Compute/virtualMachines/TestVM/extensions/IaaSAntimalware',
+            'name' => 'IaasAntimalware',
+            'resource_group' => 'fog-test-rg',
+            'location' => 'West US',
+            'properties' => {
+              'publisher' => 'Microsoft.Azure.Security',
+              'type' => 'IaaSAntimalware',
+              'typeHandlerVersion' => '1.3',
+              'autoUpgradeMinorVersion' => 'true',
+              'forceUpdateTag' => 'RerunExtension',
+              'settings' => {
+                'AnitmalwareEnabled' => 'true',
+                'RealtimeProtectionEnabled' => 'false'
+              },
+              'protected_settings' => {}
+            }
+          }
+          extension_mapper = Azure::ARM::Compute::Models::VirtualMachineExtension.mapper
+          @compute_mgmt_client.deserialize(extension_mapper, body, 'result.body')
+        end
+      end
+    end
+  end
+end

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

@@ -26,7 +26,11 @@ module Fog
                                                                    vm_hash[:publisher],
                                                                    vm_hash[:offer],
                                                                    vm_hash[:sku],
-                                                                   vm_hash[:version])
+                                                                   vm_hash[:version],
+                                                                   vm_hash[:vhd_path],
+                                                                   vm_hash[:platform],
+                                                                   vm_hash[:resource_group])
+
           virtual_machine.os_profile = if vm_hash[:platform].casecmp(WINDOWS).zero?
                                          define_windows_os_profile(vm_hash[:name],
                                                                    vm_hash[:username],
@@ -62,21 +66,54 @@ module Fog
           hw_profile
         end
 
-        def define_storage_profile(vm_name, storage_account_name, publisher, offer, sku, version)
+        def define_storage_profile(vm_name, storage_account_name, publisher, offer, sku, version, vhd_path, platform, resource_group)
           storage_profile = Azure::ARM::Compute::Models::StorageProfile.new
           os_disk = Azure::ARM::Compute::Models::OSDisk.new
           vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
-          image_reference = Azure::ARM::Compute::Models::ImageReference.new
 
-          image_reference.publisher = publisher
-          image_reference.offer = offer
-          image_reference.sku = sku
-          image_reference.version = version
           vhd.uri = "http://#{storage_account_name}.blob.core.windows.net/vhds/#{vm_name}_os_disk.vhd"
+
+          if vhd_path.nil?
+            image_reference = Azure::ARM::Compute::Models::ImageReference.new
+            image_reference.publisher = publisher
+            image_reference.offer = offer
+            image_reference.sku = sku
+            image_reference.version = version
+            storage_profile.image_reference = image_reference
+          else
+            # Copy if VHD does not exist belongs to same storage account.
+            vhd_storage_account = (vhd_path.split('/')[2]).split('.')[0]
+            if storage_account_name != vhd_storage_account
+              storage_account = @storage_service.storage_accounts.get(resource_group, storage_account_name)
+              access_key = storage_account.get_access_keys[0].value
+              storage_data = Fog::Storage.new(provider: 'AzureRM', azure_storage_account_name: storage_account_name, azure_storage_access_key: access_key)
+
+              container_name = 'customimagevhd'
+              blob_name = 'vhd_image.vhd'
+              storage_data.directories.create(
+                key: container_name
+              )
+
+              storage_data.copy_blob_from_uri(container_name, blob_name, vhd_path)
+              until storage_data.get_blob_properties(container_name, blob_name).properties[:copy_status] == 'success'
+                Fog::Logger.debug 'Waiting disk to ready'
+                sleep(10)
+              end
+              new_vhd_path = "http://#{storage_account_name}.blob.core.windows.net/customimagevhd/vhd_image.vhd"
+              Fog::Logger.debug "Path:#{new_vhd_path}. | Copy done"
+            else
+              new_vhd_path = vhd_path
+            end
+
+            img_vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
+            img_vhd.uri = new_vhd_path
+            os_disk.image = img_vhd
+            os_disk.os_type = platform
+          end
+
           os_disk.name = "#{vm_name}_os_disk"
           os_disk.vhd = vhd
           os_disk.create_option = Azure::ARM::Compute::Models::DiskCreateOptionTypes::FromImage
-          storage_profile.image_reference = image_reference
           storage_profile.os_disk = os_disk
           storage_profile
         end

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

@@ -0,0 +1,28 @@
+module Fog
+  module Compute
+    class AzureRM
+      # Real class for Compute Request
+      class Real
+        def delete_vm_extension(resource_group, vm_name, extension_name)
+          msg = "Deleting Extension #{extension_name} of Virtual Machine #{vm_name} in Resource Group #{resource_group}"
+          Fog::Logger.debug msg
+          begin
+            @compute_mgmt_client.virtual_machine_extensions.delete(resource_group, vm_name, extension_name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Extension #{extension_name} of Virtual Machine #{vm_name} in Resource Group #{resource_group} deleted successfully"
+          true
+        end
+      end
+
+      # Mock class for Compute Request
+      class Mock
+        def delete_vm_extension(*)
+          Fog::Logger.debug 'Extension extension_name of Virtual Machine vm_name in Resource Group resource_group deleted successfully'
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Fog
+  module Compute
+    class AzureRM
+      # Real class for Compute Request
+      class Real
+        def get_vm_extension(resource_group_name, virtual_machine_name, vm_extension_name)
+          msg = "Getting Extension #{vm_extension_name} of Virtual Machine #{virtual_machine_name} in Resource Group #{resource_group_name}"
+          Fog::Logger.debug msg
+          begin
+            vm_extension = @compute_mgmt_client.virtual_machine_extensions.get(resource_group_name, virtual_machine_name, vm_extension_name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "#{msg} successful"
+          vm_extension
+        end
+      end
+
+      # Mock class for Compute Request
+      class Mock
+        def get_vm_extension(*)
+          body = {
+            'id' => '/subscriptions/########-####-####-####-############/resourceGroups/TestRG/providers/Microsoft.Compute/virtualMachines/TestVM/extensions/IaaSAntimalware',
+            'name' => 'IaasAntimalware',
+            'resource_group' => 'fog-test-rg',
+            'location' => 'West US',
+            'properties' => {
+              'publisher' => 'Microsoft.Azure.Security',
+              'type' => 'IaaSAntimalware',
+              'typeHandlerVersion' => '1.3',
+              'autoUpgradeMinorVersion' => 'true',
+              'forceUpdateTag' => 'RerunExtension',
+              'settings' => {
+                'AnitmalwareEnabled' => 'true',
+                'RealtimeProtectionEnabled' => 'false'
+              },
+              'protected_settings' => {}
+            }
+          }
+          extension_mapper = Azure::ARM::Compute::Models::VirtualMachineExtension.mapper
+          @compute_mgmt_client.deserialize(extension_mapper, body, 'result.body')
+        end
+      end
+    end
+  end
+end

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

@@ -19,53 +19,66 @@ module Fog
         private
 
         def get_express_route_circuit_object(circuit_parameters)
+          sku = create_express_route_circuit_sku(circuit_parameters[:sku_name], circuit_parameters[:sku_family], circuit_parameters[:sku_tier])
+          service_provider_prop = create_express_route_service_provider_properties(circuit_parameters[:service_provider_name], circuit_parameters[:peering_location], circuit_parameters[:bandwidth_in_mbps])
+          create_express_route_circuit(service_provider_prop, circuit_parameters[:peerings], circuit_parameters[:circuit_name], circuit_parameters[:location], sku, circuit_parameters[:tags])
+        end
+
+        def create_express_route_circuit_sku(sku_name, sku_family, sku_tier)
           sku = Azure::ARM::Network::Models::ExpressRouteCircuitSku.new
-          sku.name = circuit_parameters[:sku_name]
-          sku.family = circuit_parameters[:sku_family]
-          sku.tier = circuit_parameters[:sku_tier]
+          sku.name = sku_name
+          sku.family = sku_family
+          sku.tier = sku_tier
+          sku
+        end
 
+        def create_express_route_service_provider_properties(service_provider_name, peering_location, bandwidth_in_mbps)
           service_provider_prop = Azure::ARM::Network::Models::ExpressRouteCircuitServiceProviderProperties.new
-          service_provider_prop.service_provider_name = circuit_parameters[:service_provider_name]
-          service_provider_prop.peering_location = circuit_parameters[:peering_location]
-          service_provider_prop.bandwidth_in_mbps = circuit_parameters[:bandwidth_in_mbps]
+          service_provider_prop.service_provider_name = service_provider_name
+          service_provider_prop.peering_location = peering_location
+          service_provider_prop.bandwidth_in_mbps = bandwidth_in_mbps
+          service_provider_prop
+        end
 
+        def create_express_route_circuit(service_provider_prop, peerings, circuit_name, location, sku, tags)
           express_route_circuit = Azure::ARM::Network::Models::ExpressRouteCircuit.new
           express_route_circuit.service_provider_properties = service_provider_prop
-          if circuit_parameters[:peerings]
-            circuit_peerings = get_circuit_peerings(circuit_parameters[:peerings])
-            express_route_circuit.peerings = circuit_peerings
-          end
-          express_route_circuit.name = circuit_parameters[:circuit_name]
-          express_route_circuit.location = circuit_parameters[:location]
+          express_route_circuit.peerings = get_circuit_peerings(peerings) if peerings
+          express_route_circuit.name = circuit_name
+          express_route_circuit.location = location
           express_route_circuit.sku = sku
-          express_route_circuit.tags = circuit_parameters[:tags] if express_route_circuit.tags.nil?
-
+          express_route_circuit.tags = tags if express_route_circuit.tags.nil?
           express_route_circuit
         end
 
         def get_circuit_peerings(peerings)
           circuit_peerings = []
           peerings.each do |peering|
-            circuit_peering = Azure::ARM::Network::Models::ExpressRouteCircuitPeering.new
-            circuit_peering.peering_type = peering[:peering_type]
-            circuit_peering.peer_asn = peering[:peer_asn]
-            circuit_peering.primary_peer_address_prefix = peering[:primary_peer_address_prefix]
-            circuit_peering.secondary_peer_address_prefix = peering[:secondary_peer_address_prefix]
-            circuit_peering.vlan_id = peering[:vlan_id]
-            if peering[:peering_type].casecmp(MICROSOFT_PEERING) == 0
-              peering_config = Azure::ARM::Network::Models::ExpressRouteCircuitPeeringConfig.new
-              peering_config.advertised_public_prefixes = peering[:advertised_public_prefixes]
-              peering_config.advertised_public_prefixes_state = peering[:advertised_public_prefix_state]
-              peering_config.customer_asn = peering[:customer_asn]
-              peering_config.routing_registry_name = peering[:routing_registry_name]
-              circuit_peering.microsoft_peering_config = peering_config
-            end
-
-            circuit_peering.name = peering[:name]
-            circuit_peerings.push(circuit_peering)
+            circuit_peering_object = get_circuit_peering_object(peering)
+            circuit_peerings.push(circuit_peering_object)
           end
           circuit_peerings
         end
+
+        def create_express_route_circuit_peering(peering_type, peer_asn, primary_peer_address_prefix, secondary_peer_address_prefix, vlan_id, name)
+          circuit_peering = Azure::ARM::Network::Models::ExpressRouteCircuitPeering.new
+          circuit_peering.peering_type = peering_type
+          circuit_peering.peer_asn = peer_asn
+          circuit_peering.primary_peer_address_prefix = primary_peer_address_prefix
+          circuit_peering.secondary_peer_address_prefix = secondary_peer_address_prefix
+          circuit_peering.vlan_id = vlan_id
+          circuit_peering.name = name
+          circuit_peering
+        end
+
+        def create_express_route_circuit_peering_config(advertised_public_prefixes, advertised_public_prefix_state, customer_asn, routing_registry_name)
+          peering_config = Azure::ARM::Network::Models::ExpressRouteCircuitPeeringConfig.new
+          peering_config.advertised_public_prefixes = advertised_public_prefixes
+          peering_config.advertised_public_prefixes_state = advertised_public_prefix_state
+          peering_config.customer_asn = customer_asn
+          peering_config.routing_registry_name = routing_registry_name
+          peering_config
+        end
       end
 
       # Mock class for Network Request