fog-azure-rm 0.0.6 → 0.0.8

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

@@ -0,0 +1,78 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class is giving implementation For Virtual Machine Extension
+      class VirtualMachineExtension < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :location
+        attribute :vm_name
+        attribute :type
+        attribute :publisher
+        attribute :type_handler_version
+        attribute :auto_upgrade_minor_version
+        attribute :settings
+        attribute :protected_settings
+
+        def self.parse(vm_extension)
+          virtual_machine_extension = {}
+          virtual_machine_extension[:id] = vm_extension.id
+          virtual_machine_extension[:resource_group] = get_resource_group_from_id(vm_extension.id)
+          virtual_machine_extension[:name] = vm_extension.name
+          virtual_machine_extension[:location] = vm_extension.location
+          virtual_machine_extension[:vm_name] = get_virtual_machine_from_id(vm_extension.id)
+          virtual_machine_extension[:type] = vm_extension.virtual_machine_extension_type
+          virtual_machine_extension[:publisher] = vm_extension.publisher
+          virtual_machine_extension[:type_handler_version] = vm_extension.type_handler_version
+          virtual_machine_extension[:auto_upgrade_minor_version] = vm_extension.auto_upgrade_minor_version
+          virtual_machine_extension[:settings] = vm_extension.settings
+          virtual_machine_extension[:protected_settings] = vm_extension.protected_settings
+          virtual_machine_extension
+        end
+
+        def save
+          requires :resource_group, :location, :name, :vm_name, :type, :publisher, :type_handler_version, :settings
+          vm_extension_params = get_vm_extension_params
+          vm_extension = service.create_or_update_vm_extension(vm_extension_params)
+          merge_attributes(VirtualMachineExtension.parse(vm_extension))
+        end
+
+        def update(vm_extension_input)
+          validate_input(vm_extension_input)
+          merge_attributes(vm_extension_input) unless vm_extension_input.empty?
+          vm_extension_params = get_vm_extension_params
+          vm_extension = service.create_or_update_vm_extension(vm_extension_params)
+          merge_attributes(VirtualMachineExtension.parse(vm_extension))
+        end
+
+        def destroy
+          service.delete_vm_extension(resource_group, vm_name, name)
+        end
+
+        private
+
+        def validate_input(vm_extension_input)
+          invalid_attr = [:id, :resource_group, :location, :name, :vm_name, :type, :publisher]
+          result = invalid_attr & vm_extension_input.keys
+          raise 'Cannot modify the given attribute(s)' unless result.empty?
+        end
+
+        def get_vm_extension_params
+          {
+            resource_group: resource_group,
+            location: location,
+            name: name,
+            vm_name: vm_name,
+            type: type,
+            publisher: publisher,
+            type_handler_version: type_handler_version,
+            auto_upgrade_minor_version: auto_upgrade_minor_version,
+            settings: settings,
+            protected_settings: protected_settings
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/compute/virtual_machine_extension'
+
+module Fog
+  module Compute
+    class AzureRM
+      # This class gives the implementation for get for virtual machine extension
+      class VirtualMachineExtensions < Fog::Collection
+        model VirtualMachineExtension
+        attribute :resource_group
+        attribute :vm_name
+
+        def all
+          requires :resource_group, :vm_name
+          vm_extensions = []
+          service.get_virtual_machine(resource_group, vm_name).resources.each do |extension|
+            vm_extensions << VirtualMachineExtension.parse(extension)
+          end
+          load(vm_extensions)
+        end
+
+        def get(resource_group_name, virtual_machine_name, vm_extension_name)
+          vm_extension = service.get_vm_extension(resource_group_name, virtual_machine_name, vm_extension_name)
+          vm_extension_obj = VirtualMachineExtension.new(service: service)
+          vm_extension_obj.merge_attributes(VirtualMachineExtension.parse(vm_extension))
+        end
+      end
+    end
+  end
+end

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

@@ -22,36 +22,36 @@ module Fog
         attribute :peerings
 
         def self.parse(circuit)
-          hash = {}
-          hash['id'] = circuit.id
-          hash['name'] = circuit.name
-          hash['location'] = circuit.location
-          hash['service_key'] = circuit.service_key
-          hash['service_provider_notes'] = circuit.service_provider_notes
-          hash['resource_group'] = get_resource_group_from_id(circuit.id)
-          hash['resource_group'] = circuit.id.split('/')[4]
-          hash['tags'] = circuit.tags
+          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['resource_group'] = circuit.id.split('/')[4]
+          express_route_circuit['tags'] = circuit.tags
           sku = circuit.sku
           unless sku.nil?
-            hash['sku_name'] = sku.name
-            hash['sku_tier'] = sku.tier
-            hash['sku_family'] = sku.family
+            express_route_circuit['sku_name'] = sku.name
+            express_route_circuit['sku_tier'] = sku.tier
+            express_route_circuit['sku_family'] = sku.family
           end
-          hash['provisioning_state'] = circuit.provisioning_state
-          hash['circuit_provisioning_state'] = circuit.circuit_provisioning_state
-          hash['service_provider_provisioning_state'] = circuit.service_provider_provisioning_state
+          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?
-            hash['service_provider_name'] = service_provider_properties.service_provider_name
-            hash['peering_location'] = service_provider_properties.peering_location
-            hash['bandwidth_in_mbps'] = service_provider_properties.bandwidth_in_mbps
+            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
-          hash['peerings'] = []
+          express_route_circuit['peerings'] = []
           circuit.peerings.each do |peering|
             circuit_peering = Fog::Network::AzureRM::ExpressRouteCircuitPeering.new
-            hash['peerings'] << circuit_peering.merge_attributes(Fog::Network::AzureRM::ExpressRouteCircuitPeering.parse(peering))
+            express_route_circuit['peerings'] << circuit_peering.merge_attributes(Fog::Network::AzureRM::ExpressRouteCircuitPeering.parse(peering))
           end unless circuit.peerings.nil?
-          hash
+          express_route_circuit
         end
 
         def save

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

@@ -25,35 +25,35 @@ module Fog
         attribute :routing_registry_name
 
         def self.parse(circuit_peering)
-          hash = {}
-          hash['id'] = circuit_peering.id
-          hash['name'] = circuit_peering.name
-          hash['resource_group'] = get_resource_group_from_id(circuit_peering.id)
-          hash['circuit_name'] = circuit_peering.id.split('/')[8]
-          hash['provisioning_state'] = circuit_peering.provisioning_state
-          hash['peering_type'] = circuit_peering.peering_type
-          hash['peer_asn'] = circuit_peering.peer_asn
-          hash['azure_asn'] = circuit_peering.azure_asn
-          hash['primary_azure_port'] = circuit_peering.primary_azure_port
-          hash['secondary_azure_port'] = circuit_peering.secondary_azure_port
-          hash['state'] = circuit_peering.state
-          hash['primary_peer_address_prefix'] = circuit_peering.primary_peer_address_prefix
-          hash['secondary_peer_address_prefix'] = circuit_peering.secondary_peer_address_prefix
-          hash['vlan_id'] = circuit_peering.vlan_id
+          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'] = circuit_peering.id.split('/')[8]
+          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
-            hash['advertised_public_prefixes'] = []
+            express_route_circuit_peering['advertised_public_prefixes'] = []
             public_prefixes.each do |public_prefix|
-              hash['advertised_public_prefixes'] << public_prefix
+              express_route_circuit_peering['advertised_public_prefixes'] << public_prefix
             end unless public_prefixes.nil?
 
-            hash['advertised_public_prefix_state'] = microsoft_peering_config.advertised_public_prefixes_state
-            hash['customer_asn'] = microsoft_peering_config.customer_asn
-            hash['routing_registry_name'] = microsoft_peering_config.routing_registry_name
+            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
-          hash
+          express_route_circuit_peering
         end
 
         def save

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

@@ -9,19 +9,19 @@ module Fog
         attribute :bandwidths_offered
 
         def self.parse(service_provider)
-          hash = {}
-          hash['id'] = service_provider.id
-          hash['name'] = service_provider.name
+          express_route_service_provider = {}
+          express_route_service_provider['id'] = service_provider.id
+          express_route_service_provider['name'] = service_provider.name
 
-          hash['peering_locations'] = []
+          express_route_service_provider['peering_locations'] = []
           service_provider.peering_locations.each do |peering_location|
-            hash['peering_locations'] << peering_location
+            express_route_service_provider['peering_locations'] << peering_location
           end unless service_provider.peering_locations.nil?
-          hash['bandwidths_offered'] = []
+          express_route_service_provider['bandwidths_offered'] = []
           service_provider.bandwidths_offered.each do |bandwidth_offered|
-            hash['bandwidths_offered'] << bandwidth_offered
+            express_route_service_provider['bandwidths_offered'] << bandwidth_offered
           end unless service_provider.bandwidths_offered.nil?
-          hash
+          express_route_service_provider
         end
       end
     end

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

@@ -34,6 +34,33 @@ module Fog
           hash['direction'] = nsr.direction
           hash
         end
+
+        def save
+          requires :name, :network_security_group_name, :resource_group, :protocol, :source_port_range, :destination_port_range, :source_address_prefix, :destination_address_prefix, :access, :priority, :direction
+          security_rule_params = get_security_rule_params
+          network_security_rule = service.create_or_update_network_security_rule(security_rule_params)
+          merge_attributes(NetworkSecurityRule.parse(network_security_rule))
+        end
+
+        def get_security_rule_params
+          {
+            name: name,
+            resource_group: resource_group,
+            protocol: protocol,
+            network_security_group_name: network_security_group_name,
+            source_port_range: source_port_range,
+            destination_port_range: destination_port_range,
+            source_address_prefix: source_address_prefix,
+            destination_address_prefix: destination_address_prefix,
+            access: access,
+            priority: priority,
+            direction: direction
+          }
+        end
+
+        def destroy
+          service.delete_network_security_rule(resource_group, network_security_group_name, name)
+        end
       end
     end
   end

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

@@ -0,0 +1,31 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/network/network_security_rule'
+
+module Fog
+  module Network
+    class AzureRM
+      # collection class for Network Security Rule
+      class NetworkSecurityRules < Fog::Collection
+        model Fog::Network::AzureRM::NetworkSecurityRule
+        attribute :resource_group
+        attribute :network_security_group_name
+
+        def all
+          requires :resource_group
+          requires :network_security_group_name
+          network_security_rules = []
+          service.list_network_security_rules(resource_group, network_security_group_name).each do |nsr|
+            network_security_rules << NetworkSecurityRule.parse(nsr)
+          end
+          load(network_security_rules)
+        end
+
+        def get(resource_group, network_security_group_name, name)
+          network_security_rule = service.get_network_security_rule(resource_group, network_security_group_name, name)
+          network_security_rule_obj = NetworkSecurityRule.new(service: service)
+          network_security_rule_obj.merge_attributes(NetworkSecurityRule.parse(network_security_rule))
+        end
+      end
+    end
+  end
+end

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

@@ -13,18 +13,18 @@ module Fog
         attribute :ip_configurations_ids
 
         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.address_prefix
-          hash['network_security_group_id'] = 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.route_table.id unless subnet.route_table.nil?
-          hash['ip_configurations_ids'] = subnet.ip_configurations.map(&:id) unless subnet.ip_configurations.nil?
-          hash
+          subnet_hash = {}
+          subnet_hash['id'] = subnet.id
+          subnet_hash['name'] = subnet.name
+          subnet_hash['resource_group'] = get_resource_group_from_id(subnet.id)
+          subnet_hash['virtual_network_name'] = get_virtual_network_from_id(subnet.id)
+          subnet_hash['address_prefix'] = subnet.address_prefix
+          subnet_hash['network_security_group_id'] = nil
+          subnet_hash['network_security_group_id'] = subnet.network_security_group.id unless subnet.network_security_group.nil?
+          subnet_hash['route_table_id'] = nil
+          subnet_hash['route_table_id'] = subnet.route_table.id unless subnet.route_table.nil?
+          subnet_hash['ip_configurations_ids'] = subnet.ip_configurations.map(&:id) unless subnet.ip_configurations.nil?
+          subnet_hash
         end
 
         def save
@@ -53,6 +53,10 @@ module Fog
           merge_attributes(Fog::Network::AzureRM::Subnet.parse(subnet))
         end
 
+        def get_available_ipaddresses_count(express_route_enabled)
+          service.get_available_ipaddresses_count(name, address_prefix, ip_configurations_ids, express_route_enabled)
+        end
+
         def destroy
           service.delete_subnet(resource_group, name, virtual_network_name)
         end

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

@@ -52,24 +52,24 @@ module Fog
 
           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))
