fog-azure-rm 0.0.5 → 0.0.6

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

@@ -0,0 +1,93 @@
+module Fog
+  module Network
+    class AzureRM
+      # VirtualNetworkGatewayConnection model class for Network Service
+      class VirtualNetworkGatewayConnection < Fog::Model
+        identity :name
+        attribute :id
+        attribute :location
+        attribute :resource_group
+        attribute :tags
+        attribute :virtual_network_gateway1
+        attribute :virtual_network_gateway2
+        attribute :local_network_gateway2
+        attribute :connection_type
+        attribute :connection_status
+        attribute :authorization_key
+        attribute :routing_weight
+        attribute :shared_key
+        attribute :egress_bytes_transferred
+        attribute :ingress_bytes_transferred
+        attribute :peer
+        attribute :enable_bgp
+        attribute :resource_guid
+        attribute :provisioning_state
+
+        def self.parse(gateway_connection)
+          connection = {}
+          connection['id'] = gateway_connection.id
+          connection['name'] = gateway_connection.name
+          connection['location'] = gateway_connection.location
+          connection['resource_group'] = get_resource_group_from_id(gateway_connection.id)
+          connection['tags'] = gateway_connection.tags
+
+          unless gateway_connection.virtual_network_gateway1.nil?
+            gateway1 = VirtualNetworkGateway.new
+            connection['virtual_network_gateway1'] = gateway1.merge_attributes(VirtualNetworkGateway.parse(gateway_connection.virtual_network_gateway1))
+          end
+
+          unless gateway_connection.virtual_network_gateway2.nil?
+            gateway2 = VirtualNetworkGateway.new
+            connection['virtual_network_gateway2'] = gateway2.merge_attributes(VirtualNetworkGateway.parse(gateway_connection.virtual_network_gateway2))
+          end
+
+          connection['connection_type'] = gateway_connection.connection_type
+          connection['connection_status'] = gateway_connection.connection_status
+          connection['authorization_key'] = gateway_connection.authorization_key
+          connection['routing_weight'] = gateway_connection.routing_weight
+          connection['shared_key'] = gateway_connection.shared_key
+          connection['egress_bytes_transferred'] = gateway_connection.egress_bytes_transferred
+          connection['ingress_bytes_transferred'] = gateway_connection.ingress_bytes_transferred
+          connection['peer'] = gateway_connection.peer
+          connection['enable_bgp'] = gateway_connection.enable_bgp
+          connection['provisioning_state'] = gateway_connection.provisioning_state
+
+          connection
+        end
+
+        def save
+          requires :name, :location, :resource_group, :connection_type
+          gateway_connection_params = gateway_connection_parameters
+          gateway_connection = service.create_or_update_virtual_network_gateway_connection(gateway_connection_params)
+          merge_attributes(VirtualNetworkGatewayConnection.parse(gateway_connection))
+        end
+
+        def destroy
+          service.delete_virtual_network_gateway_connection(resource_group, name)
+        end
+
+        private
+
+        def gateway_connection_parameters
+          {
+            resource_group_name: resource_group,
+            name: name,
+            location: location,
+            tags: tags,
+            virtual_network_gateway1: virtual_network_gateway1,
+            virtual_network_gateway2: virtual_network_gateway2,
+            local_network_gateway2: local_network_gateway2,
+            enable_bgp: enable_bgp,
+            connection_type: connection_type,
+            authorization_key: authorization_key,
+            routing_weight: routing_weight,
+            shared_key: shared_key,
+            egress_bytes_transferred: egress_bytes_transferred,
+            ingress_bytes_transferred: ingress_bytes_transferred,
+            peer: peer
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/network/virtual_network_gateway_connection'
+
+module Fog
+  module Network
+    class AzureRM
+      # VirtualNetworkGatewayConnections collection class for Network Service
+      class VirtualNetworkGatewayConnections < Fog::Collection
+        model VirtualNetworkGatewayConnection
+        attribute :resource_group
+
+        def all
+          requires :resource_group
+          gateway_connections = []
+          service.list_virtual_network_gateway_connections(resource_group).each do |connection|
+            gateway_connections << VirtualNetworkGatewayConnection.parse(connection)
+          end
+          load(gateway_connections)
+        end
+
+        def get(resource_group_name, name)
+          connection = service.get_virtual_network_gateway_connection(resource_group_name, name)
+          gateway_connection = VirtualNetworkGatewayConnection.new(service: service)
+          gateway_connection.merge_attributes(VirtualNetworkGatewayConnection.parse(connection))
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
 require 'fog/core/collection'
-require 'fog/azurerm/models/network/network_interface'
+require 'fog/azurerm/models/network/virtual_network_gateway'
 
 module Fog
   module Network

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

@@ -18,8 +18,10 @@ module Fog
           load(deployments)
         end
 
-        def get(identity)
-          all.find { |deployment| deployment.name == identity }
+        def get(resource_group_name, deployment_name)
+          deployment = service.get_deployment(resource_group_name, deployment_name)
+          deployment_object = Fog::Resources::AzureRM::Deployment.new(service: service)
+          deployment_object.merge_attributes(Fog::Resources::AzureRM::Deployment.parse(deployment))
         end
       end
     end

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

@@ -17,8 +17,10 @@ module Fog
           load(resource_groups)
         end
 
-        def get(identity)
-          all.find { |f| f.name == identity }
+        def get(resource_group_name)
+          resource_group = service.get_resource_group(resource_group_name)
+          resource_group_object = Fog::Resources::AzureRM::ResourceGroup.new(service: service)
+          resource_group_object.merge_attributes(Fog::Resources::AzureRM::ResourceGroup.parse(resource_group))
         end
       end
     end

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

@@ -23,8 +23,10 @@ module Fog
           load(accounts)
         end
 
-        def get(identity)
-          all.find { |f| f.name == identity }
+        def get(resource_group_name, storage_account_name)
+          storage_account = service.get_storage_account(resource_group_name, storage_account_name)
+          storage_account_object = Fog::Storage::AzureRM::StorageAccount.new(service: service)
+          storage_account_object.merge_attributes(Fog::Storage::AzureRM::StorageAccount.parse(storage_account))
         end
 
         def check_name_availability(name)

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

@@ -41,20 +41,31 @@ module Fog
           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
+          create_or_update
         end
 
         def destroy
           service.delete_traffic_manager_endpoint(resource_group, name, traffic_manager_profile_name, type)
         end
 
+        def update(endpoint_params)
+          validate_input(endpoint_params)
+          merge_attributes(endpoint_params)
+
+          create_or_update
+        end
+
         private
 
+        def create_or_update
+          if %w(azureEndpoints externalEndpoints nestedEndpoints).select { |type| type if type.eql?(type) }.any?
+            traffic_manager_endpoint = service.create_or_update_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 traffic_manager_endpoint_hash
           {
             resource_group: resource_group,
@@ -69,6 +80,12 @@ module Fog
             min_child_endpoints: min_child_endpoints
           }
         end
+
+        def validate_input(attr_hash)
+          invalid_attr = [:resource_group, :name, :traffic_manager_profile_name, :id]
+          result = invalid_attr & attr_hash.keys
+          raise 'Cannot modify the given attribute' unless result.empty?
+        end
       end
     end
   end

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

@@ -44,15 +44,41 @@ module Fog
         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)
