fog-azure-rm 0.1.0 → 0.1.1

data/lib/fog/azurerm/models/application_gateway/gateway.rb

@@ -39,62 +39,62 @@ module Fog
 
           hash['gateway_ip_configurations'] = []
           gateway.gateway_ipconfigurations.each do |ip_configuration|
-            gateway_ip_configuration = IPConfiguration.new
-            hash['gateway_ip_configurations'] << gateway_ip_configuration.merge_attributes(IPConfiguration.parse(ip_configuration))
+            gateway_ip_configuration = Fog::ApplicationGateway::AzureRM::IPConfiguration.new
+            hash['gateway_ip_configurations'] << gateway_ip_configuration.merge_attributes(Fog::ApplicationGateway::AzureRM::IPConfiguration.parse(ip_configuration))
           end unless gateway.gateway_ipconfigurations.nil?
 
           hash['ssl_certificates'] = []
           gateway.ssl_certificates.each do |certificate|
-            ssl_certificate = SslCertificate.new
-            hash['ssl_certificates'] << ssl_certificate.merge_attributes(SslCertificate.parse(certificate))
+            ssl_certificate = Fog::ApplicationGateway::AzureRM::SslCertificate.new
+            hash['ssl_certificates'] << ssl_certificate.merge_attributes(Fog::ApplicationGateway::AzureRM::SslCertificate.parse(certificate))
           end unless gateway.ssl_certificates.nil?
 
           hash['frontend_ip_configurations'] = []
           gateway.frontend_ipconfigurations.each do |frontend_ip_config|
-            frontend_ip_configuration = FrontendIPConfiguration.new
-            hash['frontend_ip_configurations'] << frontend_ip_configuration.merge_attributes(FrontendIPConfiguration.parse(frontend_ip_config))
+            frontend_ip_configuration = Fog::ApplicationGateway::AzureRM::FrontendIPConfiguration.new
+            hash['frontend_ip_configurations'] << frontend_ip_configuration.merge_attributes(Fog::ApplicationGateway::AzureRM::FrontendIPConfiguration.parse(frontend_ip_config))
           end unless gateway.frontend_ipconfigurations.nil?
 
           hash['frontend_ports'] = []
           gateway.frontend_ports.each do |port|
-            frontend_port = FrontendPort.new
-            hash['frontend_ports'] << frontend_port.merge_attributes(FrontendPort.parse(port))
+            frontend_port = Fog::ApplicationGateway::AzureRM::FrontendPort.new
+            hash['frontend_ports'] << frontend_port.merge_attributes(Fog::ApplicationGateway::AzureRM::FrontendPort.parse(port))
           end unless gateway.frontend_ports.nil?
 
           hash['probes'] = []
           gateway.probes.each do |probe|
-            gateway_probe = Probe.new
-            hash['probes'] << gateway_probe.merge_attributes(Probe.parse(probe))
+            gateway_probe = Fog::ApplicationGateway::AzureRM::Probe.new
+            hash['probes'] << gateway_probe.merge_attributes(Fog::ApplicationGateway::AzureRM::Probe.parse(probe))
           end unless gateway.probes.nil?
 
           hash['backend_address_pools'] = []
           gateway.backend_address_pools.each do |address|
-            backend_address_pool = BackendAddressPool.new
-            hash['backend_address_pools'] << backend_address_pool.merge_attributes(BackendAddressPool.parse(address))
+            backend_address_pool = Fog::ApplicationGateway::AzureRM::BackendAddressPool.new
+            hash['backend_address_pools'] << backend_address_pool.merge_attributes(Fog::ApplicationGateway::AzureRM::BackendAddressPool.parse(address))
           end unless gateway.backend_address_pools.nil?
 
           hash['backend_http_settings_list'] = []
           gateway.backend_http_settings_collection.each do |http_setting|
-            backend_http_setting = BackendHttpSetting.new
-            hash['backend_http_settings_list'] << backend_http_setting.merge_attributes(BackendHttpSetting.parse(http_setting))
+            backend_http_setting = Fog::ApplicationGateway::AzureRM::BackendHttpSetting.new
+            hash['backend_http_settings_list'] << backend_http_setting.merge_attributes(Fog::ApplicationGateway::AzureRM::BackendHttpSetting.parse(http_setting))
           end unless gateway.backend_http_settings_collection.nil?
 
           hash['http_listeners'] = []
           gateway.http_listeners.each do |listener|