+            ip_configuration = FrontendIPConfiguration.new
+            hash['ip_configurations'] << ip_configuration.merge_attributes(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))
+            vpn_client_configuration = VpnClientConfiguration.new
+            hash['vpn_client_configuration'] = vpn_client_configuration.merge_attributes(VpnClientConfiguration.parse(network_gateway.vpn_client_configuration))
           end
 
           hash
         end
 
         def save
-          requires :name, :location, :resource_group, :gateway_type, :enable_bgp, :gateway_default_site
+          requires :name, :location, :resource_group, :gateway_type, :enable_bgp
           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))
+          merge_attributes(VirtualNetworkGateway.parse(network_gateway))
         end
 
         def destroy

data/lib/fog/azurerm/models/storage/{containers.rb → directories.rb}

@@ -1,17 +1,17 @@
 require 'fog/core/collection'
-require 'fog/azurerm/models/storage/container'
+require 'fog/azurerm/models/storage/directory'
 
 module Fog
   module Storage
     class AzureRM
       # This class is giving implementation of listing containers.
-      class Containers < Fog::Collection
-        model Fog::Storage::AzureRM::Container
+      class Directories < Fog::Collection
+        model Fog::Storage::AzureRM::Directory
 
-        def all(options = { :metadata => true })
+        def all(options = { metadata: true })
           containers = []
           service.list_containers(options).each do |container|
