fog-azure-rm 0.0.3 → 0.0.4

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

@@ -25,7 +25,7 @@ module Fog
 
         def self.parse(nic)
           nic_properties = nic['properties']
-          nic_ip_configuration = nic['properties']['ipConfigurations'][0]
+          nic_ip_configuration = nic_properties['ipConfigurations'][0]
           hash = {}
           hash['id'] = nic['id']
           hash['name'] = nic['name']
@@ -33,8 +33,8 @@ module Fog
           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'] = 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']
@@ -42,6 +42,7 @@ module Fog
             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'] = nil
             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?
@@ -61,13 +62,57 @@ module Fog
           requires :subnet_id
           requires :ip_configuration_name
           requires :private_ip_allocation_method
-          network_interface = service.create_network_interface(resource_group, name, location, subnet_id, public_ip_address_id, ip_configuration_name, private_ip_allocation_method)
-          merge_attributes(Fog::Network::AzureRM::NetworkInterface.parse(network_interface))
+          nic = service.create_or_update_network_interface(resource_group, name, location, subnet_id, public_ip_address_id, ip_configuration_name, private_ip_allocation_method, private_ip_address)
+          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, 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

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

@@ -18,8 +18,10 @@ module Fog
           load(network_interfaces)
         end
 
-        def get(identity)
-          all.find { |f| f.name == identity }
+        def get(resource_group_name, name)
+          nic = service.get_network_interface(resource_group_name, name)
+          network_interface_card = Fog::Network::AzureRM::NetworkInterface.new(service: service)
+          network_interface_card.merge_attributes(Fog::Network::AzureRM::NetworkInterface.parse(nic))
         end
       end
     end

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

@@ -1,7 +1,7 @@
 module Fog
   module Network
     class AzureRM
-      # Subnet model for Network Security Group
+      # Network Security Group model for Network Service
       class NetworkSecurityGroup < Fog::Model
         identity :name
         attribute :id
@@ -40,7 +40,7 @@ module Fog
           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)
+          nsg = service.create_or_update_network_security_group(resource_group, name, location, security_rules)
           merge_attributes(Fog::Network::AzureRM::NetworkSecurityGroup.parse(nsg))
         end
 
@@ -48,6 +48,29 @@ module Fog
           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)
@@ -56,11 +79,11 @@ module Fog
               if sr.is_a?(Hash)
                 validate_security_rule_params(sr)
               else
-                raise(ArgumentError, ':security_rules must be an Array of Hashes')
+                raise(ArgumentError, 'Parameter security_rules must be an Array of Hashes')
               end
             end
           else
-            raise(ArgumentError, ':security_rules must be an Array')
+            raise(ArgumentError, 'Parameter security_rules must be an Array')
           end
         end
 

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

@@ -18,8 +18,10 @@ module Fog
           load(network_security_groups)
         end
 
-        def get(identity)
-          all.find { |f| f.name == identity }
+        def get(resource_group, name)
+          nsg = service.get_network_security_group(resource_group, name)
+          network_security_group = Fog::Network::AzureRM::NetworkSecurityGroup.new(service: service)
+          network_security_group.merge_attributes(Fog::Network::AzureRM::NetworkSecurityGroup.parse(nsg))
         end
       end
     end

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

@@ -1,7 +1,7 @@
 module Fog
   module Network
     class AzureRM
-      # Subnet model for Network Service
+      # Security Rule model for Network Service
       class NetworkSecurityRule < Fog::Model
         identity :name
         attribute :id

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

@@ -16,20 +16,40 @@ module Fog
           hash = {}
           hash['id'] = subnet['id']
           hash['name'] = subnet['name']
-          hash['resource_group'] = subnet['id'].split('/')[4]
-          hash['virtual_network_name'] = subnet['id'].split('/')[8]
+          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['properties']['addressPrefix']
+          hash['network_security_group_id'] = nil
           hash['network_security_group_id'] = subnet['properties']['networkSecurityGroup']['id'] unless subnet['properties']['networkSecurityGroup'].nil?
+          hash['route_table_id'] = nil
           hash['route_table_id'] = subnet['properties']['routeTable']['id'] unless subnet['properties']['routeTable'].nil?
           hash['ip_configurations_ids'] = subnet['properties']['ipConfigurations'].map { |item| item['id'] } unless subnet['properties']['ipConfigurations'].nil?
           hash
         end
 
         def save