+          traffic_manager_profile = service.create_or_update_traffic_manager_profile(traffic_manager_profile_hash)
           merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(traffic_manager_profile))
         end
 
         def destroy
           service.delete_traffic_manager_profile(resource_group, name)
         end
+
+        def update(profile_params)
+          validate_input(profile_params)
+          merge_attributes(profile_params)
+          profile = service.create_or_update_traffic_manager_profile(traffic_manager_profile_hash)
+          merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(profile))
+        end
+
+        private
+
+        def validate_input(attr_hash)
+          invalid_attr = [:resource_group, :name, :relative_name, :id]
+          result = invalid_attr & attr_hash.keys
+          raise 'Cannot modify the given attribute' unless result.empty?
+        end
+
+        def traffic_manager_profile_hash
+          {
+            resource_group: resource_group,
+            name: name,
+            traffic_routing_method: traffic_routing_method,
+            relative_name: relative_name,
+            ttl: ttl,
+            protocol: protocol,
+            port: port,
+            path: path
+          }
+        end
       end
     end
   end

data/lib/fog/azurerm/network.rb

@@ -1,5 +1,3 @@
-require 'fog/azurerm/core'
-
 module Fog
   module Network
     # Fog Service Class for AzureRM
@@ -21,7 +19,7 @@ module Fog
       request :delete_virtual_network
       request :list_virtual_networks
       request :check_for_virtual_network
