fog-azure-rm 0.0.4 → 0.0.5

data/lib/fog/azurerm/models/resources/resource_group.rb

@@ -8,11 +8,19 @@ module Fog
         attribute :id
         attribute :location
 
+        def self.parse(resource_group)
+          hash = {}
+          hash['id'] = resource_group.id
+          hash['name'] = resource_group.name
+          hash['location'] = resource_group.location
+          hash
+        end
+
         def save
           requires :name
           requires :location
           resource_group = service.create_resource_group(name, location)
-          merge_attributes(resource_group)
+          merge_attributes(Fog::Resources::AzureRM::ResourceGroup.parse(resource_group))
         end
 
         def destroy

data/lib/fog/azurerm/models/resources/resource_groups.rb

@@ -10,7 +10,11 @@ module Fog
         model Fog::Resources::AzureRM::ResourceGroup
 
         def all
-          load(service.list_resource_groups)
+          resource_groups = []
+          service.list_resource_groups.each do |resource_group|
+            resource_groups.push(Fog::Resources::AzureRM::ResourceGroup.parse(resource_group))
+          end
+          load(resource_groups)
         end
 
         def get(identity)

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

@@ -12,12 +12,12 @@ module Fog
 
         def self.parse(disk)
           hash = {}
-          hash['name'] = disk['name']
-          hash['disk_size_gb'] = disk['diskSizeGB']
-          hash['lun'] = disk['lun']
-          hash['vhd_uri'] = disk['vhd']['uri']
-          hash['caching'] = disk['caching'] unless disk['caching'].nil?
-          hash['create_option'] = disk['createOption']
+          hash['name'] = disk.name
+          hash['disk_size_gb'] = disk.disk_size_gb
+          hash['lun'] = disk.lun
+          hash['vhd_uri'] = disk.vhd.uri
+          hash['caching'] = disk.caching unless disk.caching.nil?
+          hash['create_option'] = disk.create_option
           hash
         end
       end

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

@@ -7,23 +7,52 @@ module Fog
         identity  :name
         attribute :location
         attribute :resource_group
-        attribute :account_type
+        attribute :sku_name
+        attribute :replication
+
+        def self.parse(storage_account)
+          hash = {}
+          hash['id'] = storage_account.id
+          hash['name'] = storage_account.name
+          hash['location'] = storage_account.location
+          hash['resource_group'] = get_resource_group_from_id(storage_account.id)
+          hash['sku_name'] = storage_account.sku.name.split('_').first
+          hash['replication'] = storage_account.sku.name.split('_').last
+          hash
+        end
 
         def save
           requires :name
           requires :location
           requires :resource_group
-          hash = {}
           # Create a model for new storage account.
-          properties = Azure::ARM::Storage::Models::StorageAccountPropertiesCreateParameters.new
-          properties.account_type = 'Standard_LRS' # This might change in the near future!
+          self.sku_name = STANDARD_STORAGE if sku_name.nil?
+          self.replication = ALLOWED_STANDARD_REPLICATION.first if replication.nil?
+          validate_sku_name!
+          storage_account_arguments = get_storage_account_arguments
+          storage_account = service.create_storage_account(storage_account_arguments)
+          merge_attributes(Fog::Storage::AzureRM::StorageAccount.parse(storage_account))
+        end
+
+        def get_storage_account_arguments
+          {
+            resource_group: resource_group,
+            name: name,
+            sku_name: sku_name,
+            location: location,
+            replication: replication
+          }
+        end
 
-          params = Azure::ARM::Storage::Models::StorageAccountCreateParameters.new
-          params.properties = properties
-          params.location = location
-          sa = service.create_storage_account(resource_group, name, params)
-          hash['account_type'] = sa['properties']['accountType']
-          merge_attributes(hash)
+        def validate_sku_name!
+          case sku_name
+          when STANDARD_STORAGE
+            raise 'Standard Replications can only be LRS, ZRS, GRS or RAGRS.' unless ALLOWED_STANDARD_REPLICATION.include?(replication)
+          when PREMIUM_STORAGE
+            raise 'Premium Replication can only be LRS.' if replication != 'LRS'
+          else
+            raise 'Account Type can only be Standard or Premium'
+          end
         end
 
         def get_access_keys(options = {})
