fog-azure-rm 0.0.1 → 0.0.2

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

@@ -0,0 +1,249 @@
+module Fog
+  module Network
+    class AzureRM
+      # LoadBalancer model class for Network Service
+      class LoadBalancer < Fog::Model
+        identity :name
+        attribute :id
+        attribute :location
+        attribute :resource_group
+        attribute :frontend_ip_configurations
+        attribute :backend_address_pool_names
+        attribute :load_balancing_rules
+        attribute :probes
+        attribute :inbound_nat_rules
+        attribute :inbound_nat_pools
+
+        # @param [Object] load_balancer
+        def self.parse(load_balancer)
+          load_balancer_properties = load_balancer['properties']
+
+          hash = {}
+          hash['id'] = load_balancer['id']
+          hash['name'] = load_balancer['name']
+          hash['location'] = load_balancer['location']
+          hash['resource_group'] = load_balancer['id'].split('/')[4]
+          hash['backend_address_pool_names'] = load_balancer_properties['backendAddressPools'].map { |item| item['name'] } unless load_balancer_properties['backendAddressPools'].nil?
+
+          hash['frontend_ip_configurations'] = []
+          load_balancer_properties['frontendIPConfigurations'].each do |fic|
+            frontend_ip_configuration = Fog::Network::AzureRM::FrontendIPConfiguration.new
+            hash['frontend_ip_configurations'] << frontend_ip_configuration.merge_attributes(Fog::Network::AzureRM::FrontendIPConfiguration.parse(fic))
+          end unless load_balancer_properties['frontendIPConfigurations'].nil?
+
+          hash['load_balancing_rules'] = []
+          load_balancer_properties['loadBalancingRules'].each do |lbr|
+            load_balancing_rule = Fog::Network::AzureRM::LoadBalangcingRule.new
+            hash['load_balancing_rules'] << load_balancing_rule.merge_attributes(Fog::Network::AzureRM::LoadBalangcingRule.parse(lbr))
+          end unless load_balancer_properties['loadBalancingRules'].nil?
+
+          hash['probes'] = []
+          load_balancer_properties['probes'].each do |prb|
+            prob = Fog::Network::AzureRM::Probe.new
+            hash['probes'] << prob.merge_attributes(Fog::Network::AzureRM::Probe.parse(prb))
+          end unless load_balancer_properties['probes'].nil?
+
+          hash['inbound_nat_rules'] = []
+          load_balancer_properties['inboundNatRules'].each do |inr|
+            inbound_nat_rule = Fog::Network::AzureRM::InboundNatRule.new
+            hash['inbound_nat_rules'] << inbound_nat_rule.merge_attributes(Fog::Network::AzureRM::InboundNatRule.parse(inr))
+          end unless load_balancer_properties['inboundNatRules'].nil?
+
+          hash['inbound_nat_rules'] = []
+          load_balancer_properties['inboundNatPools'].each do |inp|
+            inbound_nat_pool = Fog::Network::AzureRM::InboundNatPool.new
+            hash['inbound_nat_rules'] << inbound_nat_pool.merge_attributes(Fog::Network::AzureRM::InboundNatPool.parse(inp))
+          end unless load_balancer_properties['inboundNatPools'].nil?
+
+          hash
+        end
+
+        def save
+          requires :name, :location, :resource_group
+
+          validate_frontend_ip_configurations(frontend_ip_configurations) unless frontend_ip_configurations.nil?
+          validate_load_balancing_rules(load_balancing_rules) unless load_balancing_rules.nil?
+          validate_probes(probes) unless probes.nil?
+          validate_inbound_nat_rules(inbound_nat_rules) unless inbound_nat_rules.nil?
+          validate_inbound_nat_pools(inbound_nat_pools) unless inbound_nat_pools.nil?
+
+          load_balancer = service.create_load_balancer(name, location, resource_group, frontend_ip_configurations, backend_address_pool_names, load_balancing_rules, probes, inbound_nat_rules, inbound_nat_pools)
+
+          merge_attributes(Fog::Network::AzureRM::LoadBalancer.parse(load_balancer))
+        end
+
+        def validate_load_balancing_rules(load_balancing_rules)
+          if load_balancing_rules.is_a?(Array)
+            if load_balancing_rules.any?
+              load_balancing_rules.each do |lbr|
+                if lbr.is_a?(Hash)
+                  validate_load_balancing_rule_params(lbr)
+                else
+                  raise(ArgumentError, ':load_balancing_rules must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':load_balancing_rules must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':load_balancing_rules must be an Array')
+          end
+        end
+
+        def validate_load_balancing_rule_params(load_balancing_rule)
+          required_params = [
+            :name,
+            :protocol,
+            :frontend_port,
+            :backend_port
+          ]
+          missing = required_params.select { |p| p unless load_balancing_rule.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def validate_probes(probes)
+          if probes.is_a?(Array)
+            if probes.any?
+              probes.each do |prb|
+                if prb.is_a?(Hash)
+                  validate_probe_params(prb)
+                else
+                  raise(ArgumentError, ':probes must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':probes must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':probes must be an Array')
+          end
+        end
+
+        def validate_probe_params(probe)
+          required_params = [
+            :name,
+            :port,
+            :request_path,
+            :interval_in_seconds,
+            :number_of_probes
+          ]
+          missing = required_params.select { |p| p unless probe.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def validate_inbound_nat_rules(inbound_nat_rules)
+          if inbound_nat_rules.is_a?(Array)
+            if inbound_nat_rules.any?
+              inbound_nat_rules.each do |inr|
+                if inr.is_a?(Hash)
+                  validate_inbound_nat_rule_params(inr)
+                else
+                  raise(ArgumentError, ':inbound_nat_rules must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':inbound_nat_rules must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':inbound_nat_rules must be an Array')
+          end
+        end
+
+        def validate_inbound_nat_rule_params(inbound_nat_rule)
+          required_params = [
+            :name,
+            :protocol,
+            :frontend_port,
+            :backend_port
+          ]
+          missing = required_params.select { |p| p unless inbound_nat_rule.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def validate_inbound_nat_pools(inbound_nat_pools)
+          if inbound_nat_pools.is_a?(Array)
+            if inbound_nat_pools.any?
+              inbound_nat_pools.each do |inp|
+                if inp.is_a?(Hash)
+                  validate_inbound_nat_pool_params(inp)
+                else
+                  raise(ArgumentError, ':inbound_nat_pools must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':inbound_nat_pools must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':inbound_nat_pools must be an Array')
+          end
+        end
+
+        def validate_inbound_nat_pool_params(inbound_nat_pool)
+          required_params = [
+            :name,
+            :protocol,
+            :frontend_port_range_start,
+            :frontend_port_range_end,
+            :backend_port
+          ]
+          missing = required_params.select { |p| p unless inbound_nat_pool.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+
+        def validate_frontend_ip_configurations(frontend_ip_configurations)
+          if frontend_ip_configurations.is_a?(Array)
+            if frontend_ip_configurations.any?
+              frontend_ip_configurations.each do |frontend_ip_configuration|
+                if fic.is_a?(Hash)
+                  validate_frontend_ip_configuration_params(fic)
+                else
+                  raise(ArgumentError, ':frontend_ip_configurations must be an Array of Hashes')
+                end
+              end
+            else
+              raise(ArgumentError, ':frontend_ip_configurations must not be an empty Array')
+            end
+          else
+            raise(ArgumentError, ':frontend_ip_configurations must be an Array')
+          end
+        end
+
+        def validate_frontend_ip_configuration_params(frontend_ip_configuration)
+          required_params = [
+            :name,
+            :private_ipallocation_method
+          ]
+          missing = required_params.select { |p| p unless frontend_ip_configuration.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+          unless frontend_ip_configuration.key?(:subnet_id) || frontend_ip_configuration.key?(:public_ipaddress_id)
+            raise(ArgumentError, 'subnet_id and public_id can not be empty at the same time.')
+          end
+        end
+
+        def destroy
+          service.delete_load_balancer(resource_group, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/network/load_balancer'
+
+module Fog
+  module Network
+    class AzureRM
+      # LoadBalancers collection class for Network Service
+      class LoadBalancers < Fog::Collection
+        model Fog::Network::AzureRM::LoadBalancer
+        attribute :resource_group
+
+        def all
+          requires :resource_group
+          load_balancers = []
+          service.list_load_balancers(resource_group).each do |load_balancer|
+            load_balancers << Fog::Network::AzureRM::LoadBalancer.parse(load_balancer)
+          end
+          load(load_balancers)
+        end
+
+        def get(identity)
+          all.find { |f| f.name == identity }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Fog
+  module Network
+    class AzureRM
+      # LoadBalangcingRule model for Network Service
+      class LoadBalangcingRule < Fog::Model
+        identity :name
+        attribute :id
+        attribute :frontend_ip_configuration_id
+        attribute :backend_address_pool_id
+        attribute :protocol
+        attribute :frontend_port
+        attribute :backend_port
+        attribute :probe_id
+        attribute :enable_floating_ip
+        attribute :idle_timeout_in_minutes
+        attribute :load_distribution
+
+        def self.parse(load_balancing_rule)
+          load_balancing_rule_prop = load_balancing_rule['properties']
+          hash = {}
+          hash['id'] = load_balancing_rule['id']
+          hash['name'] = load_balancing_rule['name']
+          unless load_balancing_rule_prop['frontendIPConfiguration'].nil?
+            hash['frontend_ip_configuration_id'] = load_balancing_rule_prop['frontendIPConfiguration']['id']
+          end
+          unless load_balancing_rule_prop['backendAddressPool'].nil?
+            hash['backend_address_pool_id'] = load_balancing_rule_prop['backendAddressPool']['id']
+          end
+
+          hash['protocol'] = load_balancing_rule_prop['protocol']
+          hash['frontend_port'] = load_balancing_rule_prop['frontendPort']
+          hash['backend_port'] = load_balancing_rule_prop['backendPort']
+          hash['probe_id'] = load_balancing_rule_prop['probe']['id'] unless load_balancing_rule_prop['probe'].nil?
+          hash['enable_floating_ip'] = load_balancing_rule_prop['enableFloatingIP']
+          hash['idle_timeout_in_minutes'] = load_balancing_rule_prop['idleTimeoutInMinutes']
+          hash['load_distribution'] = load_balancing_rule_prop['loadDistribution']
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -7,10 +7,52 @@ module Fog
         attribute :id
         attribute :location
         attribute :resource_group
-        attribute :subnet_id
+        attribute :virtual_machine_id
+        attribute :mac_address
+        attribute :network_security_group_id
         attribute :ip_configuration_name
+        attribute :ip_configuration_id
+        attribute :subnet_id
         attribute :private_ip_allocation_method
-        attribute :properties
+        attribute :private_ip_address
+        attribute :public_ip_address_id
+        attribute :load_balancer_backend_address_pools_ids
+        attribute :load_balancer_inbound_nat_rules_ids
+        attribute :dns_servers
+        attribute :applied_dns_servers
+        attribute :internal_dns_name_label
+        attribute :internal_fqd
+
+        def self.parse(nic)
+          nic_properties = nic['properties']
+          nic_ip_configuration = nic['properties']['ipConfigurations'][0]
+          hash = {}
+          hash['id'] = nic['id']
+          hash['name'] = nic['name']
+          hash['location'] = nic['location']
+          hash['resource_group'] = nic['id'].split('/')[4]
+          hash['virtual_machine_id'] = nic_properties['virtualMachine']['id'] unless nic_properties['virtualMachine'].nil?
+          hash['mac_address'] = nic_properties['macAddress'] unless nic_properties['macAddress'].nil?
+          hash['network_security_group_id'] = nic_properties['networkSecurityGroup']['id'] unless nic_properties['networkSecurityGroup'].nil?
+
+          unless nic_ip_configuration.nil?
+            nic_ip_configuration_properties = nic_ip_configuration['properties']
+            hash['ip_configuration_name'] = nic_ip_configuration['name']
+            hash['ip_configuration_id'] = nic_ip_configuration['id']
+            hash['subnet_id'] = nic_ip_configuration_properties['subnet']['id'] unless nic_ip_configuration_properties['subnet'].nil?
+            hash['private_ip_allocation_method'] = nic_ip_configuration_properties['privateIPAllocationMethod']
+            hash['private_ip_address'] = nic_ip_configuration_properties['privateIPAddress']
+            hash['public_ip_address_id'] = nic_ip_configuration_properties['publicIPAddress']['id'] unless nic_ip_configuration_properties['publicIPAddress'].nil?
+            hash['load_balancer_backend_address_pools_ids'] = nic_ip_configuration_properties['loadBalancerBackendAddressPools'].map{ |item| item['id'] } unless nic_ip_configuration_properties['loadBalancerBackendAddressPools'].nil?
+            hash['load_balancer_inbound_nat_rules_ids'] = nic_ip_configuration_properties['loadBalancerInboundNatRules'].map{ |item| item['id'] } unless nic_ip_configuration_properties['loadBalancerInboundNatRules'].nil?
+          end
+
+          hash['dns_servers'] = nic_properties['dnsSettings']['dnsServers']
+          hash['applied_dns_servers'] = nic_properties['appliedDnsServers']
+          hash['internal_dns_name_label'] = nic_properties['internalDnsNameLabel']
+          hash['internal_fqd'] = nic_properties['internalFqd']
+          hash
+        end
 
         def save
           requires :name
@@ -19,11 +61,8 @@ module Fog
           requires :subnet_id
           requires :ip_configuration_name
           requires :private_ip_allocation_method
-
-          Fog::Logger.debug "Creating Network Interface Card: #{name}..."
-          network_interface = service.create_network_interface(name, location, resource_group, subnet_id, ip_configuration_name, private_ip_allocation_method)
-          Fog::Logger.debug "Network Interface #{name} created successfully."
-          network_interface
+          network_interface = service.create_network_interface(resource_group, name, location, subnet_id, ip_configuration_name, private_ip_allocation_method)
+          merge_attributes(Fog::Network::AzureRM::NetworkInterface.parse(network_interface))
         end
 
         def destroy

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

@@ -12,14 +12,8 @@ module Fog
         def all
           requires :resource_group
           network_interfaces = []
-          network_interface_list = service.list_network_interfaces(resource_group)
-          network_interface_list.each do |nic|
-            hash = {}
-            nic.instance_variables.each do |var|
-              hash[var.to_s.delete('@')] = nic.instance_variable_get(var)
-            end
-            hash['resource_group'] = resource_group
-            network_interfaces << hash
+          service.list_network_interfaces(resource_group).each do |nic|
+            network_interfaces << Fog::Network::AzureRM::NetworkInterface.parse(nic)
           end
           load(network_interfaces)
         end

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

@@ -0,0 +1,89 @@
+module Fog
+  module Network
+    class AzureRM
+      # Subnet model for Network Security Group
+      class NetworkSecurityGroup < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :location
+        attribute :network_interfaces_ids
+        attribute :subnets_ids
+        attribute :security_rules
+        attribute :default_security_rules
+
+        def self.parse(nsg)
+          hash = {}
+          hash['id'] = nsg['id']
+          hash['name'] = nsg['name']
+          hash['resource_group'] = nsg['id'].split('/')[4]
+          hash['location'] = nsg['location']
+          hash['network_interfaces_ids'] = nsg['properties']['networkInterfaces'].map { |item| item['id'] } unless nsg['properties']['networkInterfaces'].nil?
+          hash['subnets_ids'] = nsg['properties']['subnets'].map { |item| item['id'] } unless nsg['properties']['subnets'].nil?
+          hash['security_rules'] = []
+          hash['default_security_rules'] = []
+
+          nsg['properties']['securityRules'].each do |sr|
+            security_rule = Fog::Network::AzureRM::NetworkSecurityRule.new
+            hash['security_rules'] << security_rule.merge_attributes(Fog::Network::AzureRM::NetworkSecurityRule.parse(sr))
+          end unless nsg['properties']['securityRules'].nil?
+
+          nsg['properties']['defaultSecurityRules'].each do |dsr|
+            security_rule = Fog::Network::AzureRM::NetworkSecurityRule.new
+            hash['default_security_rules'] << security_rule.merge_attributes(Fog::Network::AzureRM::NetworkSecurityRule.parse(dsr))
+          end
+
+          hash
+        end
+
+        def save
+          requires :name, :location, :resource_group
+
+          validate_security_rules(security_rules) unless security_rules.nil?
+          nsg = service.create_network_security_group(resource_group, name, location, security_rules)
+          merge_attributes(Fog::Network::AzureRM::NetworkSecurityGroup.parse(nsg))
+        end
+
+        def destroy
+          service.delete_network_security_group(resource_group, name)
+        end
+
+        private
+
+        def validate_security_rules(security_rules)
+          if security_rules.is_a?(Array)
+            security_rules.each do |sr|
+              if sr.is_a?(Hash)
+                validate_security_rule_params(sr)
+              else
+                raise(ArgumentError, ':security_rules must be an Array of Hashes')
+              end
+            end
+          else
+            raise(ArgumentError, ':security_rules must be an Array')
+          end
+        end
+
+        def validate_security_rule_params(nsr)
+          required_params = [
+            :name,
+            :protocol,
+            :source_port_range,
+            :destination_port_range,
+            :source_address_prefix,
+            :destination_address_prefix,
+            :access,
+            :priority,
+            :direction
+          ]
+          missing = required_params.select { |p| p unless nsr.key?(p) }
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')} and #{missing[-1]} are required for this operation")
+          end
+        end
+      end
+    end
+  end
+end