-      request :create_public_ip
+      request :create_or_update_public_ip
       request :delete_public_ip
       request :get_public_ip
       request :list_public_ips
@@ -43,6 +41,7 @@ module Fog
       request :create_load_balancer
       request :delete_load_balancer
       request :list_load_balancers
+      request :get_load_balancer
       request :create_or_update_network_security_group
       request :delete_network_security_group
       request :list_network_security_groups
@@ -61,7 +60,22 @@ module Fog
       request :delete_express_route_circuit_peering
       request :get_express_route_circuit_peering
       request :list_express_route_circuit_peerings
+      request :create_or_update_express_route_circuit_authorization
+      request :delete_express_route_circuit_authorization
+      request :get_express_route_circuit_authorization
+      request :list_express_route_circuit_authorizations
       request :list_express_route_service_providers
+      request :create_or_update_local_network_gateway
+      request :delete_local_network_gateway
+      request :get_local_network_gateway
+      request :list_local_network_gateways
+      request :create_or_update_virtual_network_gateway_connection
+      request :delete_virtual_network_gateway_connection
+      request :get_virtual_network_gateway_connection
+      request :list_virtual_network_gateway_connections
+      request :get_connection_shared_key
+      request :reset_connection_shared_key
+      request :set_connection_shared_key
 
       model_path 'fog/azurerm/models/network'
       model :virtual_network
@@ -92,8 +106,14 @@ module Fog
       collection :express_route_circuits
       model :express_route_circuit_peering
       collection :express_route_circuit_peerings
+      model :express_route_circuit_authorization
+      collection :express_route_circuit_authorizations
       model :express_route_service_provider
       collection :express_route_service_providers
+      model :local_network_gateway
+      collection :local_network_gateways
+      model :virtual_network_gateway_connection
+      collection :virtual_network_gateway_connections
 
       # Mock class for Network Service
       class Mock

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

@@ -3,80 +3,41 @@ module Fog
     class AzureRM
       # 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)
-          msg = "Creating Application Gateway: #{name} in Resource Group: #{resource_group}."
+        def create_or_update_application_gateway(gateway_params)
+          msg = "Creating/Updated Application Gateway: #{gateway_params[:name]} in Resource Group: #{gateway_params[: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)
+          gateway = define_application_gateway(gateway_params)
           begin
-            gateway_obj = @network_client.application_gateways.create_or_update(resource_group, name, gateway)
+            gateway_obj = @network_client.application_gateways.create_or_update(gateway_params[:resource_group], gateway_params[:name], gateway)
           rescue MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Application Gateway #{name} created successfully."
+          Fog::Logger.debug "Application Gateway #{gateway_params[:name]} created/updated 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)
+        def define_application_gateway(gateway_params)
           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)