@@ -33,6 +62,8 @@ module Fog
         def destroy
           service.delete_storage_account(resource_group, name)
         end
+
+        private :get_storage_account_arguments, :validate_sku_name!
       end
     end
   end

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

@@ -18,12 +18,7 @@ module Fog
             hash_of_storage_accounts = service.list_storage_accounts
           end
           hash_of_storage_accounts.each do |account|
-            hash = {}
-            hash['name'] = account['name']
-            hash['location'] = account['location']
-            hash['resource_group'] = account['id'].split('/')[4]
-            hash['account_type'] = account['properties']['accountType']
-            accounts << hash
+            accounts << Fog::Storage::AzureRM::StorageAccount.parse(account)
           end
           load(accounts)
         end

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

@@ -0,0 +1,75 @@
+module Fog
+  module TrafficManager
+    class AzureRM
+      # Traffic Manager End Point model for Traffic Manager Service
+      class TrafficManagerEndPoint < Fog::Model
+        identity :name
+        attribute :traffic_manager_profile_name
+        attribute :id
+        attribute :resource_group
+        attribute :type
+        attribute :target_resource_id
+        attribute :target
+        attribute :endpoint_status
+        attribute :endpoint_monitor_status
+        attribute :weight
+        attribute :priority
+        attribute :endpoint_location
+        attribute :min_child_endpoints
+
+        def self.parse(endpoint)
+          hash = {}
+          hash['id'] = endpoint.id
+          hash['name'] = endpoint.name
+          hash['resource_group'] = get_resource_group_from_id(endpoint.id)
+          hash['type'] = get_end_point_type(endpoint.type)
+          hash['target_resource_id'] = endpoint.target_resource_id
+          hash['target'] = endpoint.target
+          hash['endpoint_status'] = endpoint.endpoint_status
+          hash['endpoint_monitor_status'] = endpoint.endpoint_monitor_status
+          hash['weight'] = endpoint.weight
+          hash['priority'] = endpoint.priority
+          hash['endpoint_location'] = endpoint.endpoint_location
+          hash['min_child_endpoints'] = endpoint.min_child_endpoints
+          hash['traffic_manager_profile_name'] = get_traffic_manager_profile_name_from_endpoint_id(endpoint.id)
+          hash
+        end
+
+        def save
+          requires :name, :traffic_manager_profile_name, :resource_group, :type
+          requires :target_resource_id if type.eql?(AZURE_ENDPOINTS)
+          requires :target, :endpoint_location if type.eql?(EXTERNAL_ENDPOINTS)
+          requires :target_resource_id, :endpoint_location, :min_child_endpoints if type.eql?(NESTED_ENDPOINTS)
+
+          if %w(azureEndpoints externalEndpoints nestedEndpoints).select { |type| type if type.eql?(type) }.any?
+            traffic_manager_endpoint = service.create_traffic_manager_endpoint(traffic_manager_endpoint_hash)
+            merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(traffic_manager_endpoint))
+          else
+            raise(ArgumentError, ":type should be '#{AZURE_ENDPOINTS}', '#{EXTERNAL_ENDPOINTS}' or '#{NESTED_ENDPOINTS}'")
+          end
+        end
+
+        def destroy
+          service.delete_traffic_manager_endpoint(resource_group, name, traffic_manager_profile_name, type)
+        end
+
+        private
+
+        def traffic_manager_endpoint_hash
+          {
+            resource_group: resource_group,
+            name: name,
+            traffic_manager_profile_name: traffic_manager_profile_name,
+            type: type,
+            target_resource_id: target_resource_id,
+            target: target,
+            weight: weight,
+            priority: priority,
+            endpoint_location: endpoint_location,
+            min_child_endpoints: min_child_endpoints
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Fog
+  module TrafficManager
+    class AzureRM
+      # Traffic Manager End Point Collection for TrafficManager Service
+      class TrafficManagerEndPoints < Fog::Collection
+        attribute :resource_group
+        attribute :traffic_manager_profile_name
+        model Fog::TrafficManager::AzureRM::TrafficManagerEndPoint
+
+        def all
+          requires :resource_group
+          requires :traffic_manager_profile_name
+
+          traffic_manager_endpoints = []
+          profile = service.get_traffic_manager_profile(resource_group, traffic_manager_profile_name)
+          end_points = profile.endpoints
+          end_points.each do |endpoint|
+            traffic_manager_endpoints << Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(endpoint)
+          end
+          load(traffic_manager_endpoints)
+        end
+
+        def get(resource_group, traffic_manager_profile_name, end_point_name, type)
+          endpoint = service.get_traffic_manager_end_point(resource_group, traffic_manager_profile_name, end_point_name, type)
+          endpoint_obj = Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.new(service: service)
+          endpoint_obj.merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(endpoint))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Fog
+  module TrafficManager
+    class AzureRM
+      # Traffic Manager Profile model for TrafficManager Service
+      class TrafficManagerProfile < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :location
+        attribute :profile_status
+        attribute :traffic_routing_method
+        attribute :relative_name
+        attribute :fqdn
+        attribute :ttl
+        attribute :profile_monitor_status
+        attribute :protocol
+        attribute :port
+        attribute :path
+        attribute :endpoints
+
+        def self.parse(profile)
+          hash = {}
+          hash['id'] = profile.id
+          hash['name'] = profile.name
+          hash['resource_group'] = get_resource_group_from_id(profile.id)
+          hash['location'] = profile.location
+          hash['profile_status'] = profile.profile_status
+          hash['traffic_routing_method'] = profile.traffic_routing_method
+          hash['relative_name'] = profile.dns_config.relative_name
+          hash['fqdn'] = profile.dns_config.fqdn
+          hash['ttl'] = profile.dns_config.ttl
+          hash['profile_monitor_status'] = profile.monitor_config.profile_monitor_status
+          hash['protocol'] = profile.monitor_config.protocol
+          hash['port'] = profile.monitor_config.port
+          hash['path'] = profile.monitor_config.path
+          hash['endpoints'] = []
+          profile.endpoints.each do |endpoint|
+            end_point = Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.new
+            hash['endpoints'] << end_point.merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(endpoint))
+          end
+          hash
+        end
+
+        def save
+          requires :name, :resource_group, :traffic_routing_method, :relative_name, :ttl,
+                   :protocol, :port, :path
+          traffic_manager_profile = service.create_traffic_manager_profile(resource_group, name,
+                                                                           traffic_routing_method, relative_name, ttl,
+                                                                           protocol, port, path)
+          merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(traffic_manager_profile))
+        end
+
+        def destroy
+          service.delete_traffic_manager_profile(resource_group, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module TrafficManager
+    class AzureRM
+      # Traffic Manager Profile Collection for TrafficManager Service
+      class TrafficManagerProfiles < Fog::Collection
+        attribute :resource_group
+        model Fog::TrafficManager::AzureRM::TrafficManagerProfile
+
+        def all
+          requires :resource_group
+          traffic_manager_profiles = []
+          service.list_traffic_manager_profiles(resource_group).each do |profile|
+            traffic_manager_profiles << Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(profile)
+          end
+          load(traffic_manager_profiles)
+        end
+
+        def get(resource_group, traffic_manager_profile_name)
+          profile = service.get_traffic_manager_profile(resource_group, traffic_manager_profile_name)
+          profile_obj = Fog::TrafficManager::AzureRM::TrafficManagerProfile.new(service: service)
+          profile_obj.merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(profile))
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/network.rb

