fog-azure-rm 0.0.4 → 0.0.5

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

@@ -18,8 +18,10 @@ module Fog
           load(public_ips)
         end
 
-        def get(identity)
-          all.find { |f| f.name == identity }
+        def get(resource_group_name, public_ip_name)
+          public_ip = service.get_public_ip(resource_group_name, public_ip_name)
+          public_ip_object = Fog::Network::AzureRM::PublicIp.new(service: service)
+          public_ip_object.merge_attributes(Fog::Network::AzureRM::PublicIp.parse(public_ip))
         end
 
         def check_if_exists(resource_group, name)

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

@@ -14,16 +14,16 @@ module Fog
 
         def self.parse(subnet)
           hash = {}
-          hash['id'] = subnet['id']
-          hash['name'] = subnet['name']
-          hash['resource_group'] = get_resource_group_from_id(subnet['id'])
-          hash['virtual_network_name'] = get_virtual_network_from_id(subnet['id'])
-          hash['address_prefix'] = subnet['properties']['addressPrefix']
+          hash['id'] = subnet.id
+          hash['name'] = subnet.name
+          hash['resource_group'] = get_resource_group_from_id(subnet.id)
+          hash['virtual_network_name'] = get_virtual_network_from_id(subnet.id)
+          hash['address_prefix'] = subnet.address_prefix
           hash['network_security_group_id'] = nil
-          hash['network_security_group_id'] = subnet['properties']['networkSecurityGroup']['id'] unless subnet['properties']['networkSecurityGroup'].nil?
+          hash['network_security_group_id'] = subnet.network_security_group.id unless subnet.network_security_group.nil?
           hash['route_table_id'] = nil
-          hash['route_table_id'] = subnet['properties']['routeTable']['id'] unless subnet['properties']['routeTable'].nil?
-          hash['ip_configurations_ids'] = subnet['properties']['ipConfigurations'].map { |item| item['id'] } unless subnet['properties']['ipConfigurations'].nil?
+          hash['route_table_id'] = subnet.route_table.id unless subnet.route_table.nil?
+          hash['ip_configurations_ids'] = subnet.ip_configurations.map(&:id) unless subnet.ip_configurations.nil?
           hash
         end
 

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

@@ -14,15 +14,15 @@ module Fog
 
         def self.parse(vnet)
           hash = {}
-          hash['id'] = vnet['id']
-          hash['name'] = vnet['name']
-          hash['resource_group'] = get_resource_group_from_id(vnet['id'])
-          hash['location'] = vnet['location']
-          hash['dns_servers'] = vnet['properties']['dhcpOptions']['dnsServers'] unless vnet['properties']['dhcpOptions'].nil?
-          hash['address_prefixes'] = vnet['properties']['addressSpace']['addressPrefixes'] unless vnet['properties']['addressSpace']['addressPrefixes'].nil?
+          hash['id'] = vnet.id
+          hash['name'] = vnet.name
+          hash['resource_group'] = get_resource_group_from_id(vnet.id)
+          hash['location'] = vnet.location
+          hash['dns_servers'] = vnet.dhcp_options.dns_servers unless vnet.dhcp_options.nil?
+          hash['address_prefixes'] = vnet.address_space.address_prefixes unless vnet.address_space.address_prefixes.nil?
 
           subnets = []
-          vnet['properties']['subnets'].each do |subnet|
+          vnet.subnets.each do |subnet|
             subnet_object = Fog::Network::AzureRM::Subnet.new
             subnets.push(subnet_object.merge_attributes(Fog::Network::AzureRM::Subnet.parse(subnet)))
           end
@@ -36,8 +36,8 @@ module Fog
           requires :resource_group
           validate_subnets!(subnets) unless subnets.nil?
 
-          vnet = service.create_or_update_virtual_network(resource_group, name, location, dns_servers, subnets, address_prefixes)
-          merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(vnet))
+          virtual_network = service.create_or_update_virtual_network(resource_group, name, location, dns_servers, subnets, address_prefixes)
+          merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(virtual_network))
         end
 
         def add_dns_servers(dns_servers_list)

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