-            hash = Container.parse container
+            hash = Directory.parse container
             hash['public_access_level'] = 'unknown'
             containers << hash
           end
@@ -19,7 +19,7 @@ module Fog
         end
 
         def get(identity)
-          container = all(prefix: identity, metadata: true).find { |item| item.name == identity }
+          container = all(prefix: identity, metadata: true).find { |item| item.key == identity }
           return if container.nil?
 
           access_control_list = service.get_container_access_control_list(identity)[0]
@@ -31,12 +31,12 @@ module Fog
           container
         end
 
-        def get_container_metadata(name)
-          service.get_container_metadata(name)
+        def get_metadata(name, options = {})
+          service.get_container_metadata(name, options)
         end
 
-        def set_container_metadata(name, metadata)
-          service.set_container_metadata(name, metadata)
+        def set_metadata(name, metadata, options = {})
+          service.set_container_metadata(name, metadata, options)
         end
       end
     end

data/lib/fog/azurerm/models/storage/{container.rb → directory.rb}

@@ -2,8 +2,8 @@ module Fog
   module Storage
     class AzureRM
       # This class is giving implementation of create and delete a container.
-      class Container < Fog::Model
-        identity  :name
+      class Directory < Fog::Model
+        identity  :key, aliases: %w(Name name)
         attribute :etag
         attribute :last_modified
         attribute :lease_duration