@@ -23,6 +23,7 @@ module Fog
       request :check_for_virtual_network
       request :create_public_ip
       request :delete_public_ip
+      request :get_public_ip
       request :list_public_ips
       request :check_for_public_ip
       request :create_subnet
@@ -48,15 +49,19 @@ module Fog
       request :get_network_security_group
       request :add_security_rules
       request :remove_security_rule
-      request :create_application_gateway
-      request :delete_application_gateway
-      request :list_application_gateways
-      request :create_traffic_manager_profile
-      request :get_traffic_manager_profile
-      request :delete_traffic_manager_profile
-      request :list_traffic_manager_profiles
-      request :create_traffic_manager_endpoint
-      request :delete_traffic_manager_endpoint
+      request :delete_virtual_network_gateway
+      request :create_or_update_virtual_network_gateway
+      request :list_virtual_network_gateways
+      request :get_virtual_network_gateway
+      request :create_or_update_express_route_circuit
+      request :delete_express_route_circuit
+      request :get_express_route_circuit
+      request :list_express_route_circuits
+      request :create_or_update_express_route_circuit_peering
+      request :delete_express_route_circuit_peering
+      request :get_express_route_circuit_peering
+      request :list_express_route_circuit_peerings
+      request :list_express_route_service_providers
 
       model_path 'fog/azurerm/models/network'
       model :virtual_network