@@ -0,0 +1,138 @@
+module Fog
+  module Network
+    class AzureRM
+      # VirtualNetworkGateway model class for Network Service
+      class VirtualNetworkGateway < Fog::Model
+        identity :name
+        attribute :id
+        attribute :location
+        attribute :resource_group
+        attribute :tags
+        attribute :gateway_type
+        attribute :gateway_size
+        attribute :vpn_type
+        attribute :enable_bgp
+        attribute :provisioning_state
+        attribute :sku_name
+        attribute :sku_tier
+        attribute :sku_capacity
+        attribute :ip_configurations
+        attribute :asn
+        attribute :bgp_peering_address
+        attribute :peer_weight
+        attribute :vpn_client_configuration
+        attribute :gateway_default_site
+        attribute :vpn_client_address_pool
+        attribute :default_sites
+
+        def self.parse(network_gateway)
+          hash = {}
+          hash['id'] = network_gateway.id
+          hash['name'] = network_gateway.name
+          hash['location'] = network_gateway.location
+          hash['resource_group'] = get_resource_group_from_id(network_gateway.id)
+          hash['tags'] = network_gateway.tags
+          unless network_gateway.sku.nil?
+            hash['sku_name'] = network_gateway.sku.name
+            hash['sku_tier'] = network_gateway.sku.tier
+            hash['sku_capacity'] = network_gateway.sku.capacity
+          end
+          hash['gateway_type'] = network_gateway.gateway_type
+          hash['gateway_default_site'] = network_gateway.gateway_default_site
+          hash['vpn_type'] = network_gateway.vpn_type
+          hash['enable_bgp'] = network_gateway.enable_bgp
+          hash['provisioning_state'] = network_gateway.provisioning_state
+          bgp_settings = network_gateway.bgp_settings
+
+          unless bgp_settings.nil?
+            hash['asn'] = bgp_settings.asn
+            hash['bgp_peering_address'] = bgp_settings.bgp_peering_address
+            hash['peer_weight'] = bgp_settings.peer_weight
+          end
+
+          hash['ip_configurations'] = []
+          network_gateway.ip_configurations.each do |ip_config|
+            ip_configuration = Fog::Network::AzureRM::FrontendIPConfiguration.new
+            hash['ip_configurations'] << ip_configuration.merge_attributes(Fog::Network::AzureRM::FrontendIPConfiguration.parse(ip_config))
+          end unless network_gateway.ip_configurations.nil?
+
+          unless network_gateway.vpn_client_configuration.nil?
+            vpn_client_configuration = Fog::Network::AzureRM::VpnClientConfiguration.new
+            hash['vpn_client_configuration'] = vpn_client_configuration.merge_attributes(Fog::Network::AzureRM::VpnClientConfiguration.parse(network_gateway.vpn_client_configuration))
+          end
+
+          hash
+        end
+
+        def save
+          requires :name, :location, :resource_group, :gateway_type, :enable_bgp, :gateway_default_site
+          validate_ip_configurations(ip_configurations) unless ip_configurations.nil?
+          virtual_network_params = virtual_gateway_parameters
+          network_gateway = service.create_or_update_virtual_network_gateway(virtual_network_params)
+          merge_attributes(Fog::Network::AzureRM::VirtualNetworkGateway.parse(network_gateway))
+        end
+
+        def destroy
+          service.delete_virtual_network_gateway(resource_group, name)
+        end
+
+        private
+
+        def virtual_gateway_parameters
+          {
+            resource_group_name: resource_group,
+            name: name,
+            location: location,
+            tags: tags,
+            gateway_type: gateway_type,
+            gateway_size: gateway_size,
+            vpn_type: vpn_type,
+            enable_bgp: enable_bgp,
+            provisioning_state: provisioning_state,
+            sku_name: sku_name,
+            sku_tier: sku_tier,
+            sku_capacity: sku_capacity,
+            vpn_client_address_pool: vpn_client_address_pool,
+            default_sites: default_sites,
+            gateway_default_site: gateway_default_site,
+            ip_configurations: ip_configurations,
+            vpn_client_configuration: vpn_client_configuration,
+            asn: asn,
+            bgp_peering_address: bgp_peering_address,
+            peer_weight: peer_weight
+          }
+        end
+
+        def validate_ip_configurations(ip_configurations)
+          unless ip_configurations.is_a?(Array)
+            raise(ArgumentError, ':ip_configurations must be an Array')
+          end
+          unless ip_configurations.any?
+            raise(ArgumentError, ':ip_configurations must not be an empty Array')
+          end
+          ip_configurations.each do |ip_configuration|
+            if ip_configuration.is_a?(Hash)
+              validate_ip_configuration_params(ip_configuration)
+            else
+              raise(ArgumentError, ':ip_configurations must be an Array of Hashes')
+            end
+          end
+        end
+
+        def validate_ip_configuration_params(ip_configuration)
+          required_params = [
+            :name,
+            :private_ipallocation_method
+          ]
+          missing = required_params.select { |p| p unless ip_configuration.key?(p) }
+          if missing.length == 1 || missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+          unless ip_configuration.key?(:subnet_id) || ip_configuration.key?(:public_ipaddress_id)
+            raise(ArgumentError, 'subnet_id and public_id can not be empty at the same time.')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/network/network_interface'
+
+module Fog
+  module Network
+    class AzureRM
+      # VirtualNetworkGateways collection class for Network Service
+      class VirtualNetworkGateways < Fog::Collection
+        model Fog::Network::AzureRM::VirtualNetworkGateway
+        attribute :resource_group
+
+        def all
+          requires :resource_group
+          network_gateways = []
+          service.list_virtual_network_gateways(resource_group).each do |gateway|
+            network_gateways << Fog::Network::AzureRM::VirtualNetworkGateway.parse(gateway)
+          end
+          load(network_gateways)
+        end
+
+        def get(resource_group_name, name)
+          network_gateway = service.get_virtual_network_gateway(resource_group_name, name)
+          virtual_network_gateway = Fog::Network::AzureRM::VirtualNetworkGateway.new(service: service)
+          virtual_network_gateway.merge_attributes(Fog::Network::AzureRM::VirtualNetworkGateway.parse(network_gateway))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Fog
+  module Network
+    class AzureRM
+      # Vpn Client Configuration model class for Network Service
+      class VpnClientConfiguration < Fog::Model
+        attribute :address_pool
+        attribute :root_certificates
+        attribute :revoked_certificates
+
+        def self.parse(vpn_client_config)
+          hash = {}
+          hash['address_pool'] = []
+          vpn_client_config.vpn_client_address_pool.each do |address_prefix|
+            hash['address_pool'] << address_prefix
+          end unless vpn_client_config.vpn_client_address_pool.nil?
+
+          hash['root_certificates'] = []
+          vpn_client_config.vpn_client_root_certificates.each do |root_cert|
+            root_certificate = Fog::Network::AzureRM::VpnClientRootCertificate.new
+            hash['root_certificates'] << root_certificate.merge_attributes(Fog::Network::AzureRM::VpnClientRootCertificate.parse(root_cert))
+          end unless vpn_client_config.vpn_client_root_certificates.nil?
+
+          hash['revoked_certificates'] = []
+          vpn_client_config.vpn_client_revoked_certificates.each do |revoked_cert|
+            revoked_certificate = Fog::Network::AzureRM::VpnClientRevokedCertificate.new
+            hash['revoked_certificates'] << revoked_certificate.merge_attributes(Fog::Network::AzureRM::VpnClientRevokedCertificate.parse(revoked_cert))
+          end unless vpn_client_config.vpn_client_revoked_certificates.nil?
+
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Fog
+  module Network
+    class AzureRM
+      # Vpn Client Revoked Certificate model class for Network Service
+      class VpnClientRevokedCertificate < Fog::Model
+        attribute :name
+        attribute :id
+        attribute :thumbprint
+        attribute :provisioning_state
+
+        def self.parse(revoked_cert)
+          hash = {}
+          hash['name'] = revoked_cert.name
+          hash['id'] = revoked_cert.id
+          hash['thumbprint'] = revoked_cert.thumbprint
+          hash['provisioning_state'] = revoked_cert.provisioning_state
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Fog
+  module Network
+    class AzureRM
+      # Vpn Client Root Certificate model class for Network Service
+      class VpnClientRootCertificate < Fog::Model
+        attribute :name
+        attribute :id
+        attribute :public_cert_data
+        attribute :provisioning_state
+
+        def self.parse(root_cert)
+          hash = {}
+          hash['name'] = root_cert.name
+          hash['id'] = root_cert.id
+          hash['public_cert_data'] = root_cert.public_cert_data
+          hash['provisioning_state'] = root_cert.provisioning_state
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/resources/azure_resource.rb

