fog-azure-rm 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 383946b845128b2c0a73641f825dee37cc02f5be
-  data.tar.gz: 5e9413c7e0991277335912bfe558062f6953aed8
+  metadata.gz: 35da447cf146705b309a9b239e0d42b543622911
+  data.tar.gz: 07eb2ced5d952e43d6542d13a1770796efaaff76
 SHA512:
-  metadata.gz: 8ed53c8c074f39e27cedc5ee8827ff6b441772f8082e5c665809f74b8c127c12dee612389799c8b3b739c6d8b21b00f650ded1d2db4fe17cba9619e985dbdfd0
-  data.tar.gz: 569bda7824aa556ded3c1dae642246ee213d05f357e883bc53a86c783ac95bffa6d5b843f84e4e002cd40bf140261d5a8df11781560beff6f848654302b2bf04
+  metadata.gz: a6d6f19416f13e123f54bd38a294356be5d953a16064720e4d417065fa829f96a8803d6812dbfab6a0c94510e420732d8a287a5f5c1c2710fa76c354e16b4ac6
+  data.tar.gz: bee84fdd1d9dd9f99eae7330309ec14e509b73dbd660d6d5af1c21f61a02bc9a01b9d7b78e75058b86b9b8e62c1ea3dee733ea760098be664d61d290bdd27c52

data/CHANGELOG.md

@@ -0,0 +1,64 @@
+## 0.0.3
+
+**Added:**
+- Compute Service: Support for Attach Data Disk & Detach Data Disk in Server
+- Compute Service: Support for Windows VM in create Server
+- Network Service - Application Gateway
+- Compute Service- check_vm_status method in Server as per: https://github.com/fog/fog-azure-rm/issues/38
+- Badges in Readme.md file
+
+**Fixed:**
+- Code Climate Issues
+- Rubocop Offences
+- Compute service - Bug in Sever model as per: https://github.com/fog/fog-azure-rm/issues/36
+- Network Service - Bug in Network Interface as per: https://github.com/fog/fog-azure-rm/issues/65
+
+**Removed:**
+- Shindo Unit Tests
+
+**Integrated:**
+- Code Climate
+- Travis CI
+- Hound CI
+- Gemnasium
+- Waffle
+
+
+## 0.0.2
+
+**Added:**
+- Network Service - Network Security Group
+- Network Service - Load Balancer
+- Network Service - Traffic Manager
+- Minitest Unit Tests - DNS Requests
+- Response Parser: Compute, Network, DNS, Storage
+- Mock class implementation in all services
+
+**Changed:**
+- Response related changes in all services
+- Network Service - Subnet attributes names
+- Code standardization in all services
+
+
+## 0.0.1
+
+**Fixed:**
+- Network Service - Network Interface Card
+
+
+## 0.0.0
+
+**Added:**
+- Shindo Unit Tests - All
+- Minitest Unit Tests - Compute, Storage, Network, Resources, DNS Models
+- Documentation - All Services 
+- Compute Service - Server
+- Compute Service - Availability Set
+- Network Service - Network Interface
+- Network Service - Subnet
+- Network Service - Virtual Network
+- Network Service - Public IP
+- Storage Service - Storage Account
+- Resource Service - Resource Manager
+- DNS Service - Record Set
+- DNS Service - Zone

data/README.md