@@ -77,23 +82,18 @@ module Fog
       model :network_security_group
       collection :network_security_groups
       model :network_security_rule
-      model :application_gateway
-      collection :application_gateways
-      model :application_gateway_backend_address_pool
-      model :application_gateway_backend_http_setting
-      model :application_gateway_frontend_ip_configuration
-      model :application_gateway_frontend_port
-      model :application_gateway_ip_configuration
-      model :application_gateway_http_listener
       model :path_rule
-      model :application_gateway_probe
-      model :application_gateway_request_routing_rule
-      model :application_gateway_ssl_certificate
-      model :application_gateway_url_path_map
-      model :traffic_manager_profile
-      collection :traffic_manager_profiles
-      model :traffic_manager_end_point
-      collection :traffic_manager_end_points
+      model :vpn_client_configuration
+      model :vpn_client_revoked_certificates
+      model :vpn_client_root_certificates
+      model :virtual_network_gateway
+      collection :virtual_network_gateways
+      model :express_route_circuit
+      collection :express_route_circuits
+      model :express_route_circuit_peering
+      collection :express_route_circuit_peerings
+      model :express_route_service_provider
+      collection :express_route_service_providers
 
       # Mock class for Network Service
       class Mock

data/lib/fog/azurerm/requests/{network → application_gateway}/create_application_gateway.rb

@@ -1,97 +1,83 @@
 module Fog
-  module Network
+  module ApplicationGateway
     class AzureRM
-      # Real class for Network Request
+      # Real class for Application Gateway Request
       class Real
         def create_application_gateway(name, location, resource_group, sku_name, sku_tier, sku_capacity, gateway_ip_configurations, ssl_certificates, frontend_ip_configurations, frontend_ports, probes, backend_address_pools, backend_http_settings_list, http_listeners, url_path_maps, request_routing_rules)
-          Fog::Logger.debug "Creating Application Gateway: #{name}..."
+          msg = "Creating Application Gateway: #{name} in Resource Group: #{resource_group}."
+          Fog::Logger.debug msg
           gateway = define_application_gateway(name, location, sku_name, sku_tier, sku_capacity, gateway_ip_configurations, ssl_certificates, frontend_ip_configurations, frontend_ports, probes, backend_address_pools, backend_http_settings_list, http_listeners, url_path_maps, request_routing_rules)
           begin
-            promise = @network_client.application_gateways.create_or_update(resource_group, name, gateway)
-            result = promise.value!
-            Fog::Logger.debug "Application Gateway #{name} created successfully."
-            Azure::ARM::Network::Models::ApplicationGateway.serialize_object(result.body)
+            gateway_obj = @network_client.application_gateways.create_or_update(resource_group, name, gateway)
           rescue MsRestAzure::AzureOperationError => e
-            msg = "Exception creating Application Gateway #{name} in Resource Group: #{resource_group}. #{e.body['error']['message']}"
-            raise msg
+            raise_azure_exception(e, msg)
           end
+          Fog::Logger.debug "Application Gateway #{name} created successfully."
+          gateway_obj
         end
 
         private
 
         def define_application_gateway(name, location, sku_name, sku_tier, sku_capacity, gateway_ip_configurations, ssl_certificates, frontend_ip_configurations, frontend_ports, probes, backend_address_pools, backend_http_settings_list, http_listeners, url_path_maps, request_routing_rules)
-          ag_props = Azure::ARM::Network::Models::ApplicationGatewayPropertiesFormat.new
+          application_gateway = Azure::ARM::Network::Models::ApplicationGateway.new
+          application_gateway.name = name
+          application_gateway.location = location
 
           if gateway_ip_configurations
             gateway_ip_configuration_arr = define_gateway_ip_configuration(gateway_ip_configurations)
