fog-azure-rm-temp 0.0.1

data/lib/fog/azurerm/requests/network/create_load_balancer.rb

@@ -0,0 +1,189 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Load-Balancer Request
+      class Real
+        def create_load_balancer(name, location, resource_group, frontend_ip_configurations, backend_address_pool_names, load_balancing_rules, probes, inbound_nat_rules, inbound_nat_pools)
+          msg = "Creating Load-Balancer: #{name}"
+          Fog::Logger.debug msg
+          load_balancer = define_load_balancer(name, location, frontend_ip_configurations, backend_address_pool_names, load_balancing_rules, probes, inbound_nat_rules, inbound_nat_pools)
+          begin
+            load_balancer = @network_client.load_balancers.create_or_update(resource_group, name, load_balancer)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Load-Balancer #{name} created successfully."
+          load_balancer
+        end
+
+        private
+
+        def define_load_balancer(name, location, frontend_ip_configurations, backend_address_pool_names, load_balancing_rules, probes, inbound_nat_rules, inbound_nat_pools)
+          load_balancer = Azure::ARM::Network::Models::LoadBalancer.new
+          load_balancer.name = name
+          load_balancer.location = location
+
+          if frontend_ip_configurations
+            frontend_ip_configuration_arr = define_lb_frontend_ip_configurations(frontend_ip_configurations)
+            load_balancer.frontend_ipconfigurations = frontend_ip_configuration_arr
+          end
+
+          if backend_address_pool_names
+            load_balancer.backend_address_pools = []
+            backend_address_pool_names.each do |bap|
+              backend_pool = Azure::ARM::Network::Models::BackendAddressPool.new
+              backend_pool.name = bap
+              load_balancer.backend_address_pools.push(backend_pool)
+            end
+          end
+
+          if load_balancing_rules
+            load_balancing_rule_arr = define_load_balancing_rule(load_balancing_rules)
+            load_balancer.load_balancing_rules = load_balancing_rule_arr
+          end
+
+          if probes
+            probe_arr = define_probe(probes)
+            load_balancer.probes = probe_arr
+          end
+
+          if inbound_nat_rules
+            inbound_nat_rule_arr = define_inbound_nat_rule(inbound_nat_rules)
+            load_balancer.inbound_nat_rules = inbound_nat_rule_arr
+          end
+
+          if inbound_nat_pools
+            inbound_nat_pool_arr = define_inbound_nat_pool(inbound_nat_pools)
+            load_balancer.inbound_nat_pools = inbound_nat_pool_arr
+          end
+
+          load_balancer
+        end
+
+        def define_inbound_nat_pool(inbound_nat_pools)
+          inbound_nat_pool_arr = []
+          inbound_nat_pools.each do |inp|
+            inbound_nat_pool = Azure::ARM::Network::Models::InboundNatPool.new
+
+            unless inp[:frontend_ip_configuration_id].nil?
+              frontend_ipconfigurations = Azure::ARM::Network::Models::FrontendIPConfiguration.new
+              frontend_ipconfigurations.id = inp[:frontend_ip_configuration_id]
+              inbound_nat_pool.frontend_ipconfiguration = frontend_ipconfigurations
+            end
+
+            inbound_nat_pool.protocol = inp[:protocol]
+            inbound_nat_pool.frontend_port_range_start = inp[:frontend_port_range_start]
+            inbound_nat_pool.frontend_port_range_end = inp[:frontend_port_range_end]
+            inbound_nat_pool.backend_port = inp[:backend_port]
+
+            inbound_nat_pool.name = inp[:name]
+            inbound_nat_pool_arr.push(inbound_nat_pool)
+          end
+          inbound_nat_pool_arr
+        end
+
+        def define_inbound_nat_rule(inbound_nat_rules)
+          inbound_nat_rule_arr = []
+          inbound_nat_rules.each do |inr|
+            inbound_nat_rule = Azure::ARM::Network::Models::InboundNatRule.new
+
+            unless inr[:frontend_ip_configuration_id].nil?
+              frontend_ipconfigurations = Azure::ARM::Network::Models::FrontendIPConfiguration.new
+              frontend_ipconfigurations.id = inr[:frontend_ip_configuration_id]
+              inbound_nat_rule.frontend_ipconfiguration = frontend_ipconfigurations
+            end
+            inbound_nat_rule.protocol = inr[:protocol]
+            inbound_nat_rule.frontend_port = inr[:frontend_port]
+            inbound_nat_rule.backend_port = inr[:backend_port]
+
+            inbound_nat_rule.name = inr[:name]
+            inbound_nat_rule_arr.push(inbound_nat_rule)
+          end
+          inbound_nat_rule_arr
+        end
+
+        def define_probe(probes)
+          probe_arr = []
+          probes.each do |prb|
+            probe = Azure::ARM::Network::Models::Probe.new
+
+            probe.protocol = prb[:protocol]
+            probe.port = prb[:port]
+            probe.interval_in_seconds = prb[:interval_in_seconds]
+            probe.number_of_probes = prb[:number_of_probes]
+            probe.request_path = prb[:request_path]
+
+            probe.name = prb[:name]
+            probe_arr.push(probe)
+          end
+          probe_arr
+        end
+
+        def define_load_balancing_rule(load_balancing_rules)
+          load_balancing_rule_arr = []
+          load_balancing_rules.each do |lbr|
+            load_balancing_rule = Azure::ARM::Network::Models::LoadBalancingRule.new
+
+            load_balancing_rule.protocol = lbr[:protocol]
+            load_balancing_rule.load_distribution = lbr[:load_distribution]
+            load_balancing_rule.idle_timeout_in_minutes = lbr[:idle_timeout_in_minutes]
+            load_balancing_rule.frontend_port = lbr[:frontend_port]
+            load_balancing_rule.backend_port = lbr[:backend_port]
+            load_balancing_rule.enable_floating_ip = lbr[:enable_floating_ip]
+
+            unless lbr[:frontend_ip_configuration_id].nil?
+              frontend_ipconfigurations = Azure::ARM::Network::Models::FrontendIPConfiguration.new
+              frontend_ipconfigurations.id = lbr[:frontend_ip_configuration_id]
+              load_balancing_rule.frontend_ipconfiguration = frontend_ipconfigurations
+            end
+
+            unless lbr[:backend_address_pool_id].nil?
+              backend_address_pool = Azure::ARM::Network::Models::BackendAddressPool.new
+              backend_address_pool.id = lbr[:backend_address_pool_id]
+              load_balancing_rule.backend_address_pool = backend_address_pool
+            end
+
+            unless lbr[:probe_id].nil?
+              probe = Azure::ARM::Network::Models::Probe.new
+              probe.id = lbr[:probe_id]
+              load_balancing_rule.probe = probe
+            end
+
+            load_balancing_rule.name = lbr[:name]
+            load_balancing_rule_arr.push(load_balancing_rule)
+          end
+          load_balancing_rule_arr
+        end
+
+        def define_lb_frontend_ip_configurations(frontend_ip_configurations)
+          frontend_ip_configuration_arr = []
+          frontend_ip_configurations.each do |fic|
+            frontend_ip_configuration = Azure::ARM::Network::Models::FrontendIPConfiguration.new
+            frontend_ip_configuration.private_ipaddress = fic[:private_ipaddress]
+            frontend_ip_configuration.private_ipallocation_method = fic[:private_ipallocation_method]
+            unless fic[:subnet_id].nil?
+              snet = Azure::ARM::Network::Models::Subnet.new
+              snet.id = fic[:subnet_id]
+              frontend_ip_configuration.subnet = snet
+            end
+            unless fic[:public_ipaddress_id].nil?
+              pip = Azure::ARM::Network::Models::PublicIPAddress.new
+              pip.id = fic[:public_ipaddress_id]
+              frontend_ip_configuration.public_ipaddress = pip
+            end
+
+            frontend_ip_configuration.name = fic[:name]
+            frontend_ip_configuration_arr.push(frontend_ip_configuration)
+          end
+          frontend_ip_configuration_arr
+        end
+      end
+
+      # Mock class for Load-Balancer Request
+      class Mock
+        def create_load_balancer(_name, _location, _resource_group, _frontend_ip_configuration_name, _subnet_id, _private_ip_address, _private_ip_allocation_method, _public_ip_address_id, _backend_address_pool_names, _load_balancing_rules, _probes, _inbound_nat_rules, _inbound_nat_pools)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/network/create_or_update_express_route_circuit.rb

