diff --git a/src/vmm_mad/remotes/lib/vcenter_driver/datacenter.rb b/src/vmm_mad/remotes/lib/vcenter_driver/datacenter.rb
index e12fb7d6d9..21214c8a70 100644
--- a/src/vmm_mad/remotes/lib/vcenter_driver/datacenter.rb
+++ b/src/vmm_mad/remotes/lib/vcenter_driver/datacenter.rb
@@ -372,12 +372,18 @@ class DatacenterFolder
     end
 
     # Determine if a network must be excluded from the list
-    def exclude_network?(vc_network, one_host, args)
+    def exclude_network?(vc_network, one_host, args, vc_network_hash)
+
+        vc_network_ref = vc_network_hash[:vc_network_ref]
+        vc_network_name = vc_network_hash[:vc_network_name]
+        vc_network_host = vc_network_hash[:vc_network_host]
+        vc_network_tag = vc_network_hash[:vc_network_tag]
+
         # Exclude some networks if filter = true
         if args[:filter]
             if ( one_host && one_host['TEMPLATE/NSX_PASSWORD'].nil?)
                 # Only NSX-V and NSX-T can be excluded
-                network_type = VCenterDriver::Network.get_network_type(vc_network)
+                network_type = VCenterDriver::Network.get_network_type(vc_network, vc_network_name)
                 if network_type == VCenterDriver::Network::NETWORK_TYPE_NSXT ||\
                    network_type == VCenterDriver::Network::NETWORK_TYPE_NSXV
 
@@ -385,17 +391,17 @@ class DatacenterFolder
                 end
             end
             # Exclude networks without hosts
-            if vc_network['host'].empty?
+            if vc_network_host.empty?
                 return true
             end
             # Exclude DVS uplinks
-            unless vc_network['tag'].empty?
-                if vc_network['tag'][0][:key] == 'SYSTEM/DVS.UPLINKPG'
+            unless vc_network_tag.empty?
+                if vc_network_tag[0][:key] == 'SYSTEM/DVS.UPLINKPG'
                     return true
                 end
             end
             # Exclude portgroup used for VXLAN communication in NSX
-            if vc_network['name'].match(/^vxw-vmknicPg-dvs-(.*)/)
+            if vc_network_name.match(/^vxw-vmknicPg-dvs-(.*)/)
                 return true
             end
             return false
@@ -413,71 +419,83 @@ class DatacenterFolder
 
         full_process = !args[:short]
 
+        vc_network_ref = vc_network._ref
+        vc_network_name = vc_network.name
+        vc_network_host = vc_network['host']
+        vc_network_tag = vc_network['tag']
+
+        vc_network_hash = {}
+        vc_network_hash[:vc_network_ref] = vc_network_ref
+        vc_network_hash[:vc_network_name] = vc_network_name
+        vc_network_hash[:vc_network_host] = vc_network_host
+        vc_network_hash[:vc_network_tag] = vc_network_tag
+
         # Initialize network hash
         network = {}
         # Add name to network hash
-        network[vc_network._ref] = {'name' => vc_network.name}
+        network[vc_network_ref] = {'name' => vc_network_name}
         # By default no network is excluded
-        network[vc_network._ref][:excluded] = false
+        network[vc_network_ref][:excluded] = false
 
         # Initialize opts hash used to inject data into one template
         opts = {}
 
         if full_process
             # Add network type to network hash
-            network_type = VCenterDriver::Network.get_network_type(vc_network)
-            network[vc_network._ref][:network_type] = network_type
+            network_type = VCenterDriver::Network.get_network_type(vc_network, vc_network_name)
+            network[vc_network_ref][:network_type] = network_type
         end
 
         # Determine if the network must be excluded
-        network[vc_network._ref][:excluded] =  exclude_network?(vc_network,
+        network[vc_network_ref][:excluded] =  exclude_network?(vc_network,
                                                                one_host,
-                                                               args)
-        return nil if network[vc_network._ref][:excluded] == true
+                                                               args,
+                                                               vc_network_hash)
+        return nil if network[vc_network_ref][:excluded] == true
 
         if full_process