-          requires :name
-          requires :resource_group
-          requires :virtual_network_name
-          subnet = service.create_subnet(resource_group, name, virtual_network_name, address_prefix)
+          requires :name, :resource_group, :virtual_network_name, :address_prefix
+          subnet = service.create_subnet(resource_group, name, virtual_network_name, address_prefix, network_security_group_id, route_table_id)
+          merge_attributes(Fog::Network::AzureRM::Subnet.parse(subnet))
+        end
+
+        def attach_network_security_group(network_security_group_id)
+          subnet = service.attach_network_security_group_to_subnet(resource_group, name, virtual_network_name, address_prefix, route_table_id, network_security_group_id)
+          merge_attributes(Fog::Network::AzureRM::Subnet.parse(subnet))
+        end
+
+        def detach_network_security_group
+          subnet = service.detach_network_security_group_from_subnet(resource_group, name, virtual_network_name, address_prefix, route_table_id)
+          merge_attributes(Fog::Network::AzureRM::Subnet.parse(subnet))
+        end
+
+        def attach_route_table(route_table_id)
+          subnet = service.attach_route_table_to_subnet(resource_group, name, virtual_network_name, address_prefix, network_security_group_id, route_table_id)
+          merge_attributes(Fog::Network::AzureRM::Subnet.parse(subnet))
+        end
+
+        def detach_route_table
+          subnet = service.detach_route_table_from_subnet(resource_group, name, virtual_network_name, address_prefix, network_security_group_id)
           merge_attributes(Fog::Network::AzureRM::Subnet.parse(subnet))
         end
 

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

@@ -20,8 +20,10 @@ module Fog
           load(subnets)
         end
 
-        def get(identity)
-          all.find { |f| f.name == identity }
+        def get(resource_group, virtual_network_name, subnet_name)
+          subnet = service.get_subnet(resource_group, virtual_network_name, subnet_name)
+          subnet_object = Fog::Network::AzureRM::Subnet.new(service: service)
+          subnet_object.merge_attributes(Fog::Network::AzureRM::Subnet.parse(subnet))
         end
       end
     end

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

@@ -8,23 +8,25 @@ module Fog
         attribute :id
         attribute :location
         attribute :resource_group
-        attribute :dns_list
-        attribute :subnet_address_list
-        attribute :network_address_list
+        attribute :dns_servers
+        attribute :subnets
+        attribute :address_prefixes
 
         def self.parse(vnet)
           hash = {}
           hash['id'] = vnet['id']
           hash['name'] = vnet['name']
-          hash['resource_group'] = vnet['id'].split('/')[4]
+          hash['resource_group'] = get_resource_group_from_id(vnet['id'])
           hash['location'] = vnet['location']
-          hash['dns_list'] = vnet['properties']['dhcpOptions']['dnsServers'].join(',') unless vnet['properties']['dhcpOptions'].nil?
-          hash['network_address_list'] = vnet['properties']['addressSpace']['addressPrefixes'].join(',') unless vnet['properties']['addressSpace']['addressPrefixes'].nil?
-          subnet_address_list = []
+          hash['dns_servers'] = vnet['properties']['dhcpOptions']['dnsServers'] unless vnet['properties']['dhcpOptions'].nil?
+          hash['address_prefixes'] = vnet['properties']['addressSpace']['addressPrefixes'] unless vnet['properties']['addressSpace']['addressPrefixes'].nil?
+
+          subnets = []
           vnet['properties']['subnets'].each do |subnet|
-            subnet_address_list << subnet['properties']['addressPrefix']
+            subnet_object = Fog::Network::AzureRM::Subnet.new
+            subnets.push(subnet_object.merge_attributes(Fog::Network::AzureRM::Subnet.parse(subnet)))
           end
-          hash['subnet_address_list'] = subnet_address_list.join(',')
+          hash['subnets'] = subnets
           hash
         end
 
@@ -32,13 +34,73 @@ module Fog
           requires :name
           requires :location
           requires :resource_group
-          vnet = service.create_virtual_network(resource_group, name, location, dns_list, subnet_address_list, network_address_list)
+          validate_subnets!(subnets) unless subnets.nil?
+
+          vnet = service.create_or_update_virtual_network(resource_group, name, location, dns_servers, subnets, address_prefixes)
           merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(vnet))
         end
 