@@ -12,11 +12,11 @@ module Fog
 
         def self.parse(resource)
           hash = {}
-          hash['id'] = resource['id']
-          hash['name'] = resource['name']
-          hash['type'] = resource['type']
-          hash['location'] = resource['location']
-          hash['tags'] = resource['tags']
+          hash['id'] = resource.id
+          hash['name'] = resource.name
+          hash['type'] = resource.type
+          hash['location'] = resource.location
+          hash['tags'] = resource.tags
           hash
         end
       end

data/lib/fog/azurerm/models/resources/dependency.rb

@@ -10,15 +10,15 @@ module Fog
 
         def self.parse(dependency)
           hash = {}
-          hash['id'] = dependency['id']
-          hash['resource_name'] = dependency['resourceName']
-          hash['resource_type'] = dependency['resourceType']
+          hash['id'] = dependency.id
+          hash['resource_name'] = dependency.resource_name
+          hash['resource_type'] = dependency.resource_type
 
           hash['depends_on'] = []
-          dependency['dependsOn'].each do |sub_dependency|
+          dependency.depends_on.each do |sub_dependency|
             dependency_obj = Fog::Resources::AzureRM::Dependency.new
             hash['depends_on'] << dependency_obj.merge_attributes(Fog::Resources::AzureRM::Dependency.parse(sub_dependency))