-        case network[vc_network._ref][:network_type]
+        case network[vc_network_ref][:network_type]
         # Distributed PortGroups
         when VCenterDriver::Network::NETWORK_TYPE_DPG
-            network[vc_network._ref][:sw_name] = \
+            network[vc_network_ref][:sw_name] = \
                 vc_network.config.distributedVirtualSwitch.name
             # For DistributedVirtualPortgroups there is networks and uplinks
-            network[vc_network._ref][:uplink] = \
+            network[vc_network_ref][:uplink] = \
                 vc_network.config.uplink
-            #network[vc_network._ref][:uplink] = false
+            #network[vc_network_ref][:uplink] = false
         # NSX-V PortGroups
         when VCenterDriver::Network::NETWORK_TYPE_NSXV
-            network[vc_network._ref][:sw_name] = \
+            network[vc_network_ref][:sw_name] = \
                 vc_network.config.distributedVirtualSwitch.name
             # For NSX-V ( is the same as DistributedVirtualPortgroups )
             # there is networks and uplinks
-            network[vc_network._ref][:uplink] = \
+            network[vc_network_ref][:uplink] = \
                 vc_network.config.uplink
-                network[vc_network._ref][:uplink] = false
+                network[vc_network_ref][:uplink] = false
         # Standard PortGroups
         when VCenterDriver::Network::NETWORK_TYPE_PG
             # There is no uplinks for standard portgroups, so all Standard
             # PortGroups are networks and no uplinks
-            network[vc_network._ref][:uplink] = false
-            network[vc_network._ref][:sw_name] = vSwitch(vc_network)
+            network[vc_network_ref][:uplink] = false
+            network[vc_network_ref][:sw_name] = vSwitch(vc_network)
         # NSX-T PortGroups
         when VCenterDriver::Network::NETWORK_TYPE_NSXT
-            network[vc_network._ref][:sw_name] = \
+            network[vc_network_ref][:sw_name] = \
                 vc_network.summary.opaqueNetworkType
             # There is no uplinks for NSX-T networks, so all NSX-T networks
             # are networks and no uplinks
-            network[vc_network._ref][:uplink] = false
+            network[vc_network_ref][:uplink] = false
         else
             raise 'Unknown network type: ' \
-                  "#{network[vc_network._ref][:network_type]}"
+                  "#{network[vc_network_ref][:network_type]}"
         end
         end
 
         # Multicluster nets support
-        network[vc_network._ref][:clusters] = {}
-        network[vc_network._ref][:clusters][:refs] = []
-        network[vc_network._ref][:clusters][:one_ids] = []
-        network[vc_network._ref][:clusters][:names] = []
+        network[vc_network_ref][:clusters] = {}
+        network[vc_network_ref][:clusters][:refs] = []
+        network[vc_network_ref][:clusters][:one_ids] = []
+        network[vc_network_ref][:clusters][:names] = []
 
         # Get hosts related to this network and add them if is not
         # excluded
@@ -485,47 +503,50 @@ class DatacenterFolder
         vc_hosts.each do |vc_host|
             # Get vCenter Cluster
             vc_cluster = vc_host.parent
+            vc_cluster_ref = vc_cluster._ref
+            vc_cluster_name = vc_cluster.name
             # Get one host from each vCenter cluster
             one_host = VCenterDriver::VIHelper
                        .find_by_ref(OpenNebula::HostPool,
                                     "TEMPLATE/VCENTER_CCR_REF",
-                                    vc_cluster._ref,
+                                    vc_cluster_ref,
                                     vcenter_uuid)
             # Check if network is excluded from each host
-            next if exclude_network?(vc_network,one_host,args)
+            next if exclude_network?(vc_network,one_host,args, vc_network_hash)
             # Insert vCenter cluster ref
-            network[vc_network._ref][:clusters][:refs] << vc_cluster._ref
+            network[vc_network_ref][:clusters][:refs] << vc_cluster_ref
             # Insert OpenNebula cluster id
             cluster_id = one_cluster_id(one_host)
-            network[vc_network._ref][:clusters][:one_ids] << cluster_id
+            network[vc_network_ref][:clusters][:one_ids] << cluster_id
             # Insert vCenter cluster name
