far-gem 0.5.1

data/lib/fog/azurerm/models/key_vault/vaults.rb

@@ -0,0 +1,27 @@
+module Fog
+  module KeyVault
+    class AzureRM
+      # This class is giving implementation of all/list and get for key vault.
+      class Vaults < Fog::Collection
+        attribute :resource_group
+        model Fog::KeyVault::AzureRM::Vault
+
+        def all
+          requires :resource_group
+          vaults = service.list_vaults(resource_group).map { |vault| Fog::KeyVault::AzureRM::Vault.parse(vault) }
+          load(vaults)
+        end
+
+        def get(resource_group, vault_name)
+          vault = service.get_vault(resource_group, vault_name)
+          vault_obj = Fog::KeyVault::AzureRM::Vault.new(service: service)
+          vault_obj.merge_attributes(Fog::KeyVault::AzureRM::Vault.parse(vault))
+        end
+
+        def check_vault_exists(resource_group, vault_name)
+          service.check_vault_exists(resource_group, vault_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Fog
+  module Network
+    class AzureRM
+      # Express Route Circuit model class for Network Service
+      class ExpressRouteCircuit < Fog::Model
+        identity :name
+        attribute :id
+        attribute :location
+        attribute :resource_group
+        attribute :tags
+        attribute :sku_name
+        attribute :sku_tier
+        attribute :sku_family
+        attribute :service_provider_name
+        attribute :provisioning_state
+        attribute :circuit_provisioning_state
+        attribute :service_provider_provisioning_state
+        attribute :service_key
+        attribute :service_provider_notes
+        attribute :peering_location
+        attribute :bandwidth_in_mbps
+        attribute :peerings
+
+        def self.parse(circuit)
+          express_route_circuit = {}
+          express_route_circuit['id'] = circuit.id
+          express_route_circuit['name'] = circuit.name
+          express_route_circuit['location'] = circuit.location
+          express_route_circuit['service_key'] = circuit.service_key
+          express_route_circuit['service_provider_notes'] = circuit.service_provider_notes
+          express_route_circuit['resource_group'] = get_resource_group_from_id(circuit.id)
+          express_route_circuit['tags'] = circuit.tags
+          sku = circuit.sku
+          unless sku.nil?
+            express_route_circuit['sku_name'] = sku.name
+            express_route_circuit['sku_tier'] = sku.tier
+            express_route_circuit['sku_family'] = sku.family
+          end
+          express_route_circuit['provisioning_state'] = circuit.provisioning_state
+          express_route_circuit['circuit_provisioning_state'] = circuit.circuit_provisioning_state
+          express_route_circuit['service_provider_provisioning_state'] = circuit.service_provider_provisioning_state
+          service_provider_properties = circuit.service_provider_properties
+          unless service_provider_properties.nil?
+            express_route_circuit['service_provider_name'] = service_provider_properties.service_provider_name
+            express_route_circuit['peering_location'] = service_provider_properties.peering_location
+            express_route_circuit['bandwidth_in_mbps'] = service_provider_properties.bandwidth_in_mbps
+          end
+          express_route_circuit['peerings'] = []
+          circuit.peerings.each do |peering|
+            circuit_peering = Fog::Network::AzureRM::ExpressRouteCircuitPeering.new
+            express_route_circuit['peerings'] << circuit_peering.merge_attributes(Fog::Network::AzureRM::ExpressRouteCircuitPeering.parse(peering))
+          end unless circuit.peerings.nil?
+          express_route_circuit
+        end
+
+        def save
+          requires :location, :tags, :resource_group, :service_provider_name, :peering_location, :bandwidth_in_mbps
+          circuit = service.create_or_update_express_route_circuit(express_route_circuit_params)
+          merge_attributes(Fog::Network::AzureRM::ExpressRouteCircuit.parse(circuit))
+        end
+
+        def destroy
+          service.delete_express_route_circuit(resource_group, name)
+        end
+
+        private
+
+        def express_route_circuit_params
+          {
+            resource_group_name: resource_group,
+            circuit_name: name,
+            location: location,
+            tags: tags,
+            sku_name: sku_name,
+            sku_tier: sku_tier,
+            sku_family: sku_family,
+            service_provider_name: service_provider_name,
+            peering_location: peering_location,
+            bandwidth_in_mbps: bandwidth_in_mbps,
+            peerings: peerings
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Fog
+  module Network
+    class AzureRM
+      # Express Route Circuit Authorization model class for Network Service
+      class ExpressRouteCircuitAuthorization < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :authorization_name
+        attribute :authorization_key
+        attribute :authorization_use_status
+        attribute :provisioning_state
+        attribute :etag
+        attribute :circuit_name
+
+        def self.parse(circuit_authorization)
+          circuit_auth_hash = get_hash_from_object(circuit_authorization)
+          circuit_auth_hash['resource_group'] = get_resource_group_from_id(circuit_authorization.id)
+          circuit_auth_hash['circuit_name'] = get_circuit_name_from_id(circuit_authorization.id)
+          circuit_auth_hash
+        end
+
+        def save
+          requires :name, :resource_group, :circuit_name
+          circuit_authorization = service.create_or_update_express_route_circuit_authorization(express_route_circuit_authorization_params)
+          merge_attributes(Fog::Network::AzureRM::ExpressRouteCircuitAuthorization.parse(circuit_authorization))
+        end
+
+        def destroy
+          service.delete_express_route_circuit_authorization(resource_group, circuit_name, name)
+        end
+
+        private
+
+        def express_route_circuit_authorization_params
+          {
+            name: name,
+            resource_group: resource_group,
+            circuit_name: circuit_name,
+            authorization_name: authorization_name,
+            authorization_key: authorization_key,
+            authorization_use_status: authorization_use_status,
+            provisioning_state: provisioning_state,
+            etag: etag
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Fog
+  module Network
+    class AzureRM
+      # ExpressRouteCircuitAuthorization collection class for Network Service
+      class ExpressRouteCircuitAuthorizations < Fog::Collection
+        model Fog::Network::AzureRM::ExpressRouteCircuitAuthorization
+        attribute :resource_group
+        attribute :circuit_name
+
+        def all
+          requires :resource_group, :circuit_name
+          circuit_authorizations = service.list_express_route_circuit_authorizations(resource_group, circuit_name).map { |circuit_authorization| Fog::Network::AzureRM::ExpressRouteCircuitAuthorization.parse(circuit_authorization) }
+          load(circuit_authorizations)
+        end
+
+        def get(resource_group_name, circuit_name, authorization_name)
+          circuit_authorization = service.get_express_route_circuit_authorization(resource_group_name, circuit_name, authorization_name)
+          express_route_circuit_authorization = Fog::Network::AzureRM::ExpressRouteCircuitAuthorization.new(service: service)
+          express_route_circuit_authorization.merge_attributes(Fog::Network::AzureRM::ExpressRouteCircuitAuthorization.parse(circuit_authorization))
+        end
+
+        def check_express_route_cir_auth_exists(resource_group_name, circuit_name, authorization_name)
+          service.check_express_route_cir_auth_exists(resource_group_name, circuit_name, authorization_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module Fog
+  module Network
+    class AzureRM
+      # Express Route Circuit model class for Network Service
+      class ExpressRouteCircuitPeering < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :etag
+        attribute :circuit_name
+        attribute :provisioning_state
+        attribute :peering_type
+        attribute :shared_key
+        attribute :azure_asn
+        attribute :peer_asn
+        attribute :primary_peer_address_prefix
+        attribute :secondary_peer_address_prefix
+        attribute :primary_azure_port
+        attribute :secondary_azure_port
+        attribute :state
+        attribute :vlan_id
+        attribute :advertised_public_prefixes
+        attribute :advertised_public_prefix_state
+        attribute :customer_asn
+        attribute :routing_registry_name
+
+        def self.parse(circuit_peering)
+          express_route_circuit_peering = {}
+          express_route_circuit_peering['id'] = circuit_peering.id
+          express_route_circuit_peering['name'] = circuit_peering.name
+          express_route_circuit_peering['resource_group'] = get_resource_group_from_id(circuit_peering.id)
+          express_route_circuit_peering['circuit_name'] = get_circuit_name_from_id(circuit_peering.id)
+          express_route_circuit_peering['provisioning_state'] = circuit_peering.provisioning_state
+          express_route_circuit_peering['peering_type'] = circuit_peering.peering_type
+          express_route_circuit_peering['peer_asn'] = circuit_peering.peer_asn
+          express_route_circuit_peering['azure_asn'] = circuit_peering.azure_asn
+          express_route_circuit_peering['primary_azure_port'] = circuit_peering.primary_azure_port
+          express_route_circuit_peering['secondary_azure_port'] = circuit_peering.secondary_azure_port
+          express_route_circuit_peering['state'] = circuit_peering.state
+          express_route_circuit_peering['primary_peer_address_prefix'] = circuit_peering.primary_peer_address_prefix
+          express_route_circuit_peering['secondary_peer_address_prefix'] = circuit_peering.secondary_peer_address_prefix
+          express_route_circuit_peering['vlan_id'] = circuit_peering.vlan_id
+
+          microsoft_peering_config = circuit_peering.microsoft_peering_config
+          unless microsoft_peering_config.nil?
+            public_prefixes = microsoft_peering_config.advertised_public_prefixes
+            express_route_circuit_peering['advertised_public_prefixes'] = []
+            public_prefixes.each do |public_prefix|
+              express_route_circuit_peering['advertised_public_prefixes'] << public_prefix
+            end unless public_prefixes.nil?
+
+            express_route_circuit_peering['advertised_public_prefix_state'] = microsoft_peering_config.advertised_public_prefixes_state
+            express_route_circuit_peering['customer_asn'] = microsoft_peering_config.customer_asn
+            express_route_circuit_peering['routing_registry_name'] = microsoft_peering_config.routing_registry_name
+          end
+          express_route_circuit_peering
+        end
+
+        def save
+          requires :name, :resource_group, :circuit_name, :peering_type, :peer_asn, :primary_peer_address_prefix, :secondary_peer_address_prefix, :vlan_id
+          requires :advertised_public_prefixes if peering_type.casecmp(MICROSOFT_PEERING) == 0
+          circuit_peering = service.create_or_update_express_route_circuit_peering(express_route_circuit_peering_params)
+          merge_attributes(Fog::Network::AzureRM::ExpressRouteCircuitPeering.parse(circuit_peering))
+        end
+
+        def destroy
+          service.delete_express_route_circuit_peering(resource_group, name, circuit_name)
+        end
+
+        private
+
+        def express_route_circuit_peering_params
+          {
+            resource_group_name: resource_group,
+            peering_name: name,
+            circuit_name: circuit_name,
+            peering_type: peering_type,
+            peer_asn: peer_asn,
+            primary_peer_address_prefix: primary_peer_address_prefix,
+            secondary_peer_address_prefix: secondary_peer_address_prefix,
+            vlan_id: vlan_id,
+            advertised_public_prefixes: advertised_public_prefixes,
+            advertised_public_prefix_state: advertised_public_prefix_state,
+            customer_asn: customer_asn,
+            routing_registry_name: routing_registry_name
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Fog
+  module Network
+    class AzureRM
+      # ExpressRouteCircuitPeering collection class for Network Service
+      class ExpressRouteCircuitPeerings < Fog::Collection
+        model Fog::Network::AzureRM::ExpressRouteCircuitPeering
+        attribute :resource_group
+        attribute :circuit_name
+
+        def all
+          requires :resource_group, :circuit_name
+          circuit_peerings = []
+          service.list_express_route_circuit_peerings(resource_group, circuit_name).each do |circuit_peering|
+            circuit_peerings << Fog::Network::AzureRM::ExpressRouteCircuitPeering.parse(circuit_peering)
+          end
+          load(circuit_peerings)
+        end
+
+        def get(resource_group_name, peering_name, circuit_name)
+          circuit_peering = service.get_express_route_circuit_peering(resource_group_name, peering_name, circuit_name)
+          express_route_circuit_peering = Fog::Network::AzureRM::ExpressRouteCircuitPeering.new(service: service)
+          express_route_circuit_peering.merge_attributes(Fog::Network::AzureRM::ExpressRouteCircuitPeering.parse(circuit_peering))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Fog
+  module Network
+    class AzureRM
+      # ExpressRouteCircuit collection class for Network Service
+      class ExpressRouteCircuits < Fog::Collection
+        model Fog::Network::AzureRM::ExpressRouteCircuit
+        attribute :resource_group
+
+        def all
+          requires :resource_group
+          express_route_circuits = []
+          service.list_express_route_circuits(resource_group).each do |circuit|
+            express_route_circuits << Fog::Network::AzureRM::ExpressRouteCircuit.parse(circuit)
+          end
+          load(express_route_circuits)
+        end
+
+        def get(resource_group_name, name)
+          circuit = service.get_express_route_circuit(resource_group_name, name)
+          express_route_circuit = Fog::Network::AzureRM::ExpressRouteCircuit.new(service: service)
+          express_route_circuit.merge_attributes(Fog::Network::AzureRM::ExpressRouteCircuit.parse(circuit))
+        end
+
+        def check_express_route_circuit_exists(resource_group_name, name)
+          service.check_express_route_circuit_exists(resource_group_name, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Fog
+  module Network
+    class AzureRM
+      # Express Route Service Provider model class for Network Service
+      class ExpressRouteServiceProvider < Fog::Model
+        identity :name
+        attribute :id
+        attribute :peering_locations
+        attribute :bandwidths_offered
+
+        def self.parse(service_provider)
+          express_route_service_provider = {}
+          express_route_service_provider['id'] = service_provider.id
+          express_route_service_provider['name'] = service_provider.name
+
+          express_route_service_provider['peering_locations'] = []
+          service_provider.peering_locations.each do |peering_location|
+            express_route_service_provider['peering_locations'] << peering_location
+          end unless service_provider.peering_locations.nil?
+          express_route_service_provider['bandwidths_offered'] = []
+          service_provider.bandwidths_offered.each do |bandwidth_offered|
+            express_route_service_provider['bandwidths_offered'] << bandwidth_offered
+          end unless service_provider.bandwidths_offered.nil?
+          express_route_service_provider
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Fog
+  module Network
+    class AzureRM
+      # ExpressRouteServiceProvider collection class for Network Service
+      class ExpressRouteServiceProviders < Fog::Collection
+        model Fog::Network::AzureRM::ExpressRouteServiceProvider
+
+        def all
+          express_route_service_providers = []
+          service.list_express_route_service_providers.each do |service_provider|
+            express_route_service_providers << Fog::Network::AzureRM::ExpressRouteServiceProvider.parse(service_provider)
+          end
+          load(express_route_service_providers)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Fog
+  module Network
+    class AzureRM
+      # FrontendIPConfiguration model for Network Service
+      class FrontendIPConfiguration < Fog::Model
+        identity :name
+        attribute :id
+        attribute :load_balancing_rules
+        attribute :private_ipaddress
+        attribute :private_ipallocation_method
+        attribute :subnet_id
+        attribute :public_ipaddress_id
+
+        def self.parse(frontend_ip_configuration)
+          hash = {}
+          hash['id'] = frontend_ip_configuration.id
+          hash['name'] = frontend_ip_configuration.name
+          hash['subnet_id'] = frontend_ip_configuration.subnet.id unless frontend_ip_configuration.subnet.nil?
+          hash['private_ipaddress'] = frontend_ip_configuration.private_ipaddress if frontend_ip_configuration.respond_to?(:private_ipaddress)
+          hash['private_ipallocation_method'] = frontend_ip_configuration.private_ipallocation_method unless frontend_ip_configuration.private_ipallocation_method.nil?
+          hash['public_ipaddress_id'] = frontend_ip_configuration.public_ipaddress.id unless frontend_ip_configuration.public_ipaddress.nil?
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module Network
+    class AzureRM
+      # InboundNatPool model for Network Service
+      class InboundNatPool < Fog::Model
+        identity :name
+        attribute :id
+        attribute :protocol
+        attribute :frontend_port_range_start
+        attribute :frontend_port_range_end
+        attribute :backend_port
+
+        def self.parse(inbound_nat_pool)
+          hash = {}
+          hash['id'] = inbound_nat_pool.id
+          hash['name'] = inbound_nat_pool.name
+          hash['protocol'] = inbound_nat_pool.protocol
+          hash['frontend_port_range_start'] = inbound_nat_pool.frontend_port_range_start
+          hash['frontend_port_range_end'] = inbound_nat_pool.frontend_port_range_end
+          hash['backend_port'] = inbound_nat_pool.backend_port
+          hash
+        end
+      end
+    end
+  end
+end