fog-azure-rm 0.0.4 → 0.0.5

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

@@ -12,15 +12,15 @@ module Fog
         attribute :platform_update_domain_count
         attribute :platform_fault_domain_count
 
-        def self.parse(as)
+        def self.parse(availability_set)
           hash = {}
-          hash['id'] = as['id']
-          hash['name'] = as['name']
-          hash['type'] = as['type']
-          hash['location'] = as['location']
-          hash['resource_group'] = as['id'].split('/')[4]
-          hash['platform_update_domain_count'] = as['properties']['platformUpdateDomainCount']
-          hash['platform_fault_domain_count'] = as['properties']['platformFaultDomainCount']
+          hash['id'] = availability_set.id
+          hash['name'] = availability_set.name
+          hash['type'] = availability_set.type
+          hash['location'] = availability_set.location
+          hash['resource_group'] = get_resource_group_from_id(availability_set.id)
+          hash['platform_update_domain_count'] = availability_set.platform_update_domain_count
+          hash['platform_fault_domain_count'] = availability_set.platform_fault_domain_count
           hash
         end
 

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

@@ -23,7 +23,9 @@ module Fog
         end
 
         def get(resource_group, identity)
-          all.find { |as| as.resource_group == resource_group && as.name == identity }
+          availability_set = service.get_availability_set(resource_group, identity)
+          availability_set_obj = Fog::Compute::AzureRM::AvailabilitySet.new(service: service)
+          availability_set_obj.merge_attributes(Fog::Compute::AzureRM::AvailabilitySet.parse(availability_set))
         end
       end
     end

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

@@ -31,37 +31,33 @@ module Fog
 
         def self.parse(vm)
           hash = {}
-          hash['id'] = vm['id']
-          hash['name'] = vm['name']
-          hash['location'] = vm['location']
-          hash['resource_group'] = vm['id'].split('/')[4]
-          hash['vm_size'] = vm['properties']['hardwareProfile']['vmSize']
-          hash['os_disk_name'] = vm['properties']['storageProfile']['osDisk']['name']
-          hash['os_disk_vhd_uri'] = vm['properties']['storageProfile']['osDisk']['vhd']['uri']
-          hash['publisher'] = vm['properties']['storageProfile']['imageReference']['publisher']
-          hash['offer'] = vm['properties']['storageProfile']['imageReference']['offer']
-          hash['sku'] = vm['properties']['storageProfile']['imageReference']['sku']
-          hash['version'] = vm['properties']['storageProfile']['imageReference']['version']
-          hash['username'] = vm['properties']['osProfile']['adminUsername']
+          hash['id'] = vm.id
+          hash['name'] = vm.name
+          hash['location'] = vm.location
+          hash['resource_group'] = get_resource_group_from_id(vm.id)
+          hash['vm_size'] = vm.hardware_profile.vm_size
+          hash['os_disk_name'] = vm.storage_profile.os_disk.name
+          hash['os_disk_vhd_uri'] = vm.storage_profile.os_disk.vhd.uri
+          hash['publisher'] = vm.storage_profile.image_reference.publisher
+          hash['offer'] = vm.storage_profile.image_reference.offer
+          hash['sku'] = vm.storage_profile.image_reference.sku
+          hash['version'] = vm.storage_profile.image_reference.version
+          hash['username'] = vm.os_profile.admin_username
           hash['data_disks'] = []
 
-          vm['properties']['storageProfile']['dataDisks'].each do |disk|
+          vm.storage_profile.data_disks.each do |disk|
             data_disk = Fog::Storage::AzureRM::DataDisk.new
             hash['data_disks'] << data_disk.merge_attributes(Fog::Storage::AzureRM::DataDisk.parse(disk))