+        def add_dns_servers(dns_servers_list)
+          virtual_network = service.add_dns_servers_in_virtual_network(resource_group, name, dns_servers_list)
+          merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(virtual_network))
+        end
+
+        def remove_dns_servers(dns_servers_list)
+          virtual_network = service.remove_dns_servers_from_virtual_network(resource_group, name, dns_servers_list)
+          merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(virtual_network))
+        end
+
+        def add_address_prefixes(address_prefixes_list)
+          virtual_network = service.add_address_prefixes_in_virtual_network(resource_group, name, address_prefixes_list)
+          merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(virtual_network))
+        end
+
+        def remove_address_prefixes(address_prefixes_list)
+          virtual_network = service.remove_address_prefixes_from_virtual_network(resource_group, name, address_prefixes_list)
+          merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(virtual_network))
+        end
+
+        def add_subnets(subnets_list)
+          validate_subnets!(subnets_list)
+          virtual_network = service.add_subnets_in_virtual_network(resource_group, name, subnets_list)
+          merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(virtual_network))
+        end
+
+        def remove_subnets(subnet_names_list)
+          virtual_network = service.remove_subnets_from_virtual_network(resource_group, name, subnet_names_list)
+          merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(virtual_network))
+        end
+
+        def update(vnet_hash)
+          raise('Provided hash can not be empty.') if vnet_hash.empty? || vnet_hash.nil?
+          validate_update_attributes!(vnet_hash)
+          merge_attributes(vnet_hash)
+          virtual_network = service.create_or_update_virtual_network(resource_group, name, location, dns_servers, subnets, address_prefixes)
+          merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(virtual_network))
+        end
+
         def destroy
           service.delete_virtual_network(resource_group, name)
         end
+
+        private
+
+        def validate_update_attributes!(vnet_hash)
+          forbidden_attributes = [:id, :name, :location, :resource_group]
+          invalid_attributes = forbidden_attributes & vnet_hash.keys
+          raise "#{invalid_attributes.join(', ')} cannot be changed." if invalid_attributes.any?
+          validate_subnets!(vnet_hash[:subnets]) if vnet_hash.key?(:subnets)
+        end
+
+        def validate_subnets!(subnets)
+          raise ':subnets must be an Array' unless subnets.is_a?(Array)
+          raise ':subnets must not be an empty Array' if subnets.empty?
+
+          subnets.each do |subnet|
+            raise ':subnets must be an Array of Hashes' unless subnet.is_a?(Hash)
+            validate_params([:name, :address_prefix], subnet)
+          end
+        end
       end
     end
   end

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

@@ -19,8 +19,10 @@ module Fog
           load(virtual_networks)
         end
 
-        def get(identity)
-          all.find { |f| f.name == identity }
+        def get(resource_group_name, virtual_network_name)
+          virtual_network = service.get_virtual_network(resource_group_name, virtual_network_name)
+          virtual_network_object = Fog::Network::AzureRM::VirtualNetwork.new(service: service)
+          virtual_network_object.merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(virtual_network))
         end
 
         def check_if_exists(resource_group, name)

data/lib/fog/azurerm/models/resources/azure_resource.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Resources
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for resources.
+      class AzureResource < Fog::Model
+        attribute :id
+        attribute :name
+        attribute :type
+        attribute :location
+        attribute :tags
+
+        def self.parse(resource)
+          hash = {}
+          hash['id'] = resource['id']
+          hash['name'] = resource['name']
+          hash['type'] = resource['type']
+          hash['location'] = resource['location']
+          hash['tags'] = resource['tags']
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/resources/azure_resources.rb

@@ -0,0 +1,31 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/resources/azure_resource'
+
+module Fog
+  module Resources
+    class AzureRM
+      # This class is giving implementation of all/list and get.
+      class AzureResources < Fog::Collection
+        attribute :tag_name
+        attribute :tag_value
+        model Fog::Resources::AzureRM::AzureResource
+
+        def all
+          unless tag_name.nil? && tag_value.nil?
+            resources = []
+            service.list_tagged_resources(tag_name, tag_value).each do |resource|
+              resources << Fog::Resources::AzureRM::AzureResource.parse(resource)
+            end
+            resources.inspect
+            return load(resources)
+          end
+          nil
+        end
+
+        def get(resource_id)
+          all.find { |f| f.id == resource_id }
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/resources/dependency.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Resources
+    class AzureRM
+      # Dependency model class
+      class Dependency < Fog::Model
+        attribute :id
+        attribute :resource_name
+        attribute :resource_type
+        attribute :depends_on
+
+        def self.parse(dependency)
+          hash = {}
+          hash['id'] = dependency['id']
+          hash['resource_name'] = dependency['resourceName']
+          hash['resource_type'] = dependency['resourceType']
+
+          hash['depends_on'] = []
+          dependency['dependsOn'].each do |sub_dependency|
+            dependency_obj = Fog::Resources::AzureRM::Dependency.new
+            hash['depends_on'] << dependency_obj.merge_attributes(Fog::Resources::AzureRM::Dependency.parse(sub_dependency))
+          end unless dependency['dependsOn'].nil?
+          hash
+        end
+      end
+    end
+  end
+end