fog-azure-rm 0.0.4 → 0.0.5

data/lib/fog/azurerm/fog_azure_rm_exception.rb

@@ -0,0 +1,13 @@
+module Fog
+  module AzureRm
+    # Custom exception class
+    class OperationError < MsRestAzure::AzureOperationError
+      def initialize(exception)
+        super(exception.body['error']['message'])
+        self.request = exception.request
+        self.response = exception.response
+        set_backtrace(exception.backtrace)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Backend Address Pool model class for Application Gateway Service
+      class BackendAddressPool < Fog::Model
+        identity :name
+        attribute :ip_addresses
+
+        def self.parse(backend_address_pool)
+          hash = {}
+          backend_addresses = backend_address_pool.backend_addresses
+          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,26 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Backend Http Settings model class for Application Gateway Service
+      class BackendHttpSetting < Fog::Model
+        identity :name
+        attribute :port
+        attribute :protocol
+        attribute :cookie_based_affinity
+        attribute :request_timeout
+        attribute :probe
+
+        def self.parse(backend_http_setting)
+          hash = {}
+          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,22 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Frontend IP Configuration model class for Application Gateway Service
+      class FrontendIPConfiguration < Fog::Model
+        identity :name
+        attribute :public_ip_address_id
+        attribute :private_ip_allocation_method
+        attribute :private_ip_address
+        def self.parse(frontend_ip_configuration)
+          hash = {}
+          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
+        end
+      end
+    end
+  end
+end

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

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

data/lib/fog/azurerm/models/{network/application_gateway.rb → application_gateway/gateway.rb}

@@ -1,8 +1,8 @@
 module Fog
-  module Network
+  module ApplicationGateway
     class AzureRM
-      # Application Gateway model class for Network Service
-      class ApplicationGateway < Fog::Model
+      # Gateway model class for Application Gateway Service
+      class Gateway < Fog::Model
         identity :name
         attribute :id
         attribute :location
@@ -24,82 +24,78 @@ module Fog
         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?
+          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
         end
 
@@ -118,7 +114,7 @@ module Fog
           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))
+          merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
         end
 
         def validate_gateway_ip_configurations(gateway_ip_configurations)

data/lib/fog/azurerm/models/{network/application_gateways.rb → application_gateway/gateways.rb}

@@ -1,19 +1,19 @@
 require 'fog/core/collection'
-require 'fog/azurerm/models/network/application_gateway'
+require 'fog/azurerm/models/application_gateway/gateway'
 
 module Fog
-  module Network
+  module ApplicationGateway
     class AzureRM
-      # Application Gateway collection class for Network Service
-      class ApplicationGateways < Fog::Collection
-        model Fog::Network::AzureRM::ApplicationGateway
+      # Application Gateway collection class for Application Gateway Service
+      class Gateways < Fog::Collection
+        model Fog::ApplicationGateway::AzureRM::Gateway
         attribute :resource_group
 
         def all
           requires :resource_group
           application_gateways = []
           service.list_application_gateways(resource_group).each do |gateway|
-            application_gateways << Fog::Network::AzureRM::ApplicationGateway.parse(gateway)
+            application_gateways << Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway)
           end
           load(application_gateways)
         end

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

@@ -0,0 +1,28 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Http Listener class for Application Gateway Service
+      class HttpListener < Fog::Model
+        identity :name
+        attribute :frontend_ip_config_id
+        attribute :frontend_port_id
+        attribute :protocol
+        attribute :host_name
+        attribute :ssl_certificate_id
+        attribute :require_server_name_indication
+
+        def self.parse(http_listener)
+          hash = {}
+          hash['name'] = http_listener.name
+          hash['frontend_ip_config_id'] = http_listener.frontend_ipconfiguration.id unless http_listener.frontend_ipconfiguration.nil?
+          hash['frontend_port_id'] = http_listener.frontend_port.id unless http_listener.frontend_port.nil?
+          hash['protocol'] = http_listener.protocol
+          hash['host_name'] = http_listener.host_name
+          hash['ssl_certificate_id'] = http_listener.ssl_certificate.id unless http_listener.ssl_certificate.nil?
+          hash['require_server_name_indication'] = http_listener.require_server_name_indication
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # GatewayIPConfiguration model class for Application Gateway Service
+      class IPConfiguration < Fog::Model
+        identity :name
+        attribute :subnet_id
+
+        def self.parse(gateway_ip_configuration)
+          hash = {}
+          hash['name'] = gateway_ip_configuration.name
+          hash['subnet_id'] = gateway_ip_configuration.subnet.id unless gateway_ip_configuration.subnet.nil?
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Probe model class for Application Gateway Service
+      class Probe < Fog::Model
+        identity :name
+        attribute :protocol
+        attribute :host
+        attribute :path
+        attribute :interval
+        attribute :timeout
+        attribute :unhealthy_threshold
+
+        def self.parse(probe)
+          hash = {}
+          hash['name'] = probe.name
+          hash['protocol'] = probe.protocol
+          hash['host'] = probe.host
+          hash['path'] = probe.path
+          hash['interval'] = probe.interval
+          hash['timeout'] = probe.timeout
+          hash['unhealthy_threshold'] = probe.unhealthy_threshold
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Request Routing Rule model class for Application Gateway Service
+      class RequestRoutingRule < Fog::Model
+        identity :name
+        attribute :type
+        attribute :http_listener_id
+        attribute :backend_address_pool_id
+        attribute :backend_http_settings_id
+        attribute :url_path_map
+
+        def self.parse(request_routing_rule)
+          hash = {}
+          hash['name'] = request_routing_rule.name
+          hash['type'] = request_routing_rule.rule_type
+          hash['http_listener_id'] = request_routing_rule.http_listener.id unless request_routing_rule.http_listener.nil?
+          hash['backend_address_pool_id'] = request_routing_rule.backend_address_pool.id unless request_routing_rule.backend_address_pool.nil?
+          hash['backend_http_settings_id'] = request_routing_rule.backend_http_settings.id unless request_routing_rule.backend_http_settings.nil?
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # SSL Certificate model class for Application Gateway Service
+      class SslCertificate < Fog::Model
+        identity :name
+        attribute :data
+        attribute :password
+        attribute :public_cert_data
+
+        def self.parse(ssl_certificate)
+          hash = {}
+          hash['name'] = ssl_certificate.name
+          hash['data'] = ssl_certificate.data
+          hash['password'] = ssl_certificate.password
+          hash['public_cert_data'] = ssl_certificate.public_cert_data
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # URL Path Map model class for Application Gateway Service
+      class UrlPathMap < Fog::Model
+        identity :name
+        attribute :default_backend_address_pool_id
+        attribute :default_backend_http_settings_id
+        attribute :path_rules
+
+        def self.parse(url_path_map)
+          hash = {}
+          hash['name'] = url_path_map.name
+          hash['default_backend_address_pool_id'] = url_path_map.default_backend_address_pool.id unless url_path_map.default_backend_address_pool.nil?
+          hash['default_backend_http_settings_id'] = url_path_map.default_backend_http_settings.id unless url_path_map.default_backend_http_settings.nil?
+
+          path_rules = url_path_map.path_rules
+          hash['path_rules'] = []
+          path_rules.each do |rule|
+            path_rule = Fog::Network::AzureRM::PathRule.new
+            hash['path_rules'] << path_rule.merge_attributes(Fog::Network::AzureRM::PathRule.parse(rule))
+          end unless path_rules.nil?
+          hash
+        end
+      end
+    end
+  end
+end