-            network[vc_network._ref][:clusters][:names] << vc_cluster.name
-            opts[:dc_name] = vc_cluster.name
+            network[vc_network_ref][:clusters][:names] << vc_cluster_name
+
+            opts[:dc_name] = vc_cluster_name
         end
 
         # Remove duplicate entries
-        network[vc_network._ref][:clusters][:refs].uniq!
-        network[vc_network._ref][:clusters][:one_ids].uniq!
-        network[vc_network._ref][:clusters][:names].uniq!
+        network[vc_network_ref][:clusters][:refs].uniq!
+        network[vc_network_ref][:clusters][:one_ids].uniq!
+        network[vc_network_ref][:clusters][:names].uniq!
 
         # Mark network as processed
-        network[vc_network._ref][:processed] = true
+        network[vc_network_ref][:processed] = true
 
         if full_process
         # General net_info related to datacenter
         opts[:vcenter_uuid] = vcenter_uuid
         opts[:vcenter_instance_name] = vcenter_instance_name
-        opts[:network_name] = network[vc_network._ref]['name']
+        opts[:network_name] = network[vc_network_ref]['name']
         opts[:network_ref]  = network.keys.first
-        opts[:network_type] = network[vc_network._ref][:network_type]
-        opts[:sw_name] = network[vc_network._ref][:sw_name]
+        opts[:network_type] = network[vc_network_ref][:network_type]
+        opts[:sw_name] = network[vc_network_ref][:sw_name]
 
-        network[vc_network._ref] = \
-            network[vc_network._ref].merge(VCenterDriver::Network
+        network[vc_network_ref] = \
+            network[vc_network_ref].merge(VCenterDriver::Network
                                                     .to_one_template(opts))
         else
-          network[vc_network._ref][:ref] = vc_network._ref
-          network[vc_network._ref][:name] = network[vc_network._ref]['name']
+          network[vc_network_ref][:ref] = vc_network_ref
+          network[vc_network_ref][:name] = network[vc_network_ref]['name']
         end
 
         network
diff --git a/src/vmm_mad/remotes/lib/vcenter_driver/network.rb b/src/vmm_mad/remotes/lib/vcenter_driver/network.rb
index 30a43b914b..d384d29f1c 100644
--- a/src/vmm_mad/remotes/lib/vcenter_driver/network.rb
+++ b/src/vmm_mad/remotes/lib/vcenter_driver/network.rb
@@ -248,10 +248,10 @@ class Network
         one_vn
     end
 
-    def self.get_network_type(network)
+    def self.get_network_type(network, network_name)
         case network
         when RbVmomi::VIM::DistributedVirtualPortgroup
-            if network['name']
+            if network_name
               .match(/^vxw-dvs-(.*)-virtualwire-(.*)-sid-(.*)/)
                 VCenterDriver::Network::NETWORK_TYPE_NSXV
             else
@@ -383,7 +383,7 @@ class NetImporter < VCenterDriver::VcImporter
     end
 
     def get_list(args = {})
-	    dc_folder = VCenterDriver::DatacenterFolder.new(@vi_client)
+        dc_folder = VCenterDriver::DatacenterFolder.new(@vi_client)
 
         # OpenNebula's VirtualNetworkPool
         npool = VCenterDriver::VIHelper.one_pool(OpenNebula::VirtualNetworkPool, false)
diff --git a/src/vmm_mad/remotes/lib/vcenter_driver/vm_template.rb b/src/vmm_mad/remotes/lib/vcenter_driver/vm_template.rb
index d161adf3d4..c1146eb892 100644
--- a/src/vmm_mad/remotes/lib/vcenter_driver/vm_template.rb
+++ b/src/vmm_mad/remotes/lib/vcenter_driver/vm_template.rb
@@ -835,7 +835,7 @@ class Template
 
         res[:net_name]  = deviceNetwork.name
         res[:net_ref]   = deviceNetwork._ref
-        res[:pg_type]   = VCenterDriver::Network.get_network_type(deviceNetwork)
+        res[:pg_type]   = VCenterDriver::Network.get_network_type(deviceNetwork, res[:net_name])
         res[:network]   = deviceNetwork
 
         res