@@ -13,31 +13,31 @@ module Fog
         attribute :public_access_level
 
         def create(options = {})
-          requires :name
-          merge_attributes(Container.parse(service.create_container(name, options)))
+          requires :key
+          merge_attributes(Directory.parse(service.create_container(key, options)))
         end
 
         alias save create
 
         def get_properties(options = { metadata: true })
-          requires :name
-          merge_attributes(Container.parse(service.get_container_properties(name, options)))
+          requires :key
+          merge_attributes(Directory.parse(service.get_container_properties(key, options)))
         end
 
-        def get_access_control_list(options = {})
-          requires :name
-          merge_attributes(Container.parse(service.get_container_access_control_list(name, options)[0]))
+        def access_control_list(options = {})
+          requires :key
+          merge_attributes(Directory.parse(service.get_container_access_control_list(key, options)[0]))
         end
 
         def destroy(options = {})
-          requires :name
-          service.delete_container name, options
+          requires :key
+          service.delete_container key, options
         end
 
         def self.parse(container)
           hash = {}
           if container.is_a? Hash
-            hash['name'] = container['name']
+            hash['key'] = container['name']
             hash['metadata'] = container['metadata']
             return hash unless container.key?('properties')
 
@@ -47,7 +47,7 @@ module Fog
             hash['lease_status'] = container['properties']['lease_status']
             hash['lease_state'] = container['properties']['lease_state']
           else
-            hash['name'] = container.name
+            hash['key'] = container.name
             hash['metadata'] = container.metadata
             return hash unless container.respond_to?('properties')