-            http_listener = HttpListener.new
-            hash['http_listeners'] << http_listener.merge_attributes(HttpListener.parse(listener))
+            http_listener = Fog::ApplicationGateway::AzureRM::HttpListener.new
+            hash['http_listeners'] << http_listener.merge_attributes(Fog::ApplicationGateway::AzureRM::HttpListener.parse(listener))
           end unless gateway.http_listeners.nil?
 
           hash['url_path_maps'] = []
           gateway.url_path_maps.each do |map|
-            url_path_map = UrlPathMap.new
-            hash['url_path_maps'] << url_path_map.merge_attributes(UrlPathMap.parse(map))
+            url_path_map = Fog::ApplicationGateway::AzureRM::UrlPathMap.new
+            hash['url_path_maps'] << url_path_map.merge_attributes(Fog::ApplicationGateway::AzureRM::UrlPathMap.parse(map))
           end unless gateway.url_path_maps.nil?
 
           hash['request_routing_rules'] = []
           gateway.request_routing_rules.each do |rule|
-            request_routing_rule = RequestRoutingRule.new
-            hash['request_routing_rules'] << request_routing_rule.merge_attributes(RequestRoutingRule.parse(rule))
+            request_routing_rule = Fog::ApplicationGateway::AzureRM::RequestRoutingRule.new
+            hash['request_routing_rules'] << request_routing_rule.merge_attributes(Fog::ApplicationGateway::AzureRM::RequestRoutingRule.parse(rule))
           end unless gateway.request_routing_rules.nil?
           hash
         end
@@ -112,12 +112,11 @@ module Fog
           validate_http_listeners(http_listeners) unless http_listeners.nil?
           validate_url_path_maps(url_path_maps) unless url_path_maps.nil?
           validate_request_routing_rules(request_routing_rules) unless request_routing_rules.nil?
-          gateway_params = get_gateway_params
-          gateway = service.create_or_update_application_gateway(gateway_params)
+          gateway = service.create_or_update_application_gateway(application_gateway_params)
           merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
         end
 
-        def get_gateway_params
+        def application_gateway_params
           {
             name: name,
             location: location,
@@ -548,54 +547,54 @@ module Fog
         end
 
         def update_sku(sku_name, sku_capacity = nil)
-          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash = serialize_sub_resources(application_gateway_params)
           gateway = service.update_sku_attributes(gateway_hash, sku_name, sku_capacity)
           merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
         end
 
         def update_gateway_ip_configuration(subnet_id)
-          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash = serialize_sub_resources(application_gateway_params)
           gateway = service.update_subnet_id_in_gateway_ip_configuration(gateway_hash, subnet_id)
           merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
         end
 
         def add_ssl_certificate(ssl_certificate_obj)
-          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash = serialize_sub_resources(application_gateway_params)
           gateway_hash[:ssl_certificates] << ssl_certificate_obj
           gateway = service.create_or_update_application_gateway(gateway_hash)
           merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
         end
 
         def remove_ssl_certificate(ssl_certificate_obj)
-          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash = serialize_sub_resources(application_gateway_params)
           gateway_hash[:ssl_certificates].delete(ssl_certificate_obj)
           gateway = service.create_or_update_application_gateway(gateway_hash)
           merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
         end
 
         def add_frontend_port(frontend_port_obj)
-          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash = serialize_sub_resources(application_gateway_params)
           gateway_hash[:frontend_ports] << frontend_port_obj
           gateway = service.create_or_update_application_gateway(gateway_hash)
           merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
         end
 
         def remove_frontend_port(frontend_port_obj)
-          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash = serialize_sub_resources(application_gateway_params)
           gateway_hash[:frontend_ports].delete(frontend_port_obj)
           gateway = service.create_or_update_application_gateway(gateway_hash)
           merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
         end
 
         def add_probe(probe_obj)
-          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash = serialize_sub_resources(application_gateway_params)
           gateway_hash[:probes] << probe_obj
           gateway = service.create_or_update_application_gateway(gateway_hash)
           merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
         end
 
         def remove_probe(probe_obj)
-          gateway_hash = serialize_sub_resources(get_gateway_params)
+          gateway_hash = serialize_sub_resources(application_gateway_params)
           gateway_hash[:probes].delete(probe_obj)
           gateway = service.create_or_update_application_gateway(gateway_hash)
           merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))