@@ -1,4 +1,9 @@
 [![Gem Version](https://badge.fury.io/rb/fog-azure-rm.svg)](https://badge.fury.io/rb/fog-azure-rm)
+[![Build Status](https://travis-ci.org/fog/fog-azure-rm.svg?branch=master)](https://travis-ci.org/fog/fog-azure-rm)
+[![Dependency Status](https://gemnasium.com/badges/github.com/fog/fog-azure-rm.svg)](https://gemnasium.com/github.com/fog/fog-azure-rm)
+[![Test Coverage](https://codeclimate.com/github/fog/fog-azure-rm/badges/coverage.svg)](https://codeclimate.com/github/fog/fog-azure-rm/coverage)
+[![Code Climate](https://codeclimate.com/github/fog/fog-azure-rm/badges/gpa.svg)](https://codeclimate.com/github/fog/fog-azure-rm)
+[![Stories in Ready](https://badge.waffle.io/fog/fog-azure-rm.svg?label=ready&title=Ready)](http://waffle.io/fog/fog-azure-rm)
 
 # Fog Azure Resource Manager
 

data/lib/fog/azurerm.rb

@@ -10,24 +10,24 @@ require 'fog/azurerm/storage'
 require 'fog/azurerm/network'
 require 'fog/azurerm/compute'
 
-
 module Fog
+  # Main AzureRM fog Provider Module
   module AzureRM
     def self.services
       begin
         array_of_services = []
         ENV['BUNDLE_GEM'] = File.expand_path('../../lib', File.dirname(__FILE__))
         gem_path = ENV['BUNDLE_GEM']
-        files = Dir.entries(File.join(gem_path,'/fog/azurerm')).select {|f| !File.directory? f}
+        files = Dir.entries(File.join(gem_path, '/fog/azurerm')).select { |f| !File.directory? f }
         files.each do |file|
-          next if file == "config.rb"
-          next if file == "core.rb"
-          next if file == "credentials.rb"
-          next if file == "docs"
-          next if file == "models"
-          next if file == "requests"
-          next if file == "version.rb"
-          array_of_services.push((file.split(".").first).upcase)
+          next if file == 'config.rb'
+          next if file == 'core.rb'
+          next if file == 'credentials.rb'
+          next if file == 'docs'
+          next if file == 'models'
+          next if file == 'requests'
+          next if file == 'version.rb'
+          array_of_services.push(file.split('.').first.upcase)
         end
         array_of_services
       rescue => e

data/lib/fog/azurerm/compute.rb

@@ -1,5 +1,4 @@
 require 'fog/azurerm/core'
-# rubocop:disable LineLength
 module Fog
   module Compute
     # This class registers models, requests and collections
@@ -24,12 +23,17 @@ module Fog
       request :redeploy_virtual_machine
       request :restart_virtual_machine
       request :start_virtual_machine
+      request :check_vm_status
+      request :attach_data_disk_to_vm
+      request :detach_data_disk_from_vm
 
       model_path 'fog/azurerm/models/compute'
       model :availability_set
       collection :availability_sets
       model :server
       collection :servers
+      model :data_disk
+
       # This class provides the mock implementation for unit tests.
       class Mock
         def initialize(_options = {})
@@ -46,6 +50,8 @@ module Fog
         def initialize(options)
           begin
             require 'azure_mgmt_compute'
+            require 'azure_mgmt_storage'
+            require 'azure/storage'
           rescue LoadError => e
             retry if require('rubygems')
             raise e.message
@@ -54,6 +60,8 @@ module Fog
           credentials = Fog::Credentials::AzureRM.get_credentials(options[:tenant_id], options[:client_id], options[:client_secret])
           @compute_mgmt_client = ::Azure::ARM::Compute::ComputeManagementClient.new(credentials)
           @compute_mgmt_client.subscription_id = options[:subscription_id]
+          @storage_mgmt_client = ::Azure::ARM::Storage::StorageManagementClient.new(credentials)
+          @storage_mgmt_client.subscription_id = options[:subscription_id]
         end
       end
     end

data/lib/fog/azurerm/config.rb

@@ -1 +1 @@
-AZURE_RESOURCE = 'https://management.azure.com'
+AZURE_RESOURCE = 'https://management.azure.com'.freeze

data/lib/fog/azurerm/core.rb

@@ -1,6 +1,7 @@
 require 'fog/core'
 
 module Fog
+  # This module registers available services
   module AzureRM
     extend Fog::Provider
     service(:resources, 'Resources')

data/lib/fog/azurerm/credentials.rb

@@ -1,7 +1,7 @@
 module Fog
   module Credentials
+    # This class is managing credentials token
     class AzureRM
-
       def self.get_credentials(tenant_id, client_id, client_secret)
         if @credentials.nil? || new_client(tenant_id, client_id, client_secret)
           get_new_credentials(tenant_id, client_id, client_secret)
@@ -26,12 +26,12 @@ module Fog
 
       def self.new_client(tenant_id, client_id, client_secret)
         @tenant_id != tenant_id ||
-            @client_id != client_id ||
-            @client_secret != client_secret
+          @client_id != client_id ||
+          @client_secret != client_secret
       end
 
       private_class_method :get_new_credentials
       private_class_method :new_client
     end
   end
-end
+end

data/lib/fog/azurerm/dns.rb

@@ -3,6 +3,7 @@ require 'fog/azurerm/credentials'
 
 module Fog
   module DNS
+    # This class registers models, requests and collections
     class AzureRM < Fog::Service
       requires :tenant_id
       requires :client_id
@@ -25,11 +26,13 @@ module Fog
       model :record_set
       collection :record_sets
 
+      # This class provides the mock implementation for unit tests.
       class Mock
-        def initialize(options = {})
+        def initialize(_options = {})
         end
       end
 
+      # This class provides the actual implemention for service calls.
       class Real
         def initialize(options)
           @tenant_id = options[:tenant_id]
@@ -37,10 +40,11 @@ module Fog
           @client_secret = options[:client_secret]
           @subscription_id = options[:subscription_id]
           @resources = Fog::Resources::AzureRM.new(
-              tenant_id: options[:tenant_id],
-              client_id: options[:client_id],
-              client_secret: options[:client_secret],
-              subscription_id: options[:subscription_id])
+            tenant_id: options[:tenant_id],
+            client_id: options[:client_id],
+            client_secret: options[:client_secret],
+            subscription_id: options[:subscription_id]
+          )
         end
       end
     end

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

@@ -1,5 +1,3 @@
-# rubocop:disable MethodLength
-# rubocop:disable AbcSize
 module Fog
   module Compute
     class AzureRM

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

@@ -1,6 +1,5 @@
 require 'fog/core/collection'
 require 'fog/azurerm/models/compute/availability_set'
-# rubocop:disable MethodLength
 module Fog
   module Compute
     class AzureRM

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

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class AzureRM
+      # DataDisk Model for Compute Service
+      class DataDisk < Fog::Model
+        identity  :name
+        attribute :disk_size_gb
+        attribute :lun
+        attribute :vhd_uri
+        attribute :caching
+        attribute :create_option
+
+        def self.parse(vm)
+          hash = {}
+          hash['name'] = vm['name']
+          hash['disk_size_gb'] = vm['diskSizeGB']
+          hash['lun'] = vm['lun']
+          hash['vhd_uri'] = vm['vhd']['uri']
+          hash['caching'] = vm['caching'] unless vm['caching'].nil?
+          hash['create_option'] = vm['createOption']
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -11,16 +11,20 @@ module Fog
         attribute :vm_size
         attribute :storage_account_name
         attribute :os_disk_name
-        attribute :vhd_uri
+        attribute :os_disk_vhd_uri
         attribute :publisher
         attribute :offer
         attribute :sku
         attribute :version
         attribute :username
         attribute :password
+        attribute :data_disks
         attribute :disable_password_authentication
         attribute :ssh_key_path
         attribute :ssh_key_data
+        attribute :platform
+        attribute :provision_vm_agent
+        attribute :enable_automatic_updates
         attribute :network_interface_card_id
         attribute :availability_set_id
 
@@ -32,13 +36,29 @@ module Fog
           hash['resource_group'] = vm['id'].split('/')[4]
           hash['vm_size'] = vm['properties']['hardwareProfile']['vmSize']
           hash['os_disk_name'] = vm['properties']['storageProfile']['osDisk']['name']
-          hash['vhd_uri'] = vm['properties']['storageProfile']['osDisk']['vhd']['uri']
+          hash['os_disk_vhd_uri'] = vm['properties']['storageProfile']['osDisk']['vhd']['uri']
           hash['publisher'] = vm['properties']['storageProfile']['imageReference']['publisher']
           hash['offer'] = vm['properties']['storageProfile']['imageReference']['offer']
           hash['sku'] = vm['properties']['storageProfile']['imageReference']['sku']
           hash['version'] = vm['properties']['storageProfile']['imageReference']['version']
           hash['username'] = vm['properties']['osProfile']['adminUsername']
-          hash['disable_password_authentication'] = vm['properties']['osProfile']['linuxConfiguration']['disablePasswordAuthentication']
+          hash['data_disks'] = []
+
+          vm['properties']['storageProfile']['dataDisks'].each do |disk|
+            data_disk = Fog::Compute::AzureRM::DataDisk.new
+            hash['data_disks'] << data_disk.merge_attributes(Fog::Compute::AzureRM::DataDisk.parse(disk))
+          end unless vm['properties']['storageProfile']['dataDisks'].nil?
+
+          hash['disable_password_authentication'] =
+            if vm['properties']['osProfile']['linuxConfiguration'].nil?
+              false
+            else
+              vm['properties']['osProfile']['linuxConfiguration']['disablePasswordAuthentication']
+            end
+          if vm['properties']['osProfile']['windowsConfiguration']
+            hash['provision_vm_agent'] = vm['properties']['osProfile']['windowsConfiguration']['provisionVMAgent']
+            hash['enable_automatic_updates'] = vm['properties']['osProfile']['windowsConfiguration']['enableAutomaticUpdates']
+          end
           hash['network_interface_card_id'] = vm['properties']['networkProfile']['networkInterfaces'][0]['id']
           hash['availability_set_id'] = vm['properties']['availabilitySet']['id'] unless vm['properties']['availabilitySet'].nil?
           hash
@@ -46,14 +66,17 @@ module Fog
 
         def save
           requires :name, :location, :resource_group, :vm_size, :storage_account_name,
-                   :username, :password, :disable_password_authentication,
-                   :network_interface_card_id, :publisher, :offer, :sku, :version
+                   :username, :password, :network_interface_card_id, :publisher, :offer, :sku, :version
+          requires :disable_password_authentication if platform.casecmp('linux') == 0
 
           ssh_key_path = "/home/#{username}/.ssh/authorized_keys" unless ssh_key_data.nil?
-          vm = service.create_virtual_machine(resource_group, name, location, vm_size, storage_account_name,
-                                         username, password, disable_password_authentication,
-                                         ssh_key_path, ssh_key_data, network_interface_card_id,
-                                         availability_set_id, publisher, offer, sku, version)
+          vm = service.create_virtual_machine(
+            resource_group, name, location, vm_size, storage_account_name,
+            username, password, disable_password_authentication,
+            ssh_key_path, ssh_key_data, network_interface_card_id,
+            availability_set_id, publisher, offer, sku, version,
+            platform, provision_vm_agent, enable_automatic_updates
+          )
           merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
         end
 
@@ -88,6 +111,20 @@ module Fog
         def list_available_sizes
           service.list_available_sizes_for_virtual_machine(resource_group, name)
         end
+
+        def vm_status
+          service.check_vm_status(resource_group, name)
+        end
+
+        def attach_data_disk(disk_name, disk_size, storage_account_name)
+          vm = service.attach_data_disk_to_vm(resource_group, name, disk_name, disk_size, storage_account_name)
+          merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
+        end
+
+        def detach_data_disk(disk_name)
+          vm = service.detach_data_disk_from_vm(resource_group, name, disk_name)
+          merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
+        end
       end
     end
   end

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

@@ -1,5 +1,5 @@
-require "fog/core/collection"
-require "fog/azurerm/models/compute/server"
+require 'fog/core/collection'
+require 'fog/azurerm/models/compute/server'
 
 module Fog
   module Compute
@@ -19,8 +19,8 @@ module Fog
           load(virtual_machines)
         end
 
-        def get(resource_group, identity)
-          all.find { |s| s.name == identity && s.resource_group == resource_group}
+        def get(identity)
+          all.find { |s| s.name == identity }
         end
 
         def get_from_remote(resource_group, name)

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

@@ -17,19 +17,19 @@ module Fog
         attribute :a_record
 
         def self.parse(recordset)
-        hash = {}
-        hash['id'] = recordset['id']
-        hash['name'] = recordset['name']
-        hash['resource_group'] = recordset['id'].split('/')[4]
-        hash['location'] = recordset['location']
-        hash['zone_name'] = recordset['id'].split('/')[8]
-        hash['type'] = recordset['type']
-        type = recordset['type'].split('/')[2]
-        hash['a_record'] = recordset['properties']['ARecords'] if type == 'A'
-        hash['cname_record'] = recordset['properties']['CNAMERecord'] if type == 'CNAME'
-        hash['ttl'] = recordset['properties']['TTL']
-        hash['fqdn'] = recordset['properties']['fqdn']
-        hash
+          hash = {}
+          hash['id'] = recordset['id']
+          hash['name'] = recordset['name']
+          hash['resource_group'] = recordset['id'].split('/')[4]
+          hash['location'] = recordset['location']
+          hash['zone_name'] = recordset['id'].split('/')[8]
+          hash['type'] = recordset['type']
+          type = recordset['type'].split('/')[2]
+          hash['a_record'] = recordset['properties']['ARecords'] if type == 'A'
+          hash['cname_record'] = recordset['properties']['CNAMERecord'] if type == 'CNAME'
+          hash['ttl'] = recordset['properties']['TTL']
+          hash['fqdn'] = recordset['properties']['fqdn']
+          hash
         end
 
         def save

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

@@ -0,0 +1,456 @@
+module Fog
+  module Network
+    class AzureRM
+      # Application Gateway model class for Network Service
+      class ApplicationGateway < 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
+
+        def self.parse(gateway)
+          gateway_properties = gateway['properties']
+
+          hash = {}
+          hash['name'] = gateway['name']
+          hash['id'] = gateway['id']
+          hash['location'] = gateway['location']
+          hash['resource_group'] = gateway['id'].split('/')[4]
+          unless gateway_properties.nil?
+            hash['provisioning_state'] = gateway_properties['provisioningState']
+            unless gateway_properties['sku'].nil?
+              hash['sku_name'] = gateway_properties['sku']['name']
+              hash['sku_tier'] = gateway_properties['sku']['tier']
+              hash['sku_capacity'] = gateway_properties['sku']['capacity']
+            end
+            hash['operational_state'] = gateway_properties['operationalState']
+
+            hash['gateway_ip_configurations'] = []
+            gateway_properties['gatewayIpConfigurations'].each do |ip_configuration|
+              gateway_ip_configuration = Fog::Network::AzureRM::ApplicationGatewayIPConfiguration.new
+              hash['gateway_ip_configurations'] << gateway_ip_configuration.merge_attributes(Fog::Network::AzureRM::ApplicationGatewayIPConfiguration.parse(ip_configuration))
+            end unless gateway_properties['gatewayIpConfigurations'].nil?
+
+            hash['ssl_certificates'] = []
+            gateway_properties['sslCertificates'].each do |certificate|
+              ssl_certificate = Fog::Network::AzureRM::ApplicationGatewaySslCertificate.new
+              hash['ssl_certificates'] << ssl_certificate.merge_attributes(Fog::Network::AzureRM::ApplicationGatewaySslCertificate.parse(certificate))
+            end unless gateway_properties['sslCertificates'].nil?
+
+            hash['frontend_ip_configurations'] = []
+            gateway_properties['frontendIpConfigurations'].each do |frontend_ip_config|
+              frontend_ip_configuration = Fog::Network::AzureRM::ApplicationGatewayFrontendIPConfiguration.new
+              hash['frontend_ip_configurations'] << frontend_ip_configuration.merge_attributes(Fog::Network::AzureRM::ApplicationGatewayFrontendIPConfiguration.parse(frontend_ip_config))
+            end unless gateway_properties['frontendIpConfigurations'].nil?
+
+            hash['frontend_ports'] = []
+            gateway_properties['frontendPorts'].each do |port|
+              frontend_port = Fog::Network::AzureRM::ApplicationGatewayFrontendPort.new
+              hash['frontend_ports'] << frontend_port.merge_attributes(Fog::Network::AzureRM::ApplicationGatewayFrontendPort.parse(port))
+            end unless gateway_properties['frontendPorts'].nil?
+
+            hash['probes'] = []
+            gateway_properties['probes'].each do |probe|
+              gateway_probe = Fog::Network::AzureRM::ApplicationGatewayProbe.new
+              hash['probes'] << gateway_probe.merge_attributes(Fog::Network::AzureRM::ApplicationGatewayProbe.parse(probe))
+            end unless gateway_properties['probes'].nil?
+
+            hash['backend_address_pools'] = []
+            gateway_properties['backendAddressPools'].each do |address|
+              backend_address_pool = Fog::Network::AzureRM::ApplicationGatewayBackendAddressPool.new
+              hash['backend_address_pools'] << backend_address_pool.merge_attributes(Fog::Network::AzureRM::ApplicationGatewayBackendAddressPool.parse(address))
+            end unless gateway_properties['backendAddressPools'].nil?
+
+            hash['backend_http_settings_list'] = []
+            gateway_properties['backendHttpSettingsCollection'].each do |http_setting|
+              backend_http_setting = Fog::Network::AzureRM::ApplicationGatewayBackendHttpSetting.new
+              hash['backend_http_settings_list'] << backend_http_setting.merge_attributes(Fog::Network::AzureRM::ApplicationGatewayBackendHttpSetting.parse(http_setting))
+            end unless gateway_properties['backendHttpSettingsCollection'].nil?
+
+            hash['http_listeners'] = []
+            gateway_properties['httpListeners'].each do |listener|
+              http_listener = Fog::Network::AzureRM::ApplicationGatewayHttpListener.new
+              hash['http_listeners'] << http_listener.merge_attributes(Fog::Network::AzureRM::ApplicationGatewayHttpListener.parse(listener))
+            end unless gateway_properties['httpListeners'].nil?
+
+            hash['url_path_maps'] = []
+            gateway_properties['urlPathMaps'].each do |map|
+              url_path_map = Fog::Network::AzureRM::ApplicationGatewayUrlPathMap.new
+              hash['url_path_maps'] << url_path_map.merge_attributes(Fog::Network::AzureRM::ApplicationGatewayUrlPathMap.parse(map))
+            end unless gateway_properties['urlPathMaps'].nil?
+
+            hash['request_routing_rules'] = []
+            gateway_properties['requestRoutingRules'].each do |rule|
+              request_routing_rule = Fog::Network::AzureRM::ApplicationGatewayRequestRoutingRule.new
+              hash['request_routing_rules'] << request_routing_rule.merge_attributes(Fog::Network::AzureRM::ApplicationGatewayRequestRoutingRule.parse(rule))
+            end unless gateway_properties['requestRoutingRules'].nil?
+          end
+          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_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)
+          merge_attributes(Fog::Network::AzureRM::ApplicationGateway.parse(gateway))
+        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,
+            :public_ip_address_id,
+            :private_ip_allocation_method,
+            :private_ip_address
+          ]
+          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,
+            :request_timeout
+          ]
+          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 destroy
+          service.delete_application_gateway(resource_group, name)
+        end
+      end
+    end
+  end
+end