fog-azure-rm 0.1.2 → 0.2.0

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

@@ -4,11 +4,13 @@ module Fog
       # Backend Address Pool model class for Application Gateway Service
       class BackendAddressPool < Fog::Model
         identity :name
+        attribute :id
         attribute :ip_addresses
 
         def self.parse(backend_address_pool)
           hash = {}
           backend_addresses = backend_address_pool.backend_addresses
+          hash['id'] = backend_address_pool.id
           hash['name'] = backend_address_pool.name
           hash['ip_addresses'] = []
           backend_addresses.each do |ip_address|

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

@@ -4,6 +4,7 @@ module Fog
       # Backend Http Settings model class for Application Gateway Service
       class BackendHttpSetting < Fog::Model
         identity :name
+        attribute :id
         attribute :port
         attribute :protocol
         attribute :cookie_based_affinity
@@ -12,6 +13,7 @@ module Fog
 
         def self.parse(backend_http_setting)
           hash = {}
+          hash['id'] = backend_http_setting.id
           hash['name'] = backend_http_setting.name
           hash['port'] = backend_http_setting.port
           hash['protocol'] = backend_http_setting.protocol

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

@@ -4,16 +4,20 @@ module Fog
       # Frontend IP Configuration model class for Application Gateway Service
       class FrontendIPConfiguration < Fog::Model
         identity :name
+        attribute :id
         attribute :public_ip_address_id
         attribute :private_ip_allocation_method
         attribute :private_ip_address
+        attribute :subnet_id
         def self.parse(frontend_ip_configuration)
           hash = {}
+          hash['id'] = frontend_ip_configuration.id
           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['subnet_id'] = frontend_ip_configuration.subnet.id unless frontend_ip_configuration.subnet.nil?
           hash
         end
       end

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

@@ -4,10 +4,12 @@ module Fog
       # Frontenf Port model class for Application Gateway Service
       class FrontendPort < Fog::Model
         identity :name
+        attribute :id
         attribute :port
 
         def self.parse(frontend_port)
           hash = {}
+          hash['id'] = frontend_port.id
           hash['name'] = frontend_port.name
           hash['port'] = frontend_port.port
           hash

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

@@ -221,10 +221,7 @@ module Fog
 
         def validate_frontend_ip_configuration_params(frontend_ip_configuration)
           required_params = [
-            :name,
-            :public_ip_address_id,
-            :private_ip_allocation_method,
-            :private_ip_address
+            :name
           ]
           missing = required_params.select { |p| p unless frontend_ip_configuration.key?(p) }
           if missing.length == 1
@@ -355,8 +352,7 @@ module Fog
             :name,
             :port,
             :protocol,
-            :cookie_based_affinity,
-            :request_timeout
+            :cookie_based_affinity
           ]
           missing = required_params.select { |p| p unless backend_http_settings.key?(p) }
           if missing.length == 1

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

@@ -20,6 +20,10 @@ module Fog
           application_gateway = Fog::ApplicationGateway::AzureRM::Gateway.new(service: service)
           application_gateway.merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
         end
+
+        def check_application_gateway_exists(resource_group_name, application_gateway_name)
+          service.check_ag_exists(resource_group_name, application_gateway_name)
+        end
       end
     end
   end

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

@@ -4,6 +4,7 @@ module Fog
       # Http Listener class for Application Gateway Service
       class HttpListener < Fog::Model
         identity :name
+        attribute :id
         attribute :frontend_ip_config_id
         attribute :frontend_port_id
         attribute :protocol
@@ -13,6 +14,7 @@ module Fog
 
         def self.parse(http_listener)
           hash = {}
+          hash['id'] = http_listener.id
           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?

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

@@ -4,14 +4,17 @@ module Fog
       # GatewayIPConfiguration model class for Application Gateway Service
       class IPConfiguration < Fog::Model
         identity :name
+        attribute :id
         attribute :subnet_id
 
         def self.parse(gateway_ip_configuration)
           hash = {}
           if gateway_ip_configuration.is_a? Hash
+            hash['id'] = gateway_ip_configuration['id']
             hash['name'] = gateway_ip_configuration['name']
             hash['subnet_id'] = gateway_ip_configuration['subnet']['id'] unless gateway_ip_configuration['subnet'].nil?
           else