-          end unless vm['properties']['storageProfile']['dataDisks'].nil?
-
-          hash['disable_password_authentication'] =
-            if vm['properties']['osProfile']['linuxConfiguration'].nil?
-              false
-            else
-              vm['properties']['osProfile']['linuxConfiguration']['disablePasswordAuthentication']
-            end
-          if vm['properties']['osProfile']['windowsConfiguration']
-            hash['provision_vm_agent'] = vm['properties']['osProfile']['windowsConfiguration']['provisionVMAgent']
-            hash['enable_automatic_updates'] = vm['properties']['osProfile']['windowsConfiguration']['enableAutomaticUpdates']
+          end unless vm.storage_profile.data_disks.nil?
+
+          hash['disable_password_authentication'] = false
+          hash['disable_password_authentication'] = vm.os_profile.linux_configuration.disable_password_authentication unless vm.os_profile.linux_configuration.nil?
+          if vm.os_profile.windows_configuration
+            hash['provision_vm_agent'] = vm.os_profile.windows_configuration.provision_vmagent
+            hash['enable_automatic_updates'] = vm.os_profile.windows_configuration.enable_automatic_updates
           end
-          hash['network_interface_card_id'] = vm['properties']['networkProfile']['networkInterfaces'][0]['id']
-          hash['availability_set_id'] = vm['properties']['availabilitySet']['id'] unless vm['properties']['availabilitySet'].nil?
+          hash['network_interface_card_id'] = vm.network_profile.network_interfaces[0].id
+          hash['availability_set_id'] = vm.availability_set.id unless vm.availability_set.nil?
           hash
         end
 
@@ -69,15 +65,9 @@ module Fog
           requires :name, :location, :resource_group, :vm_size, :storage_account_name,
                    :username, :password, :network_interface_card_id, :publisher, :offer, :sku, :version
           requires :disable_password_authentication if platform.casecmp('linux') == 0
-
           ssh_key_path = "/home/#{username}/.ssh/authorized_keys" unless ssh_key_data.nil?
-          vm = service.create_virtual_machine(
-            resource_group, name, location, vm_size, storage_account_name,
-            username, password, disable_password_authentication,
-            ssh_key_path, ssh_key_data, network_interface_card_id,
-            availability_set_id, publisher, offer, sku, version,
-            platform, provision_vm_agent, enable_automatic_updates
-          )
+          virtual_machine_params = get_virtual_machine_params(ssh_key_path)
+          vm = service.create_virtual_machine(virtual_machine_params)
           merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
         end
 
@@ -126,6 +116,32 @@ module Fog
           vm = service.detach_data_disk_from_vm(resource_group, name, disk_name)
           merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
         end
+
+        private
+
+        def get_virtual_machine_params(ssh_key_path)
+          {
+            resource_group: resource_group,
+            name: name,
+            location: location,
+            vm_size: vm_size,
+            storage_account_name: storage_account_name,
+            username: username,
+            password: password,
+            disable_password_authentication: disable_password_authentication,
+            ssh_key_path: ssh_key_path,
+            ssh_key_data: ssh_key_data,
+            network_interface_card_id: network_interface_card_id,
+            availability_set_id: availability_set_id,
+            publisher: publisher,
+            offer: offer,
+            sku: sku,
+            version: version,
+            platform: platform,
+            provision_vm_agent: provision_vm_agent,
+            enable_automatic_updates: enable_automatic_updates
+          }
+        end
       end
     end
   end

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

@@ -25,6 +25,17 @@ module Fog
           hash['zone_name'] = recordset['id'].split('/')[8]
           hash['type'] = recordset['type']
           type = recordset['type'].split('/')[2]
+          hash['records'] = []
+          if type == 'A'
+            record_entries = recordset['properties']['ARecords']
+            record_entries.each do |record|
+              hash['records'] << record['ipv4Address']
+            end
+          end
+          if type == 'CNAME'
+            record_entries = recordset['properties']['CNAMERecord']['cname']
+            hash['records'] << record_entries
+          end
           hash['a_record'] = recordset['properties']['ARecords'] if type == 'A'
           hash['cname_record'] = recordset['properties']['CNAMERecord'] if type == 'CNAME'
           hash['ttl'] = recordset['properties']['TTL']
@@ -39,17 +50,34 @@ module Fog
           requires :records
           requires :type
           requires :ttl
