far-gem 0.5.1

data/lib/fog/azurerm/docs/structure.md

@@ -0,0 +1,53 @@
+# Fog
+Whether you need compute, dns, storage, or a multitude of other services, fog provides an accessible entry point and facilitates cross service compatibility. Fog delivers the knowledge of cloud experts to you, helping you to bootstrap your cloud usage and guiding you as your own expertise develops.
+ 
+By coding with fog from the start you avoid vendor lock-in and give yourself more flexibility to provide value. Whether you are writing a library, designing a software as a service product or just hacking on the weekend this flexibility is a huge boon.
+
+# Structure
+fog is the Ruby cloud computing library, top to bottom:
+
+- Collections provide a simplified interface, making clouds easier to work with and switch between.
+- Requests allow power users to get the most out of the features of each individual cloud.
+- Mocks make testing and integrating a breeze.
+
+#### Collections
+Some collections are available across multiple providers:
+- dns providers have `zones` and `records`
+- compute providers have `images` and `servers`
+
+Collections share basic CRUD type operations, such as: 
+- **all** - fetch every object of that type from the provider.
+- **get** - fetch a single object by it’s identity from the provider.
+
+#### Models
+Many of the collection methods return individual objects, which also provide common methods:
+- **destroy** - will destroy the persisted object from the provider.
+- **save** - persist the object to the provider.
+
+#### Requests
+Requests allow you to dive deeper when the models just can’t cut it. You can see a list of available requests by calling `requests` on the connection object.
+
+#### Mocks
+As you might imagine, testing code using fog can be slow and expensive, constantly turning on and shutting down instances. Mocking allows skipping this overhead by providing an in-memory representation resources as you make requests.
+
+# Fog Provider Directory Structure
+```sh
+Plugin Root
+      |--- lib
+            |--- fog
+                 |--- azurerm.rb #registers provider
+                 |--- azurerm
+                       |--- compute.rb #registers all models, collections and requests
+                       |--- dns.rb #registers all models, collections and requests
+                       |--- storage.rb #registers all models, collections and requests
+                       |--- models #models and collections
+                       	     |--- compute #models and collections for compute
+                             |--- dns
+                             |--- storage
+                       |--- requests #requests - includes Real and Mock Classes
+                       	     |--- compute #requests for compute
+                             |--- dns
+                             |--- storage
+```
+
+For more information about fog structure [Click Here](http://fog.io/about/structure.html)

data/lib/fog/azurerm/docs/traffic_manager.md

@@ -0,0 +1,161 @@
+# Traffic Manager
+
+This document explains how to get started using Azure Traffic Manager Service with Fog. With this gem you can create, update, list or delete Traffic Manager Profiles and End Points.
+
+## Usage
+
+First of all, you need to require the Fog library by executing:
+
+```ruby
+require 'fog/azurerm'
+```
+## Create Connection
+
+Next, create a connection to the Traffic Manager Service:
+
+```ruby
+fog_traffic_manager_service = Fog::TrafficManager::AzureRM.new(
+      tenant_id:        '<Tenant Id>',                                                          # Tenant Id of Azure Active Directory Application
+      client_id:        '<Client Id>',                                                          # Client Id of Azure Active Directory Application
+      client_secret:    '<Client Secret>',                                                      # Client Secret of Azure Active Directory Application
+      subscription_id:  '<Subscription Id>',                                                    # Subscription Id of an Azure Account
+      environment:      '<AzureCloud/AzureChinaCloud/AzureUSGovernment/AzureGermanCloud>'       # Azure cloud environment. Default is AzureCloud.
+)
+```
+
+## Check Traffic Manager Profile Existence
+
+```ruby
+fog_traffic_manager_service.traffic_manager_profiles.check_traffic_manager_profile_exists('<Resource Group Name>', '<Profile Name>')
+```
+
+## Create Traffic Manager Profile
+
+Create a new Traffic Manager Profile. The parameter 'traffic_routing_method' can be 'Performance', 'Weighted' or 'Priority'.
+
+```ruby
+profile = fog_traffic_manager_service.traffic_manager_profiles.create(
+        name: '<Profile Name>',
+        resource_group: '<Resource Group Name>',
+        traffic_routing_method: '<Routing Method Name>',
+        relative_name: '<Profile Relative Name>',
+        ttl: '<TTL>',
+        protocol: '<Protocol Name>',
+        port: '<Port Number>',
+        path: '<Path>',
+        tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' }                          # [Optional]
+)
+```
+
+## List Traffic Manager Profiles
+
+List Traffic Manager Profiles in a resource group
+
+```ruby
+profiles  = fog_traffic_manager_service.traffic_manager_profiles(resource_group: '<Resource Group Name>')
+profiles.each do |profile|
+    puts "#{profile.name}"
+end
+```
+
+## Retrieve a single Traffic Manager Profile
+
+Get a single record of Traffic Manager Profile
+
+```ruby
+profile = fog_traffic_manager_service
+             .traffic_manager_profiles
+             .get('<Resource Group Name>', '<Profile Name>')
+puts "#{profile.name}"
+```
+
+## Update a Traffic Manager Profile
+
+Get a Traffic Manager Profile object from the get method and then update that Traffic Manager Profile. You can update the Traffic Manager Profile by passing the modifiable attributes in the form of a hash.
+
+```ruby
+profile.update(
+              traffic_routing_method: '<Routing Method Name>',
+              ttl: '<TTL>',
+              protocol: '<Protocol Name>',
+              port: '<Port Number>',
+              path: '<Path>'
+)
+```
+
+## Destroy a single Traffic Manager Profile
+
+Get a Traffic Manager Profile object from the get method and then destroy that Traffic Manager Profile.
+
+```ruby
+profile.destroy
+```
+
+## Check Traffic Manager Endpoint Existence
+
+```ruby
+azure_network_service.traffic_manager_end_points.check_traffic_manager_endpoint_exists(
+        '<Resource Group Name>',
+        '<Profile Name>',
+        '<Endpoint Name>',
+        '<Type(<Endpoint Type>)>'
+)
+```
+
+## Create Traffic Manager Endpoint
+
+Traffic Manager Profile is pre-requisite of Traffic Manager Endpoint. Create a new Traffic Manager Endpoint. The parameter 'type' can be 'externalEndpoints, 'azureEndpoints' or 'nestedEndpoints'.
+
+```ruby
+endpoint = azure_network_service.traffic_manager_end_points.create(
+        name: '<Endpoint Name>',
+        traffic_manager_profile_name: '<Profile Name>',
+        resource_group: '<Resource Group Name>',
+        type: '<Endpoint Type>',
+        target: '<Target URL>',
+        endpoint_location: '<Location>'
+)
+```
+
+## List Traffic Manager Endpoints
+
+List Traffic Manager Endpoints in a resource group.
+
+```ruby
+endpoints  = fog_traffic_manager_service.traffic_manager_end_points(resource_group: '<Resource Group Name>', traffic_manager_profile_name: '<Profile Name>')
+endpoints.each do |endpoint|
+   puts "#{endpoint.name}"
+end
+```
+
+## Retrieve a single Traffic Manager Endpoint
+
+Get a single Traffic Manager Endpoint.
+
+```ruby
+endpoint = fog_traffic_manager_service
+                 .traffic_manager_end_points
+                 .get('<Resource Group Name>', '<Profile Name>', '<Endpoint name>', '<Endpoint Type>')
+puts "#{endpoint.name}"
+```
+## Update a Traffic Manager Endpoint
+
+Get a Traffic Manager Endpoint object from the get method and then update that Traffic Manager Endpoint. You can update the Traffic Manager Endpoint by passing the modifiable attributes in the form of a hash.
+
+```ruby
+endpoint.update(type: '<Endpoint Type>',
+                target: '<Target URL>',
+                endpoint_location: '<Location>'
+)
+```
+
+## Destroy a single Traffic Manager Endpoint
+
+Get a Traffic Manager Endpoint object from the get method and then destroy that Traffic Manager Endpoint.
+
+```ruby
+endpoint.destroy
+```
+
+## Support and Feedback
+Your feedback is highly appreciated! If you have specific issues with the fog ARM, you should file an issue via Github.

data/lib/fog/azurerm/key_vault.rb

@@ -0,0 +1,51 @@
+module Fog
+  module KeyVault
+    # This class registers models, requests and collections
+    class AzureRM < Fog::Service
+      requires :tenant_id
+      requires :client_id
+      requires :client_secret
+      requires :subscription_id
+
+      request_path 'fog/azurerm/requests/key_vault'
+      request :get_vault
+      request :list_vaults
+      request :create_or_update_vault
+      request :delete_vault
+      request :check_vault_exists
+
+      model_path 'fog/azurerm/models/key_vault'
+      model :vault
+      model :access_policy_entry
+      collection :vaults
+
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def initialize(_options = {})
+          begin
+            require 'azure_mgmt_key_vault'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+        end
+      end
+
+      # This class provides the actual implementation for service calls.
+      class Real
+        def initialize(options)
+          begin
+            require 'azure_mgmt_key_vault'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+
+          credentials = Fog::Credentials::AzureRM.get_credentials(options[:tenant_id], options[:client_id], options[:client_secret])
+          @key_vault_client = ::Azure::ARM::KeyVault::KeyVaultManagementClient.new(credentials)
+          @key_vault_client.subscription_id = options[:subscription_id]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Backend Address Pool model class for Application Gateway Service
+      class BackendAddressPool < Fog::Model
+        identity :name
+        attribute :id
+        attribute :ip_addresses
+
+        def self.parse(backend_address_pool)
+          hash = {}
+          backend_addresses = backend_address_pool.backend_addresses
+          hash['id'] = backend_address_pool.id
+          hash['name'] = backend_address_pool.name
+          hash['ip_addresses'] = []
+          backend_addresses.each do |ip_address|
+            hash['ip_addresses'] << ip_address
+          end unless backend_addresses.nil?
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Backend Http Settings model class for Application Gateway Service
+      class BackendHttpSetting < Fog::Model
+        identity :name
+        attribute :id
+        attribute :port
+        attribute :protocol
+        attribute :cookie_based_affinity
+        attribute :request_timeout
+        attribute :probe
+
+        def self.parse(backend_http_setting)
+          hash = {}
+          hash['id'] = backend_http_setting.id
+          hash['name'] = backend_http_setting.name
+          hash['port'] = backend_http_setting.port
+          hash['protocol'] = backend_http_setting.protocol
+          hash['cookie_based_affinity'] = backend_http_setting.cookie_based_affinity
+          hash['request_timeout'] = backend_http_setting.request_timeout
+          hash['probe'] = backend_http_setting.probe
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Frontend IP Configuration model class for Application Gateway Service
+      class FrontendIPConfiguration < Fog::Model
+        identity :name
+        attribute :id
+        attribute :public_ip_address_id
+        attribute :private_ip_allocation_method
+        attribute :private_ip_address
+        attribute :subnet_id
+        def self.parse(frontend_ip_configuration)
+          hash = {}
+          hash['id'] = frontend_ip_configuration.id
+          hash['name'] = frontend_ip_configuration.name
+          hash['public_ip_address_id'] = frontend_ip_configuration.public_ipaddress.id unless frontend_ip_configuration.public_ipaddress.nil?
+          hash['private_ip_allocation_method'] = frontend_ip_configuration.private_ipallocation_method
+          private_ip_address = frontend_ip_configuration.private_ipaddress
+          hash['private_ip_address'] = private_ip_address
+          hash['subnet_id'] = frontend_ip_configuration.subnet.id unless frontend_ip_configuration.subnet.nil?
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Frontenf Port model class for Application Gateway Service
+      class FrontendPort < Fog::Model
+        identity :name
+        attribute :id
+        attribute :port
+
+        def self.parse(frontend_port)
+          hash = {}
+          hash['id'] = frontend_port.id
+          hash['name'] = frontend_port.name
+          hash['port'] = frontend_port.port
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,617 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Gateway model class for Application Gateway Service
+      class Gateway < Fog::Model
+        identity :name
+        attribute :id
+        attribute :location
+        attribute :resource_group
+        attribute :provisioning_state
+        attribute :sku_name
+        attribute :sku_tier
+        attribute :sku_capacity
+        attribute :operational_state
+        attribute :gateway_ip_configurations
+        attribute :ssl_certificates
+        attribute :frontend_ip_configurations
+        attribute :frontend_ports
+        attribute :probes
+        attribute :backend_address_pools
+        attribute :backend_http_settings_list
+        attribute :http_listeners
+        attribute :url_path_maps
+        attribute :request_routing_rules
+        attribute :tags
+
+        def self.parse(gateway)
+          hash = {}
+          hash['name'] = gateway.name
+          hash['id'] = gateway.id
+          hash['location'] = gateway.location
+          hash['resource_group'] = get_resource_group_from_id(gateway.id)
+          hash['provisioning_state'] = gateway.provisioning_state
+          unless gateway.sku.nil?
+            hash['sku_name'] = gateway.sku.name
+            hash['sku_tier'] = gateway.sku.tier
+            hash['sku_capacity'] = gateway.sku.capacity
+          end
+          hash['operational_state'] = gateway.operational_state
+
+          hash['gateway_ip_configurations'] = []
+          gateway.gateway_ipconfigurations.each do |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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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['tags'] = gateway.tags
+          hash
+        end
+
+        def save
+          requires :name, :location, :resource_group, :sku_name, :sku_tier, :sku_capacity, :gateway_ip_configurations, :frontend_ip_configurations, :frontend_ports, :backend_address_pools, :backend_http_settings_list, :http_listeners, :request_routing_rules
+
+          validate_gateway_ip_configurations(gateway_ip_configurations) unless gateway_ip_configurations.nil?
+          validate_ssl_certificates(ssl_certificates) unless ssl_certificates.nil?
+          validate_frontend_ip_configurations(frontend_ip_configurations) unless frontend_ip_configurations.nil?
+          validate_frontend_ports(frontend_ports) unless frontend_ports.nil?
+          validate_probes(probes) unless probes.nil?
+          validate_backend_address_pools(backend_address_pools) unless backend_address_pools.nil?
+          validate_backend_http_settings_list(backend_http_settings_list) unless backend_http_settings_list.nil?
+          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 = service.create_or_update_application_gateway(application_gateway_params)
+          merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
+        end
+
+        def application_gateway_params
+          {
+            name: name,
+            location: location,
+            resource_group: resource_group,
+            sku_name: sku_name,
+            sku_tier: sku_tier,
+            sku_capacity: sku_capacity,
+            gateway_ip_configurations: gateway_ip_configurations,
+            ssl_certificates: ssl_certificates,
+            frontend_ip_configurations: frontend_ip_configurations,
+            frontend_ports: frontend_ports,
+            probes: probes,
+            backend_address_pools: backend_address_pools,
+            backend_http_settings_list: backend_http_settings_list,
+            http_listeners: http_listeners,
+            url_path_maps: url_path_maps,
+            request_routing_rules: request_routing_rules,
+            tags: tags
+          }
+        end
+
+        def validate_gateway_ip_configurations(gateway_ip_configurations)
+          if gateway_ip_configurations.is_a?(Array)
+            if gateway_ip_configurations.any?
+              gateway_ip_configurations.each do |gateway_ip_configuration|
+                if gateway_ip_configuration.is_a?(Hash)
+                  validate_gateway_ip_configuration_params(gateway_ip_configuration)
+                else
+                  raise(ArgumentError, ':gateway_ip_configurations must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':gateway_ip_configurations must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':gateway_ip_configurations must be an Array')
+          end
+        end
+
+        def validate_gateway_ip_configuration_params(gateway_ip_configuration)
+          required_params = [
+            :name,
+            :subnet_id
+          ]
+          missing = required_params.select { |p| p unless gateway_ip_configuration.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def validate_ssl_certificates(ssl_certificates)
+          if ssl_certificates.is_a?(Array)
+            if ssl_certificates.any?
+              ssl_certificates.each do |ssl_certificate|
+                if ssl_certificate.is_a?(Hash)
+                  validate_ssl_certificate_params(ssl_certificate)
+                else
+                  raise(ArgumentError, ':ssl_certificates must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':ssl_certificates must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':ssl_certificates must be an Array')
+          end
+        end
+
+        def validate_ssl_certificate_params(ssl_certificate)
+          required_params = [
+            :name,
+            :data,
+            :password,
+            :public_cert_data
+          ]
+          missing = required_params.select { |p| p unless ssl_certificate.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def validate_frontend_ip_configurations(frontend_ip_configurations)
+          if frontend_ip_configurations.is_a?(Array)
+            if frontend_ip_configurations.any?
+              frontend_ip_configurations.each do |frontend_ip_configuration|
+                if frontend_ip_configuration.is_a?(Hash)
+                  validate_frontend_ip_configuration_params(frontend_ip_configuration)
+                else
+                  raise(ArgumentError, ':frontend_ip_configurations must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':frontend_ip_configurations must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':frontend_ip_configurations must be an Array')
+          end
+        end
+
+        def validate_frontend_ip_configuration_params(frontend_ip_configuration)
+          required_params = [
+            :name
+          ]
+          missing = required_params.select { |p| p unless frontend_ip_configuration.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def validate_frontend_ports(frontend_ports)
+          if frontend_ports.is_a?(Array)
+            if frontend_ports.any?
+              frontend_ports.each do |frontend_port|
+                if frontend_port.is_a?(Hash)
+                  validate_frontend_port_params(frontend_port)
+                else
+                  raise(ArgumentError, ':frontend_ports must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':frontend_ports must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':frontend_ports must be an Array')
+          end
+        end
+
+        def validate_frontend_port_params(frontend_port)
+          required_params = [
+            :name,
+            :port
+          ]
+          missing = required_params.select { |p| p unless frontend_port.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def validate_probes(probes)
+          if probes.is_a?(Array)
+            if probes.any?
+              probes.each do |probe|
+                if probe.is_a?(Hash)
+                  validate_probe_params(probe)
+                else
+                  raise(ArgumentError, ':probes must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':probes must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':probes must be an Array')
+          end
+        end
+
+        def validate_probe_params(probe)
+          required_params = [
+            :name,
+            :protocol,
+            :host,
+            :path,
+            :interval,
+            :timeout,
+            :unhealthy_threshold
+          ]
+          missing = required_params.select { |p| p unless probe.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def validate_backend_address_pools(backend_address_pools)
+          if backend_address_pools.is_a?(Array)
+            if backend_address_pools.any?
+              backend_address_pools.each do |backend_address_pool|
+                if backend_address_pool.is_a?(Hash)
+                  validate_backend_address_pool_params(backend_address_pool)
+                else
+                  raise(ArgumentError, ':backend_address_pools must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':backend_address_pools must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':backend_address_pools must be an Array')
+          end
+        end
+
+        def validate_backend_address_pool_params(backend_address_pool)
+          required_params = [
+            :name,
+            :ip_addresses
+          ]
+          missing = required_params.select { |p| p unless backend_address_pool.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def validate_backend_http_settings_list(backend_http_settings_list)
+          if backend_http_settings_list.is_a?(Array)
+            if backend_http_settings_list.any?
+              backend_http_settings_list.each do |backend_http_settings|
+                if backend_http_settings.is_a?(Hash)
+                  validate_backend_http_settings_params(backend_http_settings)
+                else
+                  raise(ArgumentError, ':backend_http_settings_list must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':backend_http_settings_list must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':backend_http_settings_list must be an Array')
+          end
+        end
+
+        def validate_backend_http_settings_params(backend_http_settings)
+          required_params = [
+            :name,
+            :port,
+            :protocol,
+            :cookie_based_affinity
+          ]
+          missing = required_params.select { |p| p unless backend_http_settings.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def validate_http_listeners(http_listeners)
+          if http_listeners.is_a?(Array)
+            if http_listeners.any?
+              http_listeners.each do |http_listener|
+                if http_listener.is_a?(Hash)
+                  validate_http_listener_params(http_listener)
+                else
+                  raise(ArgumentError, ':http_listeners must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':http_listeners must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':http_listeners must be an Array')
+          end
+        end
+
+        def validate_http_listener_params(http_listener)
+          required_params = [
+            :name,
+            :frontend_ip_config_id,
+            :frontend_port_id,
+            :protocol
+          ]
+          missing = required_params.select { |p| p unless http_listener.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def validate_url_path_maps(url_path_maps)
+          if url_path_maps.is_a?(Array)
+            if url_path_maps.any?
+              url_path_maps.each do |url_path_map|
+                if url_path_map.is_a?(Hash)
+                  validate_url_path_map_params(url_path_map)
+                else
+                  raise(ArgumentError, ':url_path_maps must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':url_path_maps must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':url_path_maps must be an Array')
+          end
+        end
+
+        def validate_url_path_map_params(url_path_map)
+          required_params = [
+            :name,
+            :default_backend_address_pool_id,
+            :default_backend_http_settings_id,
+            :path_rules
+          ]
+          missing = required_params.select { |p| p unless url_path_map.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def validate_request_routing_rules(request_routing_rules)
+          if request_routing_rules.is_a?(Array)
+            if request_routing_rules.any?
+              request_routing_rules.each do |request_routing_rule|
+                if request_routing_rule.is_a?(Hash)
+                  validate_request_routing_rule_params(request_routing_rule)
+                else
+                  raise(ArgumentError, ':request_routing_rules must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':request_routing_rules must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':request_routing_rules must be an Array')
+          end
+        end
+
+        def validate_request_routing_rule_params(request_routing_rule)
+          required_params = [
+            :type,
+            :http_listener_id
+          ]
+          missing = required_params.select { |p| p unless request_routing_rule.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def serialize_sub_resources(gateway_params)
+          ip_configurations = []
+          gateway_params[:gateway_ip_configurations].each do |ip_configuration|
+            hash = {}
+            ip_configuration.attributes.each { |key, value| hash[key] = value }
+            ip_configurations << hash
+          end
+          gateway_params[:gateway_ip_configurations] = ip_configurations
+          ssl_certificates = []
+          gateway_params[:ssl_certificates].each do |ssl_certificate|
+            hash = {}
+            ssl_certificate.attributes.each { |key, value| hash[key] = value }
+            ssl_certificates << hash
+          end
+          gateway_params[:ssl_certificates] = ssl_certificates
+          frontend_ip_configurations = []
+          gateway_params[:frontend_ip_configurations].each do |frontend_ip_configuration|
+            hash = {}
+            frontend_ip_configuration.attributes.each { |key, value| hash[key] = value }
+            frontend_ip_configurations << hash
+          end
+          gateway_params[:frontend_ip_configurations] = frontend_ip_configurations
+          frontend_ports = []
+          gateway_params[:frontend_ports].each do |frontend_port|
+            hash = {}
+            frontend_port.attributes.each { |key, value| hash[key] = value }
+            frontend_ports << hash
+          end
+          gateway_params[:frontend_ports] = frontend_ports
+          probes = []
+          gateway_params[:probes].each do |probe|
+            hash = {}
+            probe.attributes.each { |key, value| hash[key] = value }
+            probes << hash
+          end
+          gateway_params[:probes] = probes
+          backend_address_pools = []
+          gateway_params[:backend_address_pools].each do |backend_address_pool|
+            hash = {}
+            backend_address_pool.attributes.each { |key, value| hash[key] = value }
+            backend_address_pools << hash
+          end
+          gateway_params[:backend_address_pools] = backend_address_pools
+          backend_address_ip_addresses = []
+          gateway_params[:backend_address_pools].each do |backend_address_pool|
+            backend_address_pool[:ip_addresses].each do |ip_address|
+              hash = {}
+              ip_address.instance_variables.each_with_object({}) { |instance_variable| hash[:ipAddress] = ip_address.instance_variable_get(instance_variable) }
+              backend_address_ip_addresses << hash
+            end
+            backend_address_pool[:ip_addresses] = backend_address_ip_addresses
+          end
+          backend_http_settings_list = []
+          gateway_params[:backend_http_settings_list].each do |backend_http_setting|
+            hash = {}
+            backend_http_setting.attributes.each { |key, value| hash[key] = value }
+            backend_http_settings_list << hash
+          end
+          gateway_params[:backend_http_settings_list] = backend_http_settings_list
+          http_listeners = []
+          gateway_params[:http_listeners].each do |http_listener|
+            hash = {}
+            http_listener.attributes.each { |key, value| hash[key] = value }
+            http_listeners << hash
+          end
+          gateway_params[:http_listeners] = http_listeners
+          url_path_maps = []
+          gateway_params[:url_path_maps].each do |url_path_map|
+            hash = {}
+            url_path_map.attributes.each { |key, value| hash[key] = value }
+            url_path_maps << hash
+          end
+          gateway_params[:url_path_maps] = url_path_maps
+          request_routing_rules = []
+          gateway_params[:request_routing_rules].each do |request_routing_rule|
+            hash = {}
+            request_routing_rule.attributes.each { |key, value| hash[key] = value }
+            request_routing_rules << hash
+          end
+          gateway_params[:request_routing_rules] = request_routing_rules
+          gateway_params
+        end
+
+        def update_sku(sku_name, sku_capacity = nil)
+          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(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(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(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(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(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(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(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))
+        end
+
+        def start
+          service.start_application_gateway(resource_group, name)
+        end
+
+        def stop
+          service.stop_application_gateway(resource_group, name)
+        end
+
+        def destroy
+          service.delete_application_gateway(resource_group, name)
+        end
+      end
+    end
+  end
+end