+            hash['id'] = gateway_ip_configuration.id
             hash['name'] = gateway_ip_configuration.name
             hash['subnet_id'] = gateway_ip_configuration.subnet.id unless gateway_ip_configuration.subnet.nil?
           end

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

@@ -4,6 +4,7 @@ module Fog
       # Probe model class for Application Gateway Service
       class Probe < Fog::Model
         identity :name
+        attribute :id
         attribute :protocol
         attribute :host
         attribute :path
@@ -13,6 +14,7 @@ module Fog
 
         def self.parse(probe)
           hash = {}
+          hash['id'] = probe.id
           hash['name'] = probe.name
           hash['protocol'] = probe.protocol
           hash['host'] = probe.host

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

@@ -4,6 +4,7 @@ module Fog
       # Request Routing Rule model class for Application Gateway Service
       class RequestRoutingRule < Fog::Model
         identity :name
+        attribute :id
         attribute :type
         attribute :http_listener_id
         attribute :backend_address_pool_id
@@ -12,6 +13,7 @@ module Fog
 
         def self.parse(request_routing_rule)
           hash = {}
+          hash['id'] = request_routing_rule.id
           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?

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

@@ -4,12 +4,14 @@ module Fog
       # SSL Certificate model class for Application Gateway Service
       class SslCertificate < Fog::Model
         identity :name
+        attribute :id
         attribute :data
         attribute :password
         attribute :public_cert_data
 
         def self.parse(ssl_certificate)
           hash = {}
+          hash['id'] = ssl_certificate.id
           hash['name'] = ssl_certificate.name
           hash['data'] = ssl_certificate.data
           hash['password'] = ssl_certificate.password

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

@@ -4,12 +4,14 @@ module Fog
       # URL Path Map model class for Application Gateway Service
       class UrlPathMap < Fog::Model
         identity :name
+        attribute :id
         attribute :default_backend_address_pool_id
         attribute :default_backend_http_settings_id
         attribute :path_rules
 
         def self.parse(url_path_map)
           hash = {}
+          hash['id'] = url_path_map.id
           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?

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

@@ -25,6 +25,10 @@ module Fog
           availability_set_fog = Fog::Compute::AzureRM::AvailabilitySet.new(service: service)
           availability_set_fog.merge_attributes(Fog::Compute::AzureRM::AvailabilitySet.parse(availability_set))
         end
+
+        def check_availability_set_exists(resource_group, name)
+          service.check_availability_set_exists(resource_group, name)
+        end
       end
     end
   end

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

@@ -21,6 +21,10 @@ module Fog
           virtual_machine_fog = Fog::Compute::AzureRM::Server.new(service: service)
           virtual_machine_fog.merge_attributes(Fog::Compute::AzureRM::Server.parse(virtual_machine))
         end
+
+        def check_vm_exists(resource_group, name)
+          service.check_vm_exists(resource_group, name)
+        end
       end
     end
   end

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

@@ -21,6 +21,10 @@ module Fog
           vm_extension_fog = Fog::Compute::AzureRM::VirtualMachineExtension.new(service: service)
           vm_extension_fog.merge_attributes(Fog::Compute::AzureRM::VirtualMachineExtension.parse(vm_extension))
         end
+
+        def check_vm_extension_exists(resource_group_name, virtual_machine_name, vm_extension_name)
+          service.check_vm_extension_exists(resource_group_name, virtual_machine_name, vm_extension_name)
+        end
       end
     end
   end

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

@@ -24,6 +24,10 @@ module Fog
           record_set_fog = Fog::DNS::AzureRM::RecordSet.new(service: service)
           record_set_fog.merge_attributes(Fog::DNS::AzureRM::RecordSet.parse(record_set))
         end
+
+        def check_record_set_exists(resource_group, name, zone_name, record_type)
+          service.check_record_set_exists(resource_group, name, zone_name, record_type)
+        end
       end
     end
   end

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

@@ -20,8 +20,8 @@ module Fog
           zone_fog.merge_attributes(Fog::DNS::AzureRM::Zone.parse(zone))
         end
 
-        def check_for_zone(resource_group, name)
-          service.check_for_zone(resource_group, name)
+        def check_zone_exists(resource_group, name)
+          service.check_zone_exists(resource_group, name)
         end
       end
     end

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