-            ag_props.gateway_ipconfigurations = []
-            ag_props.gateway_ipconfigurations = gateway_ip_configuration_arr
+            application_gateway.gateway_ipconfigurations = gateway_ip_configuration_arr
           end
 
           if ssl_certificates
             ssl_certificate_arr = define_ssl_certificate(ssl_certificates)
-            ag_props.ssl_certificates = []
-            ag_props.ssl_certificates = ssl_certificate_arr
+            application_gateway.ssl_certificates = ssl_certificate_arr
           end
 
           if frontend_ip_configurations
             frontend_ip_configuration_arr = define_frontend_ip_configurations(frontend_ip_configurations)
-            ag_props.frontend_ipconfigurations = []
-            ag_props.frontend_ipconfigurations = frontend_ip_configuration_arr
+            application_gateway.frontend_ipconfigurations = frontend_ip_configuration_arr
           end
 
           if frontend_ports
             frontend_port_arr = define_frontend_ports(frontend_ports)
-            ag_props.frontend_ports = []
-            ag_props.frontend_ports = frontend_port_arr
+            application_gateway.frontend_ports = frontend_port_arr
           end
 
           if probes
             probe_arr = define_probes(probes)
-            ag_props.probes = []
-            ag_props.probes = probe_arr
+            application_gateway.probes = probe_arr
           end
 
           if backend_address_pools
             backend_address_pool_arr = define_backend_address_pools(backend_address_pools)
-            ag_props.backend_address_pools = []
-            ag_props.backend_address_pools = backend_address_pool_arr
+            application_gateway.backend_address_pools = backend_address_pool_arr
           end
 
           if backend_http_settings_list
             backend_http_setting_arr = define_backend_http_settings(backend_http_settings_list)
-            ag_props.backend_http_settings_collection = []
-            ag_props.backend_http_settings_collection = backend_http_setting_arr
+            application_gateway.backend_http_settings_collection = backend_http_setting_arr
           end
 
           if http_listeners
             http_listener_arr = define_http_listeners(http_listeners)
-            ag_props.http_listeners = []
-            ag_props.http_listeners = http_listener_arr
+            application_gateway.http_listeners = http_listener_arr
           end
 
           if url_path_maps
             url_path_maps_arr = define_url_path_maps(url_path_maps)
-            ag_props.url_path_maps = []
-            ag_props.url_path_maps = url_path_maps_arr
+            application_gateway.url_path_maps = url_path_maps_arr
           end
 
           if request_routing_rules
             request_routing_rule_arr = define_request_routing_rules(request_routing_rules)
-            ag_props.request_routing_rules = []
-            ag_props.request_routing_rules = request_routing_rule_arr
+            application_gateway.request_routing_rules = request_routing_rule_arr
           end
 
           gateway_sku = Azure::ARM::Network::Models::ApplicationGatewaySku.new
           gateway_sku.name = sku_name
           gateway_sku.tier = sku_tier
           gateway_sku.capacity = sku_capacity
-          ag_props.sku = gateway_sku
-
-          application_gateway = Azure::ARM::Network::Models::ApplicationGateway.new
-          application_gateway.name = name
-          application_gateway.location = location
-          application_gateway.properties = ag_props
+          application_gateway.sku = gateway_sku
 
           application_gateway
         end
@@ -100,16 +86,14 @@ module Fog
           gateway_ip_configuration_arr = []
           gateway_ip_configurations.each do |ip_configuration|
             configuration = Azure::ARM::Network::Models::ApplicationGatewayIPConfiguration.new
-            configuration_prop = Azure::ARM::Network::Models::ApplicationGatewayIPConfigurationPropertiesFormat.new
-            configuration_prop.provisioning_state = ip_configuration[:provisioning_state]
+            configuration.provisioning_state = ip_configuration[:provisioning_state]
             if ip_configuration[:subnet_id]
               subnet = Azure::ARM::Network::Models::Subnet.new
               subnet.id = ip_configuration[:subnet_id]
-              configuration_prop.subnet = subnet
+              configuration.subnet = subnet
             end
 
             configuration.name = ip_configuration[:name]
-            configuration.properties = configuration_prop
             gateway_ip_configuration_arr.push(configuration)
           end
           gateway_ip_configuration_arr
