fog-azure-rm-temp 0.0.1

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

@@ -0,0 +1,36 @@
+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
+          load_balancers = []
+          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)
+        end
+
+        def get(resource_group_name, load_balancer_name)
+          load_balancer = service.get_load_balancer(resource_group_name, load_balancer_name)
+          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
+end

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

@@ -0,0 +1,37 @@
+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)
+          hash = {}
+          hash['id'] = load_balancing_rule.id
+          hash['name'] = load_balancing_rule.name
+          hash['frontend_ip_configuration_id'] = load_balancing_rule.frontend_ipconfiguration.id unless load_balancing_rule.frontend_ipconfiguration.nil?
+          hash['backend_address_pool_id'] = load_balancing_rule.backend_address_pool.id unless load_balancing_rule.backend_address_pool.nil?
+
+          hash['protocol'] = load_balancing_rule.protocol
+          hash['frontend_port'] = load_balancing_rule.frontend_port
+          hash['backend_port'] = load_balancing_rule.backend_port
+          hash['probe_id'] = load_balancing_rule.probe.id unless load_balancing_rule.probe.nil?
+          hash['enable_floating_ip'] = load_balancing_rule.enable_floating_ip
+          hash['idle_timeout_in_minutes'] = load_balancing_rule.idle_timeout_in_minutes
+          hash['load_distribution'] = load_balancing_rule.load_distribution
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Fog
+  module Network
+    class AzureRM
+      # LocalNetworkGateway model class for Network Service
+      class LocalNetworkGateway < Fog::Model
+        identity :name
+        attribute :id
+        attribute :location
+        attribute :type
+        attribute :resource_group
+        attribute :tags
+        attribute :local_network_address_space_prefixes
+        attribute :gateway_ip_address
+        attribute :asn
+        attribute :bgp_peering_address
+        attribute :peer_weight
+        attribute :provisioning_state
+
+        def self.parse(local_network_gateway)
+          local_network_gateway_hash = get_hash_from_object(local_network_gateway)
+          bgp_settings = local_network_gateway.bgp_settings
+          unless bgp_settings.nil?
+            local_network_gateway_hash['asn'] = bgp_settings.asn
+            local_network_gateway_hash['bgp_peering_address'] = bgp_settings.bgp_peering_address
+            local_network_gateway_hash['peer_weight'] = bgp_settings.peer_weight
+          end
+          local_network_address_space = local_network_gateway.local_network_address_space
+          local_network_gateway_hash['local_network_address_space_prefixes'] = local_network_address_space.address_prefixes unless local_network_address_space.nil?
+          local_network_gateway_hash['resource_group'] = get_resource_group_from_id(local_network_gateway.id)
+          local_network_gateway_hash
+        end
+
+        def save
+          requires :name, :location, :resource_group, :local_network_address_space_prefixes, :gateway_ip_address, :asn, :bgp_peering_address, :peer_weight
+          local_network_gateway = service.create_or_update_local_network_gateway(local_network_gateway_parameters)
+          merge_attributes(Fog::Network::AzureRM::LocalNetworkGateway.parse(local_network_gateway))
+        end
+
+        def destroy
+          service.delete_local_network_gateway(resource_group, name)
+        end
+
+        private
+
+        def local_network_gateway_parameters
+          {
+            name: name,
+            location: location,
+            resource_group: resource_group,
+            local_network_address_space_prefixes: local_network_address_space_prefixes,
+            gateway_ip_address: gateway_ip_address,
+            asn: asn,
+            bgp_peering_address: bgp_peering_address,
+            peer_weight: peer_weight
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Fog
+  module Network
+    class AzureRM
+      # LocalNetworkGateways collection class for Network Service
+      class LocalNetworkGateways < Fog::Collection
+        model Fog::Network::AzureRM::LocalNetworkGateway
+        attribute :resource_group
+
+        def all
+          requires :resource_group
+          local_network_gateways = service.list_local_network_gateways(resource_group).map { |gateway| Fog::Network::AzureRM::LocalNetworkGateway.parse(gateway) }
+          load(local_network_gateways)
+        end
+
+        def get(resource_group_name, name)
+          local_network_gateway = service.get_local_network_gateway(resource_group_name, name)
+          local_network_gateway_fog = Fog::Network::AzureRM::LocalNetworkGateway.new(service: service)
+          local_network_gateway_fog.merge_attributes(Fog::Network::AzureRM::LocalNetworkGateway.parse(local_network_gateway))
+        end
+
+        def check_local_net_gateway_exists(resource_group_name, name)
+          service.check_local_net_gateway_exists(resource_group_name, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+module Fog
+  module Network
+    class AzureRM
+      # NetworkInterface model class for Network Service
+      class NetworkInterface < Fog::Model
+        identity :name
+        attribute :id
+        attribute :location
+        attribute :resource_group
+        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 :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
+        attribute :type
+
+        def self.parse(nic)
+          hash = {}
+          hash['id'] = nic.id
+          hash['name'] = nic.name
+          hash['location'] = nic.location
+          hash['resource_group'] = get_resource_from_resource_id(nic.id, RESOURCE_GROUP_NAME)
+          hash['virtual_machine_id'] = nic.virtual_machine.id unless nic.virtual_machine.nil?
+          hash['mac_address'] = nic.mac_address unless nic.mac_address.nil?
+          hash['network_security_group_id'] = nil
+          hash['network_security_group_id'] = nic.network_security_group.id unless nic.network_security_group.nil?
+          hash['type'] = nic.type
+          ip_configuration = nic.ip_configurations[0] unless nic.ip_configurations.nil?
+          unless ip_configuration.nil?
+            hash['ip_configuration_name'] = ip_configuration.name
+            hash['ip_configuration_id'] = ip_configuration.id
+            hash['subnet_id'] = ip_configuration.subnet.id unless ip_configuration.subnet.nil?
+            hash['private_ip_allocation_method'] = ip_configuration.private_ipallocation_method
+            hash['private_ip_address'] = ip_configuration.private_ipaddress
+            hash['public_ip_address_id'] = nil
+            hash['public_ip_address_id'] = ip_configuration.public_ipaddress.id unless ip_configuration.public_ipaddress.nil?
+            hash['load_balancer_backend_address_pools_ids'] = ip_configuration.load_balancer_backend_address_pools.map(&:id) unless ip_configuration.load_balancer_backend_address_pools.nil?
+            hash['load_balancer_inbound_nat_rules_ids'] = ip_configuration.load_balancer_inbound_nat_rules.map(&:id) unless ip_configuration.load_balancer_inbound_nat_rules.nil?
+          end
+          nic_dns_settings = nic.dns_settings
+          unless nic_dns_settings.nil?
+            hash['dns_servers'] = nic_dns_settings.dns_servers
+            hash['applied_dns_servers'] = nic_dns_settings.applied_dns_servers
+            hash['internal_dns_name_label'] = nic_dns_settings.internal_dns_name_label
+            hash['internal_fqd'] = nic_dns_settings.internal_fqdn
+          end
+          hash
+        end
+
+        def save
+          requires :name
+          requires :location
+          requires :resource_group
+          requires :subnet_id
+          requires :ip_configuration_name
+          requires :private_ip_allocation_method
+          nic = service.create_or_update_network_interface(resource_group, name, location, subnet_id, public_ip_address_id, network_security_group_id, ip_configuration_name, private_ip_allocation_method, private_ip_address, load_balancer_backend_address_pools_ids, load_balancer_inbound_nat_rules_ids)
+          merge_attributes(Fog::Network::AzureRM::NetworkInterface.parse(nic))
+        end
+
+        def update(updated_attributes = {})
+          validate_update_attributes!(updated_attributes)
+          merge_attributes(updated_attributes)
+          nic = service.create_or_update_network_interface(resource_group, name, location, subnet_id, public_ip_address_id, network_security_group_id, ip_configuration_name, private_ip_allocation_method, private_ip_address)
+          merge_attributes(Fog::Network::AzureRM::NetworkInterface.parse(nic))
+        end
+
+        def attach_subnet(subnet_id)
+          raise 'Subnet ID can not be nil.' if subnet_id.nil?
+          nic = service.attach_resource_to_nic(resource_group, name, SUBNET, subnet_id)
+          merge_attributes(Fog::Network::AzureRM::NetworkInterface.parse(nic))
+        end
+
+        def attach_public_ip(public_ip_id)
+          raise 'Public-IP ID can not be nil.' if public_ip_id.nil?
+          nic = service.attach_resource_to_nic(resource_group, name, PUBLIC_IP, public_ip_id)
+          merge_attributes(Fog::Network::AzureRM::NetworkInterface.parse(nic))
+        end
+
+        def attach_network_security_group(network_security_group_id)
+          raise 'Network-Security-Group ID can not be nil.' if network_security_group_id.nil?
+          nic = service.attach_resource_to_nic(resource_group, name, NETWORK_SECURITY_GROUP, network_security_group_id)
+          merge_attributes(Fog::Network::AzureRM::NetworkInterface.parse(nic))
+        end
+
+        def detach_public_ip
+          raise "Error detaching Public IP. No Public IP is attached to Network Interface #{name}" if public_ip_address_id.nil?
+          nic = service.detach_resource_from_nic(resource_group, name, PUBLIC_IP)
+          merge_attributes(Fog::Network::AzureRM::NetworkInterface.parse(nic))
+        end
+
+        def detach_network_security_group
+          raise "Error detaching Network Security Group. No Security Group is attached to Network Interface #{name}" if network_security_group_id.nil?
+          nic = service.detach_resource_from_nic(resource_group, name, NETWORK_SECURITY_GROUP)
+          merge_attributes(Fog::Network::AzureRM::NetworkInterface.parse(nic))
+        end
+
+        def destroy
+          service.delete_network_interface(resource_group, name)
+        end
+
+        def validate_update_attributes!(hash)
+          restricted_attributes = [:name, :id, :resource_group, :location, :ip_configuration_name, :ip_configuration_id]
+          hash_keys = hash.keys
+          invalid_attributes = restricted_attributes & hash_keys
+          raise "Attributes #{invalid_attributes.join(', ')} can not be updated." unless invalid_attributes.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Fog
+  module Network
+    class AzureRM
+      # NetworkInterfaces collection class for Network Service
+      class NetworkInterfaces < Fog::Collection
+        model Fog::Network::AzureRM::NetworkInterface
+        attribute :resource_group
+
+        def all
+          requires :resource_group
+          network_interfaces = []
+          service.list_network_interfaces(resource_group).each do |nic|
+            network_interfaces << Fog::Network::AzureRM::NetworkInterface.parse(nic)
+          end
+          load(network_interfaces)
+        end
+
+        def get(resource_group_name, name)
+          network_interface_card = service.get_network_interface(resource_group_name, name)
+          network_interface_card_fog = Fog::Network::AzureRM::NetworkInterface.new(service: service)
+          network_interface_card_fog.merge_attributes(Fog::Network::AzureRM::NetworkInterface.parse(network_interface_card))
+        end
+
+        def check_network_interface_exists(resource_group_name, name)
+          service.check_network_interface_exists(resource_group_name, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+module Fog
+  module Network
+    class AzureRM
+      # Network Security Group model for Network Service
+      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'] = get_resource_from_resource_id(nsg.id, RESOURCE_GROUP_NAME)
+          hash['location'] = nsg.location
+          hash['network_interfaces_ids'] = nsg.network_interfaces.map(&:id) unless nsg.network_interfaces.nil?
+          hash['subnets_ids'] = nsg.subnets.map(&:id) unless nsg.subnets.nil?
+          hash['security_rules'] = []
+          hash['default_security_rules'] = []
+
+          nsg.security_rules.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.security_rules.nil?
+
+          nsg.default_security_rules.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_or_update_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
+
+        def update_security_rules(security_rule_hash = {})
+          raise('Provided hash can not be empty.') if security_rule_hash.empty? || security_rule_hash.nil?
+
+          if !security_rule_hash[:security_rules].nil? && security_rule_hash.length == 1
+            validate_security_rules(security_rule_hash[:security_rules])
+            merge_attributes(security_rule_hash)
+            nsg = service.create_or_update_network_security_group(resource_group, name, location, security_rules)
+            return merge_attributes(Fog::Network::AzureRM::NetworkSecurityGroup.parse(nsg))
+          end
+          raise 'Invalid hash key.'
+        end
+
+        def add_security_rules(security_rules)
+          validate_security_rules(security_rules)
+          nsg = service.add_security_rules(resource_group, name, security_rules)
+          merge_attributes(Fog::Network::AzureRM::NetworkSecurityGroup.parse(nsg))
+        end
+
+        def remove_security_rule(security_rule_name)
+          nsg = service.remove_security_rule(resource_group, name, security_rule_name)
+          merge_attributes(Fog::Network::AzureRM::NetworkSecurityGroup.parse(nsg))
+        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, 'Parameter security_rules must be an Array of Hashes')
+              end
+            end
+          else
+            raise(ArgumentError, 'Parameter 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

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

@@ -0,0 +1,30 @@
+module Fog
+  module Network
+    class AzureRM
+      # collection class for Network Security Group
+      class NetworkSecurityGroups < Fog::Collection
+        model Fog::Network::AzureRM::NetworkSecurityGroup
+        attribute :resource_group
+
+        def all
+          requires :resource_group
+          network_security_groups = []
+          service.list_network_security_groups(resource_group).each do |nsg|
+            network_security_groups << Fog::Network::AzureRM::NetworkSecurityGroup.parse(nsg)
+          end
+          load(network_security_groups)
+        end
+
+        def get(resource_group, name)
+          network_security_group = service.get_network_security_group(resource_group, name)
+          network_security_group_fog = Fog::Network::AzureRM::NetworkSecurityGroup.new(service: service)
+          network_security_group_fog.merge_attributes(Fog::Network::AzureRM::NetworkSecurityGroup.parse(network_security_group))
+        end
+
+        def check_net_sec_group_exists(resource_group, name)
+          service.check_net_sec_group_exists(resource_group, name)
+        end
+      end
+    end
+  end
+end