-          end unless dependency['dependsOn'].nil?
+          end if dependency.respond_to?('depends_on')
           hash
         end
       end

data/lib/fog/azurerm/models/resources/deployment.rb

@@ -21,31 +21,31 @@ module Fog
 
         def self.parse(deployment)
           hash = {}
-          hash['name'] = deployment['name']
-          hash['id'] = deployment['id']
-          hash['resource_group'] = deployment['id'].split('/')[4]
-          hash['correlation_id'] = deployment['correlationId']
-          hash['timestamp'] = deployment['timestamp']
-          hash['outputs'] = deployment['outputs']
+          hash['name'] = deployment.name
+          hash['id'] = deployment.id
+          hash['resource_group'] = get_resource_from_resource_id(deployment.id, RESOURCE_GROUP_NAME)
+          hash['correlation_id'] = deployment.properties.correlation_id
+          hash['timestamp'] = deployment.properties.timestamp
+          hash['outputs'] = deployment.properties.outputs
 
           hash['providers'] = []
-          deployment['properties']['providers'].each do |provider|
+          deployment.properties.providers.each do |provider|
             provider_obj = Fog::Resources::AzureRM::Provider.new
             hash['providers'] << provider_obj.merge_attributes(Fog::Resources::AzureRM::Provider.parse(provider))
           end
 
           hash['dependencies'] = []
-          deployment['properties']['dependencies'].each do |dependency|
+          deployment.properties.dependencies.each do |dependency|
             dependency_obj = Fog::Resources::AzureRM::Dependency.new
             hash['dependencies'] << dependency_obj.merge_attributes(Fog::Resources::AzureRM::Dependency.parse(dependency))
           end
 
-          hash['template_link'] = deployment['properties']['templateLink']['uri']
-          hash['parameters_link'] = deployment['properties']['parametersLink']['uri']
-          hash['content_version'] = deployment['properties']['templateLink']['contentVersion']
-          hash['mode'] = deployment['properties']['mode']
-          hash['debug_setting'] = deployment['properties']['debugSetting']['detailLevel'] unless deployment['properties']['debugSetting'].nil?
-          hash['provisioning_state'] = deployment['properties']['provisioningState']
+          hash['template_link'] = deployment.properties.template_link.uri
+          hash['parameters_link'] = deployment.properties.parameters_link.uri
+          hash['content_version'] = deployment.properties.template_link.content_version
+          hash['mode'] = deployment.properties.mode
+          hash['debug_setting'] = deployment.properties.debug_setting.detail_level unless deployment.properties.debug_setting.nil?
+          hash['provisioning_state'] = deployment.properties.provisioning_state
           hash
         end
 

data/lib/fog/azurerm/models/resources/provider.rb

@@ -10,12 +10,12 @@ module Fog
 
         def self.parse(provider)
           hash = {}
-          hash['id'] = provider['id']
-          hash['namespace'] = provider['namespace']
-          hash['registration_state'] = provider['registrationState'] unless provider['registrationState'].nil?
+          hash['id'] = provider.id
+          hash['namespace'] = provider.namespace
+          hash['registration_state'] = provider.registration_state if provider.respond_to?('registration_state')
 
           hash['resource_types'] = []
-          provider['resourceTypes'].each do |provider_resource_type|
+          provider.resource_types.each do |provider_resource_type|
             provider_resource_type_obj = Fog::Resources::AzureRM::ProviderResourceType.new
             hash['resource_types'] << provider_resource_type_obj.merge_attributes(Fog::Resources::AzureRM::ProviderResourceType.parse(provider_resource_type))
           end

data/lib/fog/azurerm/models/resources/provider_resource_type.rb

@@ -10,10 +10,10 @@ module Fog
 
         def self.parse(provider_resource_type)
           hash = {}
-          hash['resource_type'] = provider_resource_type['resourceType']
-          hash['locations'] = provider_resource_type['locations']
-          hash['api_versions'] = provider_resource_type['apiVersions'] unless provider_resource_type['apiVersions'].nil?
-          hash['properties'] = provider_resource_type['properties'] unless provider_resource_type['properties'].nil?
+          hash['resource_type'] = provider_resource_type.resource_type
+          hash['locations'] = provider_resource_type.locations
+          hash['api_versions'] = provider_resource_type.api_versions if provider_resource_type.respond_to?('api_versions')
+          hash['properties'] = provider_resource_type.properties if provider_resource_type.respond_to?('properties')
           hash
         end
       end