@@ -119,13 +103,11 @@ module Fog
           ssl_certificate_arr = []
           ssl_certificates.each do |ssl_certificate|
             certificate = Azure::ARM::Network::Models::ApplicationGatewaySslCertificate.new
-            certificate_prop = Azure::ARM::Network::Models::ApplicationGatewaySslCertificatePropertiesFormat.new
-            certificate_prop.data = ssl_certificate[:data]
-            certificate_prop.password = ssl_certificate[:password]
-            certificate_prop.public_cert_data = ssl_certificate[:public_cert_data]
+            certificate.data = ssl_certificate[:data]
+            certificate.password = ssl_certificate[:password]
+            certificate.public_cert_data = ssl_certificate[:public_cert_data]
 
             certificate.name = ssl_certificate[:name]
-            certificate.properties = certificate_prop
             ssl_certificate_arr.push(ssl_certificate)
           end
           ssl_certificate_arr
@@ -135,19 +117,17 @@ module Fog
           frontend_ip_configuration_arr = []
           frontend_ip_configurations.each do |fic|
             frontend_ip_configuration = Azure::ARM::Network::Models::ApplicationGatewayFrontendIPConfiguration.new
-            frontend_ip_configuration_prop = Azure::ARM::Network::Models::ApplicationGatewayFrontendIPConfigurationPropertiesFormat.new
 
-            frontend_ip_configuration_prop.private_ipaddress = fic[:private_ip_address]
-            frontend_ip_configuration_prop.private_ipallocation_method = fic[:private_ip_allocation_method]
+            frontend_ip_configuration.private_ipaddress = fic[:private_ip_address]
+            frontend_ip_configuration.private_ipallocation_method = fic[:private_ip_allocation_method]
 
             unless fic[:public_ip_address_id].nil?
               pip = Azure::ARM::Network::Models::PublicIPAddress.new
               pip.id = fic[:public_ip_address_id]
-              frontend_ip_configuration_prop.public_ipaddress = pip
+              frontend_ip_configuration.public_ipaddress = pip
             end
 
             frontend_ip_configuration.name = fic[:name]
-            frontend_ip_configuration.properties = frontend_ip_configuration_prop
 
             frontend_ip_configuration_arr.push(frontend_ip_configuration)
           end
@@ -158,11 +138,9 @@ module Fog
           frontend_port_arr = []
           frontend_ports.each do |port|
             frontend_port = Azure::ARM::Network::Models::ApplicationGatewayFrontendPort.new
-            frontend_port_prop = Azure::ARM::Network::Models::ApplicationGatewayFrontendPortPropertiesFormat.new
 
-            frontend_port_prop.port = port[:port]
+            frontend_port.port = port[:port]
             frontend_port.name = port[:name]
-            frontend_port.properties = frontend_port_prop
 
             frontend_port_arr.push(frontend_port)
           end
@@ -173,16 +151,14 @@ module Fog
           probe_arr = []
           probes.each do |probe|
             ag_probe = Azure::ARM::Network::Models::ApplicationGatewayProbe.new
-            ag_probe_prop = Azure::ARM::Network::Models::ApplicationGatewayProbePropertiesFormat.new
-            ag_probe_prop.protocol = probe[:protocol]
-            ag_probe_prop.host = probe[:host]
-            ag_probe_prop.path = probe[:path]
-            ag_probe_prop.interval = probe[:interval]
-            ag_probe_prop.timeout = probe[:timeout]
-            ag_probe_prop.unhealthy_threshold = probe[:unhealthy_threshold]
+            ag_probe.protocol = probe[:protocol]
+            ag_probe.host = probe[:host]
+            ag_probe.path = probe[:path]
+            ag_probe.interval = probe[:interval]
+            ag_probe.timeout = probe[:timeout]
+            ag_probe.unhealthy_threshold = probe[:unhealthy_threshold]
 
             ag_probe.name = probe[:name]
-            ag_probe.properties = ag_probe_prop
             probe_arr.push(ag_probe)
           end
           probe_arr
@@ -193,7 +169,6 @@ module Fog
 
           backend_address_pools.each do |bap|
             backend_pool = Azure::ARM::Network::Models::ApplicationGatewayBackendAddressPool.new