data/lib/fog/azurerm/models/application_gateway/gateways.rb

@@ -3,22 +3,22 @@ module Fog
     class AzureRM
       # Application Gateway collection class for Application Gateway Service
       class Gateways < Fog::Collection
-        model Gateway
+        model Fog::ApplicationGateway::AzureRM::Gateway
         attribute :resource_group
 
         def all
           requires :resource_group
           application_gateways = []
           service.list_application_gateways(resource_group).each do |gateway|
-            application_gateways << Gateway.parse(gateway)
+            application_gateways << Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway)
           end
           load(application_gateways)
         end
 
         def get(resource_group_name, application_gateway_name)
           gateway = service.get_application_gateway(resource_group_name, application_gateway_name)
-          application_gateway = Gateway.new(service: service)
-          application_gateway.merge_attributes(Gateway.parse(gateway))
+          application_gateway = Fog::ApplicationGateway::AzureRM::Gateway.new(service: service)
+          application_gateway.merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
         end
       end
     end

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

@@ -4,7 +4,7 @@ module Fog
       # This class is giving implementation of all/list, get and
       # check name availability for storage account.
       class AvailabilitySets < Fog::Collection
-        model AvailabilitySet
+        model Fog::Compute::AzureRM::AvailabilitySet
         attribute :resource_group
         def all
           accounts = []
@@ -13,7 +13,7 @@ module Fog
             service.list_availability_sets(resource_group)
           unless list_of_availability_sets.nil?
             list_of_availability_sets.each do |account|
-              parse_response = AvailabilitySet.parse(account)
+              parse_response = Fog::Compute::AzureRM::AvailabilitySet.parse(account)
               accounts << parse_response
             end
           end
@@ -22,8 +22,8 @@ module Fog
 
         def get(resource_group, identity)
           availability_set = service.get_availability_set(resource_group, identity)
-          availability_set_obj = AvailabilitySet.new(service: service)
-          availability_set_obj.merge_attributes(AvailabilitySet.parse(availability_set))
+          availability_set_fog = Fog::Compute::AzureRM::AvailabilitySet.new(service: service)
+          availability_set_fog.merge_attributes(Fog::Compute::AzureRM::AvailabilitySet.parse(availability_set))
         end
       end
     end

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

@@ -1,4 +1,3 @@
-require 'fog/azurerm/models/storage/data_disk'
 module Fog
   module Compute
     class AzureRM
@@ -37,14 +36,16 @@ module Fog
           hash['name'] = vm.name
           hash['location'] = vm.location
           hash['resource_group'] = get_resource_group_from_id(vm.id)
-          hash['vm_size'] = vm.hardware_profile.vm_size
-          hash['os_disk_name'] = vm.storage_profile.os_disk.name
-          hash['os_disk_vhd_uri'] = vm.storage_profile.os_disk.vhd.uri
-          unless vm.storage_profile.image_reference.nil?
-            hash['publisher'] = vm.storage_profile.image_reference.publisher
-            hash['offer'] = vm.storage_profile.image_reference.offer
-            hash['sku'] = vm.storage_profile.image_reference.sku
-            hash['version'] = vm.storage_profile.image_reference.version
+          hash['vm_size'] = vm.hardware_profile.vm_size unless vm.hardware_profile.vm_size.nil?
+          unless vm.storage_profile.nil?
+            hash['os_disk_name'] = vm.storage_profile.os_disk.name
+            hash['os_disk_vhd_uri'] = vm.storage_profile.os_disk.vhd.uri
+            unless vm.storage_profile.image_reference.nil?
+              hash['publisher'] = vm.storage_profile.image_reference.publisher
+              hash['offer'] = vm.storage_profile.image_reference.offer
+              hash['sku'] = vm.storage_profile.image_reference.sku
+              hash['version'] = vm.storage_profile.image_reference.version
+            end
           end
           hash['username'] = vm.os_profile.admin_username
           hash['custom_data'] = vm.os_profile.custom_data