-            application_gateway.gateway_ipconfigurations = gateway_ip_configuration_arr
-          end
-
-          if ssl_certificates
-            ssl_certificate_arr = define_ssl_certificate(ssl_certificates)
-            application_gateway.ssl_certificates = ssl_certificate_arr
-          end
-
-          if frontend_ip_configurations
-            frontend_ip_configuration_arr = define_frontend_ip_configurations(frontend_ip_configurations)
-            application_gateway.frontend_ipconfigurations = frontend_ip_configuration_arr
-          end
-
-          if frontend_ports
-            frontend_port_arr = define_frontend_ports(frontend_ports)
-            application_gateway.frontend_ports = frontend_port_arr
-          end
-
-          if probes
-            probe_arr = define_probes(probes)
-            application_gateway.probes = probe_arr
-          end
-
-          if backend_address_pools
-            backend_address_pool_arr = define_backend_address_pools(backend_address_pools)
-            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)
-            application_gateway.backend_http_settings_collection = backend_http_setting_arr
-          end
-
-          if http_listeners
-            http_listener_arr = define_http_listeners(http_listeners)
-            application_gateway.http_listeners = http_listener_arr
-          end
-
-          if url_path_maps
-            url_path_maps_arr = define_url_path_maps(url_path_maps)
-            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)
-            application_gateway.request_routing_rules = request_routing_rule_arr
-          end
+          application_gateway.name = gateway_params[:name]
+          application_gateway.location = gateway_params[:location]
+
+          application_gateway.gateway_ipconfigurations = define_gateway_ip_configuration(gateway_params[:gateway_ip_configurations]) if gateway_params[:gateway_ip_configurations]
+          application_gateway.ssl_certificates = define_ssl_certificate(gateway_params[:ssl_certificates]) if gateway_params[:ssl_certificates]
+          application_gateway.frontend_ipconfigurations = define_frontend_ip_configurations(gateway_params[:frontend_ip_configurations]) if gateway_params[:frontend_ip_configurations]
+          application_gateway.frontend_ports = define_frontend_ports(gateway_params[:frontend_ports]) if gateway_params[:frontend_ports]
+          application_gateway.probes = define_probes(gateway_params[:probes]) if gateway_params[:probes]
+          application_gateway.backend_address_pools = define_backend_address_pools(gateway_params[:backend_address_pools]) if gateway_params[:backend_address_pools]
+          application_gateway.backend_http_settings_collection = define_backend_http_settings(gateway_params[:backend_http_settings_list]) if gateway_params[:backend_http_settings_list]
+          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]
 
           gateway_sku = Azure::ARM::Network::Models::ApplicationGatewaySku.new
-          gateway_sku.name = sku_name
-          gateway_sku.tier = sku_tier
-          gateway_sku.capacity = sku_capacity
+          gateway_sku.name = gateway_params[:sku_name]
+          gateway_sku.tier = gateway_params[:sku_tier]
+          gateway_sku.capacity = gateway_params[:sku_capacity]
           application_gateway.sku = gateway_sku
 
           application_gateway
@@ -171,7 +132,6 @@ module Fog
             backend_pool = Azure::ARM::Network::Models::ApplicationGatewayBackendAddressPool.new
 
             backend_addresses1 = bap[:ip_addresses]
-
             addresses = []
             backend_addresses1.each do |address|
               backend_add = Azure::ARM::Network::Models::ApplicationGatewayBackendAddress.new
@@ -327,7 +287,7 @@ module Fog
 
       # Mock class for Network Request
       class Mock
-        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)
+        def create_or_update_application_gateway(*)
         end
       end
     end

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