@@ -0,0 +1,31 @@
+module Fog
+  module KeyVault
+    class AzureRM
+      # AccessPolicyEntry Model for Storage Service
+      class AccessPolicyEntry < Fog::Model
+        identity  :object_id
+        attribute :tenant_id
+        attribute :application_id
+        attribute :keys
+        attribute :secrets
+        attribute :certificates
+
+        def self.parse(access_policy_entry)
+          access_policy_entry_hash = get_hash_from_object(access_policy_entry)
+          permissions = access_policy_entry.permissions
+          unless permissions.nil?
+            access_policy_entry_hash['keys'] = permissions.keys
+            access_policy_entry_hash['secrets'] = permissions.secrets
+            access_policy_entry_hash['certificates'] = permissions.certificates
+          end
+
+          access_policy_entry_hash
+        end
+
+        def save
+          requires :object_id, :tenant_id, :keys, :secrets
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Fog
+  module KeyVault
+    class AzureRM
+      # Vault model for KeyVault Service
+      class Vault < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :location
+        attribute :vault_uri
+        attribute :tenant_id
+        attribute :sku_family
+        attribute :sku_name
+        attribute :access_policies
+        attribute :enabled_for_deployment
+        attribute :enabled_for_disk_encryption
+        attribute :enabled_for_template_deployment
+
+        def self.parse(vault)
+          vault_hash = get_hash_from_object(vault)
+          vault_properties = vault.properties
+
+          unless vault_properties.nil?
+            vault_hash['vault_uri'] = vault_properties.vault_uri
+            vault_hash['tenant_id'] = vault_properties.tenant_id
+
+            unless vault_properties.sku.nil?
+              vault_hash['sku_family'] = vault_properties.sku.family
+              vault_hash['sku_name'] = vault_properties.sku.name
+            end
+
+            vault_hash['access_policies'] = []
+            unless vault_properties.access_policies.nil?
+              vault_properties.access_policies.each do |access_policy|
+                access_policy_entry = Fog::KeyVault::AzureRM::AccessPolicyEntry.new
+                vault_hash['access_policies'] << access_policy_entry.merge_attributes(Fog::KeyVault::AzureRM::AccessPolicyEntry.parse(access_policy))
+              end
+            end
+
+            vault_hash['enabled_for_deployment'] = vault_properties.enabled_for_deployment
+            vault_hash['enabled_for_disk_encryption'] = vault_properties.enabled_for_disk_encryption
+            vault_hash['enabled_for_template_deployment'] = vault_properties.enabled_for_template_deployment
+
+            vault_hash['resource_group'] = get_resource_group_from_id(vault.id)
+          end
+
+          vault_hash
+        end
+
+        def save
+          requires :name, :resource_group, :location, :tenant_id, :sku_family, :sku_name, :access_policies
+          vault = service.create_or_update_vault(vault_hash)
+          merge_attributes(Fog::KeyVault::AzureRM::Vault.parse(vault))
+        end
+
+        def destroy
+          service.delete_vault(resource_group, name)
+        end
+
+        private
+
+        def vault_hash
+          {
+            resource_group: resource_group,
+            name: name,
+            location: location,
+            tenant_id: tenant_id,
+            sku_family: sku_family,
+            sku_name: sku_name,
+            access_policies: access_policies
+          }
+        end
+      end
+    end
+  end
+end

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_authorizations.rb

@@ -18,6 +18,10 @@ module Fog
           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

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

@@ -20,6 +20,10 @@ module Fog
           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

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

@@ -7,9 +7,15 @@ module Fog
         attribute :resource_group
 
         def all
-          requires :resource_group
           load_balancers = []
-          service.list_load_balancers(resource_group).each do |load_balancer|
+          if !resource_group.nil?
+            requires :resource_group
+            l_balancers = service.list_load_balancers(resource_group)
+          else
+            l_balancers = service.list_load_balancers_in_subscription
+          end
+
+          l_balancers.each do |load_balancer|
             load_balancers << Fog::Network::AzureRM::LoadBalancer.parse(load_balancer)
           end
           load(load_balancers)
@@ -20,6 +26,10 @@ module Fog
           load_balancer_fog = Fog::Network::AzureRM::LoadBalancer.new(service: service)
           load_balancer_fog.merge_attributes(Fog::Network::AzureRM::LoadBalancer.parse(load_balancer))
         end
+
+        def check_load_balancer_exists(resource_group_name, load_balancer_name)
+          service.check_load_balancer_exists(resource_group_name, load_balancer_name)
+        end
       end
     end
   end