-          record_set = service.create_record_set(resource_group, name, zone_name, records, type, ttl)
+          record_set = service.create_or_update_record_set(resource_group, name, zone_name, records, type, ttl)
           merge_attributes(Fog::DNS::AzureRM::RecordSet.parse(record_set))
         end
 
         def destroy
-          service.delete_record_set(resource_group, name, zone_name, type.split('/').last)
+          service.delete_record_set(resource_group, name, zone_name, get_record_type(type))
         end
 
         def get_records(resource_group, name, zone_name, record_type)
           service.get_records_from_record_set(resource_group, name, zone_name, record_type)
         end
+
+        def update_ttl(ttl)
+          record_set = service.create_or_update_record_set(resource_group, name, zone_name, records, get_record_type(type), ttl)
+          merge_attributes(Fog::DNS::AzureRM::RecordSet.parse(record_set))
+        end
+
+        def add_a_type_record(record)
+          records << record
+          record_set = service.create_or_update_record_set(resource_group, name, zone_name, records, get_record_type(type), ttl)
+          merge_attributes(Fog::DNS::AzureRM::RecordSet.parse(record_set))
+        end
+
+        def remove_a_type_record(record)
+          records.delete(record)
+          record_set = service.create_or_update_record_set(resource_group, name, zone_name, records, get_record_type(type), ttl)
+          merge_attributes(Fog::DNS::AzureRM::RecordSet.parse(record_set))
+        end
       end
     end
   end

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

@@ -23,8 +23,10 @@ module Fog
           load(record_sets)
         end
 
-        def get(identity, type)
-          all.find { |f| f.name == identity && f.type == "Microsoft.Network/dnszones/#{type}" }
+        def get(resource_group, name, zone_name, record_type)
+          record_set = service.get_record_set(resource_group, name, zone_name, record_type)
+          record_set_obj = Fog::DNS::AzureRM::RecordSet.new(service: service)
+          record_set_obj.merge_attributes(Fog::DNS::AzureRM::RecordSet.parse(record_set))
         end
       end
     end

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

@@ -31,7 +31,7 @@ module Fog
         def save
           requires :name
           requires :resource_group
-          zone = service.create_zone(resource_group, name)
+          zone = service.create_or_update_zone(resource_group, name)
           merge_attributes(Fog::DNS::AzureRM::Zone.parse(zone))
         end
 

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

@@ -17,8 +17,10 @@ module Fog
           load(zones)
         end
 
-        def get(resource_group, identity)
-          all.find { |f| f.name == identity && f.resource_group == resource_group }
+        def get(resource_group, name)
+          zone = service.get_zone(resource_group, name)
+          zone_obj = Fog::DNS::AzureRM::Zone.new(service: service)
+          zone_obj.merge_attributes(Fog::DNS::AzureRM::Zone.parse(zone))
         end
 
         def check_for_zone(resource_group, name)

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

@@ -0,0 +1,89 @@
+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)
+          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
+          sku = circuit.sku
+          unless sku.nil?
+            hash['sku_name'] = sku.name
+            hash['sku_tier'] = sku.tier
+            hash['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
+          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
+          end
+          hash['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))
+          end unless circuit.peerings.nil?
+          hash
+        end
+
+        def save
+          requires :location, :tags, :resource_group, :service_provider_name, :peering_location, :bandwidth_in_mbps
+          express_route_parameters = express_route_circuit_params
+          circuit = service.create_or_update_express_route_circuit(express_route_parameters)
+          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
+          express_route_parameters = {
+            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
+          }
+          express_route_parameters
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+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)
+          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
+
+          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'] = []
+            public_prefixes.each do |public_prefix|
+              hash['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
+          end
+          hash
+        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_parameters = express_route_circuit_peering_params
+          circuit_peering = service.create_or_update_express_route_circuit_peering(circuit_peering_parameters)
+          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
+          circuit_peering_parameters = {
+            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
+          }
+          circuit_peering_parameters
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/network/express_route_circuit_peering'
+
+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
+          requires :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