@@ -0,0 +1,111 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Network Request
+      class Real
+        def create_or_update_express_route_circuit(circuit_parameters)
+          msg = "Creating/updating Express Route Circuit #{circuit_parameters[:circuit_name]} in Resource Group: #{circuit_parameters[:resource_group_name]}."
+          Fog::Logger.debug msg
+          circuit = get_express_route_circuit_object(circuit_parameters)
+          begin
+            circuit = @network_client.express_route_circuits.create_or_update(circuit_parameters[:resource_group_name], circuit_parameters[:circuit_name], circuit)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Express Route Circuit #{circuit_parameters[:circuit_name]} created/updated successfully."
+          circuit
+        end
+
+        private
+
+        def get_express_route_circuit_object(circuit_parameters)
+          sku = create_express_route_circuit_sku(circuit_parameters[:sku_name], circuit_parameters[:sku_family], circuit_parameters[:sku_tier])
+          service_provider_prop = create_express_route_service_provider_properties(circuit_parameters[:service_provider_name], circuit_parameters[:peering_location], circuit_parameters[:bandwidth_in_mbps])
+          create_express_route_circuit(service_provider_prop, circuit_parameters[:peerings], circuit_parameters[:circuit_name], circuit_parameters[:location], sku, circuit_parameters[:tags])
+        end
+
+        def create_express_route_circuit_sku(sku_name, sku_family, sku_tier)
+          sku = Azure::ARM::Network::Models::ExpressRouteCircuitSku.new
+          sku.name = sku_name
+          sku.family = sku_family
+          sku.tier = sku_tier
+          sku
+        end
+
+        def create_express_route_service_provider_properties(service_provider_name, peering_location, bandwidth_in_mbps)
+          service_provider_prop = Azure::ARM::Network::Models::ExpressRouteCircuitServiceProviderProperties.new
+          service_provider_prop.service_provider_name = service_provider_name
+          service_provider_prop.peering_location = peering_location
+          service_provider_prop.bandwidth_in_mbps = bandwidth_in_mbps
+          service_provider_prop
+        end
+
+        def create_express_route_circuit(service_provider_prop, peerings, circuit_name, location, sku, tags)
+          express_route_circuit = Azure::ARM::Network::Models::ExpressRouteCircuit.new
+          express_route_circuit.service_provider_properties = service_provider_prop
+          express_route_circuit.peerings = get_circuit_peerings(peerings) if peerings
+          express_route_circuit.name = circuit_name
+          express_route_circuit.location = location
+          express_route_circuit.sku = sku
+          express_route_circuit.tags = tags if express_route_circuit.tags.nil?
+          express_route_circuit
+        end
+
+        def get_circuit_peerings(peerings)
+          circuit_peerings = []
+          peerings.each do |peering|
+            circuit_peering_object = get_circuit_peering_object(peering)
+            circuit_peerings.push(circuit_peering_object)
+          end
+          circuit_peerings
+        end
+
+        def create_express_route_circuit_peering(peering_type, peer_asn, primary_peer_address_prefix, secondary_peer_address_prefix, vlan_id, name)
+          circuit_peering = Azure::ARM::Network::Models::ExpressRouteCircuitPeering.new
+          circuit_peering.peering_type = peering_type
+          circuit_peering.peer_asn = peer_asn
+          circuit_peering.primary_peer_address_prefix = primary_peer_address_prefix
+          circuit_peering.secondary_peer_address_prefix = secondary_peer_address_prefix
+          circuit_peering.vlan_id = vlan_id
+          circuit_peering.name = name
+          circuit_peering
+        end
+
+        def create_express_route_circuit_peering_config(advertised_public_prefixes, advertised_public_prefix_state, customer_asn, routing_registry_name)
+          peering_config = Azure::ARM::Network::Models::ExpressRouteCircuitPeeringConfig.new
+          peering_config.advertised_public_prefixes = advertised_public_prefixes
+          peering_config.advertised_public_prefixes_state = advertised_public_prefix_state
+          peering_config.customer_asn = customer_asn
+          peering_config.routing_registry_name = routing_registry_name
+          peering_config
+        end
+      end
+
+      # Mock class for Network Request
+      class Mock
+        def create_or_update_express_route_circuit(*)
+          {
+            'name' => 'CircuitName',
+            'location' => 'eastus',
+            'tags' => {
+              'key1' => 'value1',
+              'key2' => 'value2'
+            },
+            'sku' => {
+              'name' => 'Standard_MeteredData',
+              'tier' => 'Standard',
+              'family' => 'MeteredData'
+            },
+            'properties' => {
+              'serviceProviderProperties' => {
+                'serviceProviderName' => 'Telenor',
+                'peeringLocation' => 'London',
+                'bandwidthInMbps' => 100
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/network/create_or_update_express_route_circuit_authorization.rb

@@ -0,0 +1,51 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Express Route Circuit Authorization Request
+      class Real
+        def create_or_update_express_route_circuit_authorization(circuit_authorization_params)
+          msg = @logger_messages['network']['express_route_circuit_authentication']['message']['create']
+                .gsub('NAME', circuit_authorization_params[:authorization_name])
+                .gsub('RESOURCE_GROUP', circuit_authorization_params[:resource_group])
+          Fog::Logger.debug msg
+          circuit_authorization = get_circuit_authorization_object(circuit_authorization_params)
+          begin
+            authorization = @network_client.express_route_circuit_authorizations.create_or_update(circuit_authorization_params[:resource_group], circuit_authorization_params[:circuit_name], circuit_authorization_params[:authorization_name], circuit_authorization)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Express Route Circuit Authorization #{circuit_authorization_params[:authorization_name]} created/updated successfully."
+          authorization
+        end
+
+        private
+
+        def get_circuit_authorization_object(circuit_authorization_params)
+          circuit_authorization = Azure::ARM::Network::Models::ExpressRouteCircuitAuthorization.new
+          circuit_authorization.name = circuit_authorization_params[:authorization_name]
+          circuit_authorization.authorization_key = circuit_authorization_params[:authorization_key]
+          circuit_authorization.authorization_use_status = circuit_authorization_params[:authorization_use_status]
+          circuit_authorization.provisioning_state = circuit_authorization_params[:provisioning_state]
+          circuit_authorization.etag = circuit_authorization_params[:etag]
+
+          circuit_authorization
+        end
+      end
+
+      # Mock class for Express Route Circuit Authorization Request
+      class Mock
+        def create_or_update_express_route_circuit_authorization(*)
+          authorization = {
+            'name' => 'authorization-name',
+            'properties' => {
+              'authorizationKey' => 'authorization-key',
+              'authorizationUseStatus' => 'Available'
+            }
+          }
+          authorization_mapper = Azure::ARM::Network::Models::ExpressRouteCircuitAuthorization.mapper
+          @network_client.deserialize(authorization_mapper, authorization, 'result.body')
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/network/create_or_update_express_route_circuit_peering.rb

@@ -0,0 +1,79 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Network Request
+      class Real
+        def create_or_update_express_route_circuit_peering(circuit_peering_params)
+          msg = "Exception creating/updating Express Route Circuit Peering #{circuit_peering_params[:peering_name]} in Resource Group: #{circuit_peering_params[:resource_group_name]}."
+          Fog::Logger.debug msg
+          circuit_peering = get_circuit_peering_object(circuit_peering_params)
+          begin
+            peering = @network_client.express_route_circuit_peerings.create_or_update(circuit_peering_params[:resource_group_name], circuit_peering_params[:circuit_name], circuit_peering_params[:peering_name], circuit_peering)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Express Route Circuit Peering #{circuit_peering_params[:peering_name]} created/updated successfully."
+          peering
+        end
+
+        private
+
+        def get_circuit_peering_object(circuit_peering_params)
+          circuit_peering = create_express_route_circuit_peering(circuit_peering_params[:peering_type], circuit_peering_params[:peer_asn], circuit_peering_params[:primary_peer_address_prefix], circuit_peering_params[:secondary_peer_address_prefix], circuit_peering_params[:vlan_id], circuit_peering_params[:name])
+
+          if circuit_peering_params[:peering_type].casecmp(MICROSOFT_PEERING).zero?
+            peering_config = create_express_route_circuit_peering_config(circuit_peering_params[:advertised_public_prefixes], circuit_peering_params[:advertised_public_prefix_state], circuit_peering_params[:customer_asn], circuit_peering_params[:routing_registry_name])
+            circuit_peering.microsoft_peering_config = peering_config
+          end
+
+          circuit_peering
+        end
+
+        def create_express_route_circuit_peering(peering_type, peer_asn, primary_peer_address_prefix, secondary_peer_address_prefix, vlan_id, name)
+          circuit_peering = Azure::ARM::Network::Models::ExpressRouteCircuitPeering.new
+          circuit_peering.peering_type = peering_type
+          circuit_peering.peer_asn = peer_asn
+          circuit_peering.primary_peer_address_prefix = primary_peer_address_prefix
+          circuit_peering.secondary_peer_address_prefix = secondary_peer_address_prefix
+          circuit_peering.vlan_id = vlan_id
+          circuit_peering.name = name
+          circuit_peering
+        end
+
+        def create_express_route_circuit_peering_config(advertised_public_prefixes, advertised_public_prefix_state, customer_asn, routing_registry_name)
+          peering_config = Azure::ARM::Network::Models::ExpressRouteCircuitPeeringConfig.new
+          peering_config.advertised_public_prefixes = advertised_public_prefixes
+          peering_config.advertised_public_prefixes_state = advertised_public_prefix_state
+          peering_config.customer_asn = customer_asn
+          peering_config.routing_registry_name = routing_registry_name
+          peering_config
+        end
+      end
+
+      # Mock class for Network Request
+      class Mock
+        def create_or_update_express_route_circuit_peering(*)
+          {
+            'name' => 'PeeringName',
+            'properties' => {
+              'peeringType' => 'MicrosoftPeering',
+              'peerASN' => 100,
+              'primaryPeerAddressPrefix' => '192.168.1.0/30',
+              'secondaryPeerAddressPrefix' => '192.168.2.0/30',
+              'vlanId' => 200,
+              'microsoftPeeringConfig' => {
+                'advertisedpublicprefixes' => [
+                  '11.2.3.4/30',
+                  '12.2.3.4/30'
+                ],
+                'advertisedPublicPrefixState' => 'NotConfigured',
+                'customerAsn' => 200,
+                'routingRegistryName' => '<name>'
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/network/create_or_update_local_network_gateway.rb

@@ -0,0 +1,80 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Local Network Gateway Request
+      class Real
+        def create_or_update_local_network_gateway(local_network_gateway_params)
+          msg = @logger_messages['network']['local_network_gateway']['message']['create']
+                .gsub('NAME', local_network_gateway_params[:name])
+                .gsub('RESOURCE_GROUP', local_network_gateway_params[:resource_group])
+          Fog::Logger.debug msg
+          local_network_gateway = get_local_network_gateway_object(local_network_gateway_params)
+          begin
+            local_network_gateway = @network_client.local_network_gateways.create_or_update(local_network_gateway_params[:resource_group], local_network_gateway.name, local_network_gateway)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Local Network Gateway #{local_network_gateway_params[:name]} created/updated successfully."
+          local_network_gateway
+        end
+
+        private
+
+        def get_local_network_gateway_object(local_network_gateway_params)
+          local_network_gateway = Azure::ARM::Network::Models::LocalNetworkGateway.new
+          local_network_gateway.local_network_address_space = get_local_network_address_space_object(local_network_gateway_params[:local_network_address_space_prefixes]) if local_network_gateway_params[:local_network_address_space_prefixes]
+          local_network_gateway.gateway_ip_address = local_network_gateway_params[:gateway_ip_address] if local_network_gateway_params[:gateway_ip_address]
+          local_network_gateway.bgp_settings = get_bgp_settings_object(local_network_gateway_params)
+
+          local_network_gateway.name = local_network_gateway_params[:name]
+          local_network_gateway.type = local_network_gateway_params[:type]
+          local_network_gateway.location = local_network_gateway_params[:location]
+          local_network_gateway.tags = local_network_gateway_params[:tags] if local_network_gateway.tags.nil?
+          local_network_gateway.provisioning_state = local_network_gateway_params[:provisioning_state]
+
+          local_network_gateway
+        end
+
+        def get_local_network_address_space_object(local_network_address_space_prefixes)
+          address_space = Azure::ARM::Network::Models::AddressSpace.new
+          address_space.address_prefixes = local_network_address_space_prefixes
+          address_space
+        end
+
+        def get_bgp_settings_object(local_network_gateway_params)
+          bgp_settings = Azure::ARM::Network::Models::BgpSettings.new
+          bgp_settings.asn = local_network_gateway_params[:asn]
+          bgp_settings.bgp_peering_address = local_network_gateway_params[:bgp_peering_address]
+          bgp_settings.peer_weight = local_network_gateway_params[:peer_weight]
+          bgp_settings
+        end
+      end
+
+      # Mock class for Local Network Gateway Request
+      class Mock
+        def create_or_update_virtual_network_gateway(*)
+          local_network_gateway = {
+            'id' => '/subscriptions/<Subscription_id>/resourceGroups/learn_fog/providers/Microsoft.Network/localNetworkGateways/testLocalNetworkGateway',
+            'name' => 'testLocalNetworkGateway',
+            'type' => 'Microsoft.Network/localNetworkGateways',
+            'location' => 'eastus',
+            'properties' =>
+              {
+                'local_network_address_space' => {
+                  'address_prefixes' => []
+                },
+                'gateway_ip_address' => '192.168.1.1',
+                'bgp_settings' => {
+                  'asn' => 100,
+                  'bgp_peering_address' => '192.168.1.2',
+                  'peer_weight' => 3
+                }
+              }
+          }
+          local_network_gateway_mapper = Azure::ARM::Network::Models::LocalNetworkGateway.mapper
+          @network_client.deserialize(local_network_gateway_mapper, local_network_gateway, 'result.body')
+        end
+      end
+    end
+  end
+end