-            backend_pool_prop = Azure::ARM::Network::Models::ApplicationGatewayBackendAddressPoolPropertiesFormat.new
 
             backend_addresses1 = bap[:ip_addresses]
 
@@ -203,10 +178,9 @@ module Fog
               backend_add.ip_address = address[:ipAddress]
               addresses.push(backend_add)
             end
-            backend_pool_prop.backend_addresses = addresses
+            backend_pool.backend_addresses = addresses
 
             backend_pool.name = bap[:name]
-            backend_pool.properties = backend_pool_prop
             backend_address_pool_arr.push(backend_pool)
           end
           backend_address_pool_arr
@@ -217,19 +191,17 @@ module Fog
 
           backend_http_settings_list.each do |http_setting|
             backend_http_setting = Azure::ARM::Network::Models::ApplicationGatewayBackendHttpSettings.new
-            backend_http_setting_prop = Azure::ARM::Network::Models::ApplicationGatewayBackendHttpSettingsPropertiesFormat.new
-            backend_http_setting_prop.port = http_setting[:port]
-            backend_http_setting_prop.protocol = http_setting[:protocol]
-            backend_http_setting_prop.cookie_based_affinity = http_setting[:cookie_based_affinity]
-            backend_http_setting_prop.request_timeout = http_setting[:request_timeout]
+            backend_http_setting.port = http_setting[:port]
+            backend_http_setting.protocol = http_setting[:protocol]
+            backend_http_setting.cookie_based_affinity = http_setting[:cookie_based_affinity]
+            backend_http_setting.request_timeout = http_setting[:request_timeout]
             if http_setting[:probe]
               probe = Azure::ARM::Network::Models::Probe.new
               probe.id = http_setting[:probe]
-              backend_http_setting_prop.probe = probe
+              backend_http_setting.probe = probe
             end
 
             backend_http_setting.name = http_setting[:name]
-            backend_http_setting.properties = backend_http_setting_prop
             backend_http_setting_arr.push(backend_http_setting)
           end
           backend_http_setting_arr
@@ -240,29 +212,27 @@ module Fog
 
           http_listeners.each do |listener|
             http_listener = Azure::ARM::Network::Models::ApplicationGatewayHttpListener.new
-            http_listener_prop = Azure::ARM::Network::Models::ApplicationGatewayHttpListenerPropertiesFormat.new
 
-            http_listener_prop.protocol = listener[:protocol]
-            http_listener_prop.host_name = listener[:host_name]
-            http_listener_prop.require_server_name_indication = listener[:require_server_name_indication]
+            http_listener.protocol = listener[:protocol]
+            http_listener.host_name = listener[:host_name]
+            http_listener.require_server_name_indication = listener[:require_server_name_indication]
             if listener[:frontend_ip_config_id]
               frontend_ip = Azure::ARM::Network::Models::FrontendIPConfiguration.new
               frontend_ip.id = listener[:frontend_ip_config_id]
-              http_listener_prop.frontend_ipconfiguration = frontend_ip
+              http_listener.frontend_ipconfiguration = frontend_ip
             end
             if listener[:frontend_port_id]
               frontend_port = Azure::ARM::Network::Models::ApplicationGatewayFrontendPort.new
               frontend_port.id = listener[:frontend_port_id]
-              http_listener_prop.frontend_port = frontend_port
+              http_listener.frontend_port = frontend_port
             end
             if listener[:ssl_certificate_id]
               ssl_cert = Azure::ARM::Network::Models::ApplicationGatewaySslCertificate.new
               ssl_cert.id = listener[:ssl_certificate_id]
-              http_listener_prop.ssl_certificate = ssl_cert
+              http_listener.ssl_certificate = ssl_cert
             end
 
             http_listener.name = listener[:name]
-            http_listener.properties = http_listener_prop
             http_listener_arr.push(http_listener)
           end
           http_listener_arr
@@ -273,27 +243,25 @@ module Fog
 
           url_path_maps.each do |map|
             url_path_map = Azure::ARM::Network::Models::ApplicationGatewayUrlPathMap.new