@@ -0,0 +1,159 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Real class for Application Gateway Request
+      class Real
+        def get_application_gateway(resource_group_name, application_gateway_name)
+          msg = "Getting Application Gateway: #{application_gateway_name} in Resource group: #{resource_group_name}"
+          Fog::Logger.debug msg
+          begin
+            application_gateway = @network_client.application_gateways.get(resource_group_name, application_gateway_name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Getting application gateway #{application_gateway_name} successfully in Resource Group: #{resource_group_name}"
+          application_gateway
+        end
+      end
+
+      # Mock class for Application Gateway Request
+      class Mock
+        def get_application_gateway(*)
+          response = '{
+            "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway",
+            "name": "gateway",
+            "type": "Microsoft.Network/applicationGateways",
+            "location": "eastus",
+            "properties": {
+              "sku": {
+                "name": "Standard_Medium",
+                "tier": "Standard",
+                "capacity": 2
+              },
+              "gatewayIPConfigurations": [
+                {
+                  "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/gatewayIPConfigurations/ag-GatewayIP",
+                  "properties": {
+                    "subnet": {
+                      "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/vnet/subnets/GatewaySubnet"
+                    },
+                    "provisioningState": "Succeeded"
+                  },
+                  "name": "ag-GatewayIP"
+                }
+              ],
+              "sslCertificates": [
+                {
+                  "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/sslCertificates/ssl_certificate",
+                  "properties": {
+                    "publicCertData": "MIIDiDCCAnACCQCwYkR0Mxy+QTANBgkqhkiG9w0BAQUFADCBhTELMAkGA1UEBhMCUEsxDzANBgNVBAgTBlB1bmphYjEPMA0GA1UEBxMGTGFob3JlMQ8wDQYDVQQKEwZDb25maXoxDDAKBgNVBAsTA0RldjEPMA0GA1UEAxMGaGFpZGVyMSQwIgYJKoZIhvcNAQkBFhVoYWlkZXIuYWxpQGNvbmZpei5jb20wHhcNMTYwMzAyMTE0NTM2WhcNMTcwMzAyMTE0NTM2WjCBhTELMAkGA1UEBhMCUEsxDzANBgNVBAgTBlB1bmphYjEPMA0GA1UEBxMGTGFob3JlMQ8wDQYDVQQKEwZDb25maXoxDDAKBgNVBAsTA0RldjEPMA0GA1UEAxMGaGFpZGVyMSQwIgYJKoZIhvcNAQkBFhVoYWlkZXIuYWxpQGNvbmZpei5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCuJrPbvOG+4oXQRamkOALlpdK98m+atJue9zOcCCagY8IJI4quYL13d8VItmrZf7erA+siqpYlWEuk1+lmmUY7T4AWAL8mXeR2vc7hWF601WDUjeVPK19+IcC8emMLOlBpvjXC9nbvADLQuR0PGitfjCqFoG66EOqJmLDNBsyHWmy+qhb8J4WXitruNAJDPe/20h6L23vD6z4tvwBjh4zkrfskGlKCNcAuvG1NI0FAS8261Jvs3lf+8oFyI+oSXGtknrkeQv3PbXyeEe3KO5a/M61Uebo04Uwd4yCvdu6H0sF+YYA4bfFdanuFmrZvf9cZSwknQid+vOdzyGkTHTPFAgMBAAEwDQYJKoZIhvcNAQEFBQADggEBAKtPhYpfvn5OxP+BcChsWaQA4KZQj0THGdiAjHsvfjsgteFvhkzqZBkhKYtsAWV5tB5/GDl+o4c6PQJ2/TXhOJn3pSNaUzrCJIGtKS5DknbqTQxCwVlxyBtPHLAYWqKcPMlH282rw3VY0OYTL96XOgZ/WZjcN6A7ku+uWsNCql443FoWL+N3Gpaab45OyIluFUOH+yc0ToHNlP3iOpI3rVpi2xwmGrSyUKsGUma3nrBq7TWjkDE1E+oJoybaMNZzgXGIPSJC1HYIF1U8GSoFkZpAFxXecD0FinXWDRwUP6K54iti3i6a/Ox73WhwfI4mVCqsOy1WYWtKYhMVe6Kj4Nw=",
+                    "provisioningState": "Succeeded"
+                  },
+                  "name": "ssl_certificate"
+                }
+              ],
+              "frontendIPConfigurations": [
+                {
+                  "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/frontendIPConfigurations/frontend_ip_config",
+                  "properties": {
+                    "privateIPAllocationMethod": "Dynamic",
+                    "publicIPAddress": {
+                      "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses/ag_publicip-672835"
+                    },
+                    "provisioningState": "Succeeded"
+                  },
+                  "name": "frontend_ip_config"
+                }
+              ],
+              "frontendPorts": [
+                {
+                  "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/frontendPorts/gateway_front_port",
+                  "properties": {
+                    "port": 443,
+                    "provisioningState": "Succeeded"
+                  },
+                  "name": "gateway_front_port"
+                }
+              ],
+              "probes": [],
+              "backendAddressPools": [
+                {
+                  "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/backendAddressPools/AG-BackEndAddressPool",
+                  "properties": {
+                    "backendAddresses": [
+                      {
+                        "ipAddress": "10.0.0.4"
+                      },
+                      {
+                        "ipAddress": "10.0.0.5"
+                      }
+                    ],
+                    "provisioningState": "Succeeded"
+                  },
+                  "name": "AG-BackEndAddressPool"
+                }
+              ],
+              "backendHttpSettingsCollection": [
+                {
+                  "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/backendHttpSettingsCollection/gateway_settings",
+                  "properties": {
+                    "port": 80,
+                    "protocol": "Http",
+                    "cookieBasedAffinity": "Enabled",
+                    "requestTimeout": 30,
+                    "provisioningState": "Succeeded"
+                  },
+                  "name": "gateway_settings"
+                }
+              ],
+              "httpListeners": [
+                {
+                  "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/httpListeners/gateway_listener",
+                  "properties": {
+                    "frontendIPConfiguration": {
+                      "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/frontendIPConfigurations/frontend_ip_config"
+                    },
+                    "frontendPort": {
+                      "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/frontendPorts/gateway_front_port"
+                    },
+                    "protocol": "Https",
+                    "sslCertificate": {
+                      "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/sslCertificates/ssl_certificate"
+                    },
+                    "requireServerNameIndication": false,
+                    "provisioningState": "Succeeded"
+                  },
+                  "name": "gateway_listener"
+                }
+              ],
+              "urlPathMaps": [],
+              "requestRoutingRules": [
+                {
+                  "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/requestRoutingRules/gateway_request_route_rule",
+                  "properties": {
+                    "ruleType": "Basic",
+                    "backendAddressPool": {
+                      "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/backendAddressPools/AG-BackEndAddressPool"
+                    },
+                    "backendHttpSettings": {
+                      "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/backendHttpSettingsCollection/gateway_settings"
+                    },
+                    "httpListener": {
+                      "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/gateway/httpListeners/gateway_listener"
+                    },
+                    "provisioningState": "Succeeded"
+                  },
+                  "name": "gateway_request_route_rule"
+                }
+              ],
+              "resourceGuid": "b3db5ebf-10f8-4666-9596-d1459530f64b",
+              "provisioningState": "Succeeded"
+            }
+          }'
+          gateway_mapper = Azure::ARM::Network::Models::ApplicationGateway.mapper
+          @network_client.deserialize(gateway_mapper, JSON.load(response), 'result.body')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Real class for Application Gateway Request
+      class Real
+        def update_sku_attributes(gateway_params, sku_name, sku_capacity)
+          msg = "Updating sku attributes for #{sku_name}"
+          Fog::Logger.debug msg
+          gateway_params[:sku_name] = sku_name if sku_name
+          gateway_params[:sku_capacity] = sku_capacity if sku_capacity
+          begin
+            gateway = create_or_update_application_gateway(gateway_params)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Sku #{sku_name} updated Successfully"
+          gateway
+        end
+      end
+
+      # Mock class for Application Gateway Request
+      class Mock
+        def update_sku_attributes(*)
+        end
+      end
+    end
+  end
+end