@@ -73,8 +74,7 @@ module Fog
           requires :disable_password_authentication if platform.casecmp('linux').zero?
           requires :publisher, :offer, :sku, :version if vhd_path.nil?
           ssh_key_path = "/home/#{username}/.ssh/authorized_keys" unless ssh_key_data.nil?
-          virtual_machine_params = get_virtual_machine_params(ssh_key_path)
-          vm = service.create_virtual_machine(virtual_machine_params)
+          vm = service.create_virtual_machine(virtual_machine_params(ssh_key_path))
           merge_attributes(Server.parse(vm))
         end
 
@@ -116,17 +116,17 @@ module Fog
 
         def attach_data_disk(disk_name, disk_size, storage_account_name)
           vm = service.attach_data_disk_to_vm(resource_group, name, disk_name, disk_size, storage_account_name)
-          merge_attributes(Server.parse(vm))
+          merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
         end
 
         def detach_data_disk(disk_name)
           vm = service.detach_data_disk_from_vm(resource_group, name, disk_name)
-          merge_attributes(Server.parse(vm))
+          merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
         end
 
         private
 
-        def get_virtual_machine_params(ssh_key_path)
+        def virtual_machine_params(ssh_key_path)
           {
             resource_group: resource_group,
             name: name,

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

@@ -5,21 +5,21 @@ module Fog
       # for Server.
       class Servers < Fog::Collection
         attribute :resource_group
-        model Server
+        model Fog::Compute::AzureRM::Server
 
         def all
           requires :resource_group
           virtual_machines = []
           service.list_virtual_machines(resource_group).each do |vm|
-            virtual_machines << Server.parse(vm)
+            virtual_machines << Fog::Compute::AzureRM::Server.parse(vm)
           end
           load(virtual_machines)
         end
 
         def get(resource_group_name, virtual_machine_name)
           virtual_machine = service.get_virtual_machine(resource_group_name, virtual_machine_name)
-          virtual_machine_obj = Server.new(service: service)
-          virtual_machine_obj.merge_attributes(Server.parse(virtual_machine))
+          virtual_machine_fog = Fog::Compute::AzureRM::Server.new(service: service)
+          virtual_machine_fog.merge_attributes(Fog::Compute::AzureRM::Server.parse(virtual_machine))
         end
       end
     end

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

@@ -33,17 +33,15 @@ module Fog
 
         def save
           requires :resource_group, :location, :name, :vm_name, :type, :publisher, :type_handler_version, :settings
-          vm_extension_params = get_vm_extension_params
           vm_extension = service.create_or_update_vm_extension(vm_extension_params)
-          merge_attributes(VirtualMachineExtension.parse(vm_extension))
+          merge_attributes(Fog::Compute::AzureRM::VirtualMachineExtension.parse(vm_extension))
         end
 
         def update(vm_extension_input)
           validate_input(vm_extension_input)
           merge_attributes(vm_extension_input) unless vm_extension_input.empty?
-          vm_extension_params = get_vm_extension_params
           vm_extension = service.create_or_update_vm_extension(vm_extension_params)
-          merge_attributes(VirtualMachineExtension.parse(vm_extension))
+          merge_attributes(Fog::Compute::AzureRM::VirtualMachineExtension.parse(vm_extension))
         end
 
         def destroy
@@ -58,7 +56,7 @@ module Fog
           raise 'Cannot modify the given attribute(s)' unless result.empty?
         end
 
-        def get_vm_extension_params
+        def vm_extension_params
           {
             resource_group: resource_group,
             location: location,

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

@@ -3,23 +3,23 @@ module Fog
     class AzureRM
       # This class gives the implementation for get for virtual machine extension
       class VirtualMachineExtensions < Fog::Collection
-        model VirtualMachineExtension
+        model Fog::Compute::AzureRM::VirtualMachineExtension
         attribute :resource_group
         attribute :vm_name
 
         def all
           requires :resource_group, :vm_name
           vm_extensions = []
-          service.get_virtual_machine(resource_group, vm_name).resources.each do |extension|
-            vm_extensions << VirtualMachineExtension.parse(extension)
+          service.get_virtual_machine(resource_group, vm_name).resources.compact.each do |extension|
+            vm_extensions << Fog::Compute::AzureRM::VirtualMachineExtension.parse(extension)
           end
           load(vm_extensions)
         end
 
         def get(resource_group_name, virtual_machine_name, vm_extension_name)
           vm_extension = service.get_vm_extension(resource_group_name, virtual_machine_name, vm_extension_name)
-          vm_extension_obj = VirtualMachineExtension.new(service: service)
-          vm_extension_obj.merge_attributes(VirtualMachineExtension.parse(vm_extension))
+          vm_extension_fog = Fog::Compute::AzureRM::VirtualMachineExtension.new(service: service)
+          vm_extension_fog.merge_attributes(Fog::Compute::AzureRM::VirtualMachineExtension.parse(vm_extension))
         end
       end
     end

data/lib/fog/azurerm/models/dns/record_sets.rb

@@ -8,21 +8,21 @@ module Fog
         attribute :zone_name
         attribute :type
 
-        model RecordSet
+        model Fog::DNS::AzureRM::RecordSet
 
         def all
           requires :resource_group, :zone_name
           record_sets = []
           service.list_record_sets(resource_group, zone_name).each do |r|
-            record_sets << RecordSet.parse(r)
+            record_sets << Fog::DNS::AzureRM::RecordSet.parse(r)
           end
           load(record_sets)
         end
 
         def get(resource_group, name, zone_name, record_type)
           record_set = service.get_record_set(resource_group, name, zone_name, record_type)
-          record_set_obj = RecordSet.new(service: service)
-          record_set_obj.merge_attributes(RecordSet.parse(record_set))
+          record_set_fog = Fog::DNS::AzureRM::RecordSet.new(service: service)
+          record_set_fog.merge_attributes(Fog::DNS::AzureRM::RecordSet.parse(record_set))
         end
       end
     end

data/lib/fog/azurerm/models/dns/zones.rb

@@ -4,20 +4,20 @@ module Fog
       # This class is giving implementation of
       # all/get for Zones.
       class Zones < Fog::Collection
-        model Zone
+        model Fog::DNS::AzureRM::Zone
 
         def all
           zones = []
           service.list_zones.each do |z|
-            zones << Zone.parse(z)
+            zones << Fog::DNS::AzureRM::Zone.parse(z)
           end
           load(zones)
         end
 
         def get(resource_group, name)
           zone = service.get_zone(resource_group, name)
-          zone_obj = Zone.new(service: service)
-          zone_obj.merge_attributes(Zone.parse(zone))
+          zone_fog = Fog::DNS::AzureRM::Zone.new(service: service)
+          zone_fog.merge_attributes(Fog::DNS::AzureRM::Zone.parse(zone))
         end
 
         def check_for_zone(resource_group, name)

data/lib/fog/azurerm/models/network/express_route_circuit.rb

@@ -29,7 +29,6 @@ module Fog
           express_route_circuit['service_key'] = circuit.service_key
           express_route_circuit['service_provider_notes'] = circuit.service_provider_notes
           express_route_circuit['resource_group'] = get_resource_group_from_id(circuit.id)
-          express_route_circuit['resource_group'] = circuit.id.split('/')[4]
           express_route_circuit['tags'] = circuit.tags
           sku = circuit.sku
           unless sku.nil?
@@ -56,8 +55,7 @@ module Fog
 
         def save
           requires :location, :tags, :resource_group, :service_provider_name, :peering_location, :bandwidth_in_mbps
-          express_route_parameters = express_route_circuit_params
-          circuit = service.create_or_update_express_route_circuit(express_route_parameters)
+          circuit = service.create_or_update_express_route_circuit(express_route_circuit_params)
           merge_attributes(Fog::Network::AzureRM::ExpressRouteCircuit.parse(circuit))
         end
 
@@ -68,7 +66,7 @@ module Fog
         private
 
         def express_route_circuit_params
-          express_route_parameters = {
+          {
             resource_group_name: resource_group,
             circuit_name: name,
             location: location,
@@ -81,7 +79,6 @@ module Fog
             bandwidth_in_mbps: bandwidth_in_mbps,
             peerings: peerings
           }
-          express_route_parameters
         end
       end
     end