-            url_path_map_prop = Azure::ARM::Network::Models::ApplicationGatewayUrlPathMapPropertiesFormat.new
 
             if map[:default_backend_address_pool_id]
               default_backend_address_pool = Azure::ARM::Network::Models::BackendAddressPool.new
               default_backend_address_pool.id = map[:default_backend_address_pool_id]
-              url_path_map_prop.default_backend_address_pool = default_backend_address_pool
+              url_path_map.default_backend_address_pool = default_backend_address_pool
             end
             if map[:default_backend_http_settings_id]
               default_backend_http_setting = Azure::ARM::Network::Models::ApplicationGatewayBackendHttpSettings.new
               default_backend_http_setting.id = map[:default_backend_http_settings_id]
-              url_path_map_prop.default_backend_http_settings = default_backend_http_setting
+              url_path_map.default_backend_http_settings = default_backend_http_setting
             end
 
             if map[:path_rules]
               path_rules = map[:path_rules]
               path_rule_arr = define_path_rules(path_rules)
-              url_path_map_prop.path_rules = path_rule_arr
+              url_path_map.path_rules = path_rule_arr
             end
 
             url_path_map.name = map[:name]
-            url_path_map.properties = url_path_map_prop
             url_path_map_arr.push(url_path_map)
           end
           url_path_map_arr
@@ -303,16 +271,15 @@ module Fog
           path_rule_arr = []
           path_rules.each do |rule|
             path_rule = Azure::ARM::Network::Models::ApplicationGatewayPathRule.new
-            path_rule_prop = Azure::ARM::Network::Models::ApplicationGatewayPathRulePropertiesFormat.new
             if rule[:backend_address_pool_id]
               backend_address_pool = Azure::ARM::Network::Models::BackendAddressPool.new
               backend_address_pool.id = rule[:backend_address_pool_id]
-              path_rule_prop.backend_address_pool = backend_address_pool
+              path_rule.backend_address_pool = backend_address_pool
             end
             if rule[:backend_http_settings_id]
               backend_http_setting = Azure::ARM::Network::Models::ApplicationGatewayBackendHttpSettings.new
               backend_http_setting.id = rule[:backend_http_settings_id]
-              path_rule_prop.backend_http_settings = backend_http_setting
+              path_rule.backend_http_settings = backend_http_setting
             end
             path_urls = rule[:paths]
 
@@ -320,10 +287,9 @@ module Fog
             path_urls.each do |url|
               paths.push(url)
             end
-            path_rule_prop.paths = paths
+            path_rule.paths = paths
 
             path_rule.name = rule[:name]
-            path_rule.properties = path_rule_prop
             path_rule_arr.push(path_rule)
           end
           path_rule_arr
@@ -334,27 +300,25 @@ module Fog
 
           request_routing_rules.each do |rule|
             request_routing_rule = Azure::ARM::Network::Models::ApplicationGatewayRequestRoutingRule.new
-            request_routing_rule_prop = Azure::ARM::Network::Models::ApplicationGatewayRequestRoutingRulePropertiesFormat.new
 
-            request_routing_rule_prop.rule_type = rule[:type]
+            request_routing_rule.rule_type = rule[:type]
             if rule[:http_listener_id]
               http_listener = Azure::ARM::Network::Models::ApplicationGatewayHttpListener.new
               http_listener.id = rule[:http_listener_id]
-              request_routing_rule_prop.http_listener = http_listener
+              request_routing_rule.http_listener = http_listener
             end
             if rule[:backend_address_pool_id]
               backend_address_pool = Azure::ARM::Network::Models::BackendAddressPool.new
               backend_address_pool.id = rule[:backend_address_pool_id]
-              request_routing_rule_prop.backend_address_pool = backend_address_pool
+              request_routing_rule.backend_address_pool = backend_address_pool
             end
             if rule[:backend_http_settings_id]
               backend_http_setting = Azure::ARM::Network::Models::ApplicationGatewayBackendHttpSettings.new
               backend_http_setting.id = rule[:backend_http_settings_id]
-              request_routing_rule_prop.backend_http_settings = backend_http_setting
+              request_routing_rule.backend_http_settings = backend_http_setting
             end
 
             request_routing_rule.name = rule[:name]
-            request_routing_rule.properties = request_routing_rule_prop
             request_routing_rule_arr.push(request_routing_rule)
           end